routingtable.cc

AODV

/************************************************************************
			       ---AODV-UIUC---
			       
This software can be used under GNU General Public License.

Author: Binita Gupta <[e-mail]>
	University of Illinois, Urbana-Champaign
************************************************************************/


#include "common.h"
#include "externDec.h"

void		neighborTimeoutHandler(void *data);


void		routingTable::init_rTable()
{
#ifdef DEBUG
	cout << "init_rTable: entered" << endl;
#endif
	rtable_entry	rtEntry;
	rtEntry.initMyRtableEntry();
	insertRoute(rtEntry);

}

void		routingTable::addRoute(rtable_entry rtEntry)
{
	rTableMap.insert(pair<u_int32_t,rtable_entry>(rtEntry.getDestIP(),rtEntry));
	return;
}

void		routingTable::insertRoute(rtable_entry rtEntry)
{
	rTableMap.insert(pair<u_int32_t,rtable_entry>(rtEntry.getDestIP(),rtEntry));
	/* insert this route in kernel also */
	map<u_int32_t,rtable_entry>::iterator	iter;

#ifdef DEBUG
	cout << "insertRoute: entered" << endl;
#endif
	iter = findRouteIter(rtEntry.getDestIP());
	add_kroute(iter);

}

void		routingTable::addAllValidRoutes()
{
	map<u_int32_t,rtable_entry>::iterator	iter;

	iter = rTableMap.begin();
	while(iter != rTableMap.end())
	{
		if(iter->second.getRFlags() == ACTIVE_ROUTE)
		{
			/* add this route to the kernel */
			add_kroute(iter);
		}
		iter++;
	}
	return;
}

u_int32_t	routingTable::getDestSeqNum(u_int32_t dst)
{
	map<u_int32_t,rtable_entry>::iterator	iter;

	iter = rTableMap.find(dst);

	if(iter != rTableMap.end())
		return (iter->second.getDestSeqNum());
	else
		return 0;

}

void		routingTable::setDestSeqNum(u_int32_t	dst, u_int32_t seqNum)
{
	map<u_int32_t,rtable_entry>::iterator	iter;

	iter = rTableMap.find(dst);
	if(iter != rTableMap.end())
	{
		iter->second.setDestSeqNum(seqNum);
	}
}

u_int8_t	routingTable::getTTL(u_int32_t dst)
{
	map<u_int32_t,rtable_entry>::iterator	iter;
	iter = rTableMap.find(dst);

	if(iter != rTableMap.end())
	{
		if(isRouteValid(iter))
			return iter->second.getHopCnt();
		else
			return iter->second.getLastHopCnt();
	}
	else
		return 0;

}

void		routingTable::setLifeTime(u_int32_t dst, u_int64_t lifetime)
{
	map<u_int32_t,rtable_entry>::iterator	iter;
	iter = rTableMap.find(dst);

	if(iter != rTableMap.end())
	{
		iter->second.setLifeTime(lifetime);
	}
	return;
}

bool	routingTable::isRouteValid(map<u_int32_t,rtable_entry>::iterator iter)
{
	if((iter->second.getHopCnt() != INFINITY) && (iter->second.getLifeTime() > getcurrtime()))
		return true;
	else 
		return false;

}

void	routingTable::updateDestSeqNum(u_int32_t dest, u_int32_t seqNum)
{
	map<u_int32_t,rtable_entry>::iterator	iter;

	iter = rTableMap.find(dest);

	if(iter != rTableMap.end())
	{
		if(iter->second.getDestSeqNum() < seqNum)
			iter->second.setDestSeqNum(seqNum);
	}
	return;
}


rtable_entry*	routingTable::findRoute(u_int32_t dest)
{
	map<u_int32_t,rtable_entry>::iterator	iter;

	iter = rTableMap.find(dest);
	if(iter != rTableMap.end())
		return &(iter->second);
	else
		return NULL;
}


map<u_int32_t,rtable_entry>::iterator	routingTable::findRouteIter(u_int32_t dest)
{
	map<u_int32_t,rtable_entry>::iterator	iter;

	iter = rTableMap.find(dest);
	if(iter != rTableMap.end())
		return iter;
	else
		return NULL;

}	

/* add/update reverse route entry during reboot time */
void		routingTable::rebootReverseRouteUpdate(u_int32_t nhop, RREQ *rreqOb)
{
	u_int64_t	minLifeTime;
	map<u_int32_t,rtable_entry>::iterator	iter;

#ifdef DEBUG
	cout << "routingTable: rebootReverseRouteUpdate:\
	   	entered " << endl;
#endif

	iter = rTableMap.find(rreqOb->getSrcIP());
	if(iter != rTableMap.end())
	{
#ifdef DEBUG
		cout << "routingTable: rebootReverseRouteUpdate: route already exist " << endl;
#endif
		if(iter->second.getRFlags() == ACTIVE_ROUTE)
		{
#ifdef DEBUG
			cout << "routinTable: rebootReverseRouteUpdate: a valid route already exist " << endl;
#endif

			/* a route to the source already exist */
			if((rreqOb->getSrcSeqNum() > iter->second.getDestSeqNum()) ||
			 ((rreqOb->getSrcSeqNum() == iter->second.getDestSeqNum()) && 
			 ((rreqOb->getHopCnt()+1) < iter->second.getHopCnt())))
			{
				iter->second.setDestSeqNum(rreqOb->getSrcSeqNum());
				iter->second.setNextHop(nhop);
				iter->second.setHopCnt((rreqOb->getHopCnt()+1));
				minLifeTime = getcurrtime()+PATH_TRAVERSAL_TIME - 2*iter->second.getHopCnt()*NODE_TRAVERSAL_TIME;
				if(minLifeTime > iter->second.getLifeTime())
					iter->second.setLifeTime(minLifeTime);
			}
		}
		else
		{
#ifdef DEBUG
			cout << "routingTable: rebootReverseRouteUpdate: an invalid route exist " << endl;
#endif

			iter->second.setDestSeqNum(rreqOb->getSrcSeqNum());
			iter->second.setNextHop(nhop);
			iter->second.setHopCnt((rreqOb->getHopCnt()+1));
			iter->second.setRFlags(ACTIVE_ROUTE);

			minLifeTime = getcurrtime()+PATH_TRAVERSAL_TIME - 2*iter->second.getHopCnt()*NODE_TRAVERSAL_TIME;
			iter->second.setLifeTime(minLifeTime);
		}
	}
	else
	{
		rtable_entry	rtEntry;
		minLifeTime = getcurrtime()+PATH_TRAVERSAL_TIME - 2*(rreqOb->getHopCnt()+1)*NODE_TRAVERSAL_TIME;

		rtEntry.createEntry(rreqOb->getSrcIP(),rreqOb->getSrcSeqNum(),(rreqOb->getHopCnt()+1), nhop,minLifeTime, ACTIVE_ROUTE);
		addRoute(rtEntry);
	}
	return;
}

/* add/update reverse route entry*/
void		routingTable::reverseRouteUpdate(u_int32_t nhop, RREQ *rreqOb)
{
	u_int64_t	minLifeTime;
	u_int32_t	prevNextHop;
	bool		addFlag = false;
	map<u_int32_t,rtable_entry>::iterator	iter;

#ifdef DEBUG
	cout << "routingTable: reverseRouteUpdate: entered " << endl;
#endif

	iter = rTableMap.find(rreqOb->getSrcIP());
	if(iter != rTableMap.end())
	{
#ifdef DEBUG
		cout << "routingTable: reverseRouteUpdate: route already exist " << endl;
#endif
		if(iter->second.getRFlags() == ACTIVE_ROUTE)
		{
#ifdef DEBUG
			cout << "routinTable: reverseRouteUpdate: a valid route already exist " << endl;
#endif

			/* a route to the source already exist */
			if((rreqOb->getSrcSeqNum() > iter->second.getDestSeqNum()) ||
			 ((rreqOb->getSrcSeqNum() == iter->second.getDestSeqNum()) && 
			 ((rreqOb->getHopCnt()+1) < iter->second.getHopCnt())))
			{

#ifdef DEBUG
				cout << "routingTable: reverseRouteUpdate: update existing route " << endl;
#endif
				/* delete the old route from kernel if needed */
				prevNextHop = iter->second.getNextHop();
				if(((rreqOb->getHopCnt()+1) < iter->second.getHopCnt()) || (prevNextHop != nhop))
				{
					del_kroute(iter);
					addFlag = true;
				}

				iter->second.setDestSeqNum(rreqOb->getSrcSeqNum());
				iter->second.setNextHop(nhop);
				iter->second.setHopCnt((rreqOb->getHopCnt()+1));
				minLifeTime = getcurrtime()+PATH_TRAVERSAL_TIME - 2*iter->second.getHopCnt()*NODE_TRAVERSAL_TIME;
				if(minLifeTime > iter->second.getLifeTime())
					iter->second.setLifeTime(minLifeTime);

				/* add new route to the kernel */
				if( addFlag )
				{
					add_kroute(iter);
				}
			}
		}
		else
		{

#ifdef DEBUG
			cout << "routingTable: reverseRouteUpdate: an invalid route exist " << endl;
#endif

			iter->second.setDestSeqNum(rreqOb->getSrcSeqNum());
			iter->second.setNextHop(nhop);
			iter->second.setHopCnt((rreqOb->getHopCnt()+1));
			iter->second.setRFlags(ACTIVE_ROUTE);

			minLifeTime = getcurrtime()+PATH_TRAVERSAL_TIME - 2*iter->second.getHopCnt()*NODE_TRAVERSAL_TIME;
			iter->second.setLifeTime(minLifeTime);

			add_kroute(iter);
		}

	}
	else
	{
		/* reverse route needs to be created */
#ifdef DEBUG
		cout << "routingTable: reverseRouteUpdate: create reverse route " << endl;
#endif
		rtable_entry	rtEntry;
		minLifeTime = getcurrtime()+PATH_TRAVERSAL_TIME - 2*(rreqOb->getHopCnt()+1)*NODE_TRAVERSAL_TIME;
		rtEntry.createEntry(rreqOb->getSrcIP(),rreqOb->getSrcSeqNum(),(rreqOb->getHopCnt()+1), nhop,minLifeTime, ACTIVE_ROUTE);

		insertRoute(rtEntry);
	}

	/* now a valid reverse route has been created */
	route_discovery_done(rreqOb->getSrcIP(), ASL_ROUTE_FOUND);

	/* also remove the rreq timer */
	int ret = timer_Q.removeRREQTimer((rreqOb->getSrcIP()));
	if(ret == LR_TIMER)
	{
		/* remove the dest from local repair list ..
		 * also see if a route err need to be generated */

		local_repair.deleteFromList(rreqOb->getSrcIP());

		rtable_entry	*rtEntry;
		rtEntry = findRoute(rreqOb->getSrcIP());

		if((rtEntry != NULL) && (rtEntry->getHopCnt() > rtEntry->getLastHopCnt()))
			aodvOb.generateRERR(rreqOb->getSrcIP(),1, false);
	}
	return;
}

/* add/update forward route entry during reboot */
void		routingTable::rebootForwardRouteUpdate(u_int32_t nhop, RREP *rrepOb)
{
	map<u_int32_t,rtable_entry>::iterator	iter;

#ifdef DEBUG
	cout << "rebootForwardRouteUpdate: entered dest is" << getDotIP(rrepOb->getDestIP()) << endl;
#endif

	iter = rTableMap.find(rrepOb->getDestIP());
	if(iter != rTableMap.end())
	{

		if(iter->second.getRFlags() == ACTIVE_ROUTE)
		{
#ifdef DEBUG
			cout << "routingTable: rebootForwardRouteUpdate: an active route exist " << endl;
#endif
			if((rrepOb->getDestSeqNum() > iter->second.getDestSeqNum()) ||
				((rrepOb->getDestSeqNum() == iter->second.getDestSeqNum()) 
				&& ((rrepOb->getHopCnt()+1) < iter->second.getHopCnt())))
			{

				iter->second.setNextHop(nhop);
				iter->second.setHopCnt((rrepOb->getHopCnt()+1));
				iter->second.setDestSeqNum(rrepOb->getDestSeqNum());
				iter->second.setLifeTime(getcurrtime()+ rrepOb->getLifeTime());
			}
		}
		else
		{
			iter->second.setNextHop(nhop);
			iter->second.setHopCnt((rrepOb->getHopCnt()+1));
			iter->second.setDestSeqNum(rrepOb->getDestSeqNum());
			iter->second.setLifeTime(getcurrtime()+ rrepOb->getLifeTime());
			iter->second.setRFlags(ACTIVE_ROUTE);
		}
	}
	else
	{
		rtable_entry	rtEntry;
		rtEntry.createEntry(rrepOb->getDestIP(),rrepOb->getDestSeqNum(),(rrepOb->getHopCnt()+1), nhop, (getcurrtime()+rrepOb->getLifeTime()), ACTIVE_ROUTE);

		addRoute(rtEntry);
	}
	return;
}


/* add/update forward route entry*/
void		routingTable::forwardRouteUpdate(u_int32_t nhop, RREP *rrepOb)
{
	u_int32_t	prevNextHop;
	bool		addFlag = false;
	map<u_int32_t,rtable_entry>::iterator	iter;

#ifdef DEBUG
	cout << "forwardRouteUpdate: entered dest is" << getDotIP(rrepOb->getDestIP()) << endl;
#endif

	iter = rTableMap.find(rrepOb->getDestIP());
	if(iter != rTableMap.end())
	{
		/* an entry already exists */
#ifdef DEBUG
		cout  << "routingTable: forwardRouteUpdate: an entry exists " << endl;
		cout  << "routingTable: forwardRouteUpdate: rrep seq num" << rrepOb->getDestSeqNum() << endl;
		cout  << "routingTable: forwardRouteUpdate: rtable seq num " << iter->second.getDestSeqNum() << endl;
		cout  << "routinTable: forwardRouteUpdate: rtable hop cnt is " << (int)iter->second.getHopCnt() << endl;
#endif

		if(iter->second.getRFlags() == ACTIVE_ROUTE)
		{

#ifdef DEBUG
			cout << "routingTable: forwardRouteUpdate: an active route exist " << endl;
#endif

			if((rrepOb->getDestSeqNum() > iter->second.getDestSeqNum()) ||
				((rrepOb->getDestSeqNum() == iter->second.getDestSeqNum()) 
				&& ((rrepOb->getHopCnt()+1) < iter->second.getHopCnt())))
			{
				/* delete the old route from kernel if needed */
#ifdef DEBUG
				cout  << "routingTable: forwardRouteUpdate: update the existing entry " << endl;
#endif

				prevNextHop = iter->second.getNextHop();
				if(((rrepOb->getHopCnt()+1) < iter->second.getHopCnt()) || (prevNextHop != nhop))
				{
					del_kroute(iter);
					addFlag = true;
				}

				iter->second.setNextHop(nhop);
				iter->second.setHopCnt((rrepOb->getHopCnt()+1));
				iter->second.setDestSeqNum(rrepOb->getDestSeqNum());
				iter->second.setLifeTime(getcurrtime()+ rrepOb->getLifeTime());

				/* add new route to the kernel */
				if( addFlag )
				{
					add_kroute(iter);
				}
			}	
		}
		else
		{
#ifdef DEBUG
			cout << "routingTable: forwardRouteUpdate: an invalid route exist " << endl;
#endif

			iter->second.setNextHop(nhop);
			iter->second.setHopCnt((rrepOb->getHopCnt()+1));
			iter->second.setDestSeqNum(rrepOb->getDestSeqNum());
			iter->second.setLifeTime(getcurrtime()+ rrepOb->getLifeTime());
			iter->second.setRFlags(ACTIVE_ROUTE);

			add_kroute(iter);
		}
	}
	else
	{
		/* create a forward route entry */
		rtable_entry	rtEntry;

#ifdef DEBUG
		cout  << "routingTable: forwardRouteUpdate: an entry does not exist " << endl;
		cout  << "routingTable: forwardRouteUpdate: an entry does not exist Hop Cnt is " << (int)rrepOb->getHopCnt() << endl;
#endif

		rtEntry.createEntry(rrepOb->getDestIP(),rrepOb->getDestSeqNum(),(rrepOb->getHopCnt()+1), nhop, (getcurrtime()+rrepOb->getLifeTime()), ACTIVE_ROUTE);

		insertRoute(rtEntry);
#ifdef DEBUG
		cout  << "routingTable: forwardRouteUpdate: an entry does not exist Hop Cnt is " << (int)rtEntry.getHopCnt() << endl;
		cout  << "routingTable: forwardRouteUpdate: an entry does not exist life time is " << rrepOb->getLifeTime() << endl;
#endif
	}

	/* now a valid forward route has been created */
	route_discovery_done(rrepOb->getDestIP(), ASL_ROUTE_FOUND);

	/* also remove the rreq timer */
	int ret = timer_Q.removeRREQTimer((rrepOb->getDestIP()));
	if(ret == LR_TIMER)
	{
		/* remove the dest from local repair list ..
		 * also see if a route err need to be generated */

		local_repair.deleteFromList(rrepOb->getDestIP());

		rtable_entry	*rtEntry;
		rtEntry = findRoute(rrepOb->getDestIP());

		if((rtEntry != NULL) && (rtEntry->getHopCnt() > rtEntry->getLastHopCnt()))
			aodvOb.generateRERR(rrepOb->getDestIP(),1, false);
	}
	return;
}

rtable_entry	*routingTable::findActiveRoute(u_int32_t dest)
{
	rtable_entry	*rtEntry;
	u_int64_t		currtime = getcurrtime();

#ifdef DEBUG
	cout << "routingTable: findActiveRoute: entered dets is " << getDotIP(dest) << endl;
#endif

	rtEntry = findRoute(dest);
	if(rtEntry != NULL)
	{
		if((rtEntry->getLifeTime() > currtime) &&
			(rtEntry->getRFlags() == ACTIVE_ROUTE))
		{
#ifdef DEBUG
			cout << "routingTable: findActiveRoute: got a route" << endl;
#endif
			return rtEntry;
		}
		else
		{
#ifdef DEBUG
			cout << "routingTable: findActiveRoute: did not get a route" << endl;
#endif
			return NULL;
		}
	}
	return NULL;
}

rtable_entry	*routingTable::findValidRoute(u_int32_t dest, u_int32_t seqNum)
{
	rtable_entry	*rtEntry;