aodv.cc

AODV

	struct timerData	*tData;

	tData = (struct timerData*)data;
	dst = tData->data;

	/* return route status to ASL */
	if( route_discovery_done(dst, ASL_NO_ROUTE) < 0)
		cout << " Error: LR_handler: route_discovery_done() " << endl;

	/* generate and send a rerr if no RREP was received for local repair attempt*/


	rtEntry = rtable.findRoute(dst);
	if(rtEntry != NULL)
	{
		rtEntry->setLastHopCnt(rtEntry->getHopCnt());
		rtEntry->setHopCnt(INFINITY);
		rtEntry->setLifeTime(getcurrtime()+DELETE_PERIOD);
		rtEntry->setRFlags(INVALID_ROUTE);
	}

	/* generate a RERR for this dest */
	generateRERR(dst,0,false);

	/* also remove the packet from the local repair list */
	list<local_repair_entry>::iterator	iter;

	iter = local_repair.findInList(dst);
	if( iter != NULL)
	{
		local_repair.deleteFromList(iter);
	}
	
	return;
}

/* handler function for RREQ timer */
void	resendRREQ_handler(void *val)
{
	aodvOb.resendRREQ(val);
}

void	aodv::resendRREQ(void *val)
{
	struct timerData	*tData;
	rreq_list_entry	 *rreqEntry;

	tData = (struct timerData*)val;
	u_int32_t	dst = tData->data;

#ifdef DEBUG
	cout << "aodv: resendRREQ: dest ip is " << getDotIP(dst) << endl;
#endif

	rreqEntry = rreqL.inList(dst);
	if(rreqEntry != NULL)
	{
		sendData	snd;

		cout << "resendRREQ: entry in rreqL " << endl;

		if(expandingRingSearch)
		{
			cout << "resendRREQ: expandingRingSearch " << endl;
			if(rreqEntry->getTTL() == NET_DIAMETER)
			{	
				rreqEntry->setRetries(rreqEntry->getRetries()+1);
			}
			else
			{
				rreqEntry->setTTL((rreqEntry->getTTL())+TTL_INCREMENT);
				if(rreqEntry->getTTL() >= TTL_THRESHOLD)
				{
					rreqEntry->setTTL(NET_DIAMETER);
					rreqEntry->setRetries(rreqEntry->getRetries()+1);
				}
			}
		}
		else
		{
			cout << "resendRREQ: no expandingRingSearch " << endl;
			rreqEntry->setRetries(rreqEntry->getRetries()+1);
		}

		cout << "resendRREQ: retries value is " << rreqEntry->getRetries() << endl;

		if(rreqEntry->getRetries() > RREQ_RETRIES)
		{
#ifdef DEBUG
			cout << "resendRREQ: max retries done, not resending RREQ" << endl;
#endif
			/* delete this entry from the rreq list */
			/* also return a no route found to asl */
			rreqL.deleteFromList(dst);
			if( route_discovery_done(dst, ASL_NO_ROUTE) < 0)
				cout << " Error: route_discovery_done() " << endl;
			return ;
		}
	
		rreqEntry->setRreqId(++rreqId);
		rreqEntry->setDestSeqNum(rtable.getDestSeqNum(dst));
		rreqEntry->setSrcSeqNum(++localSeqNum);

		cout << "resendRREQ: ttl value is " << rreqEntry->getTTL() << endl;

		/* also update the rreq list timer */
		setRREQTimer(dst, rreqEntry->getTTL());

		genSndData(&snd,BROADCAST_ADDR, rreqEntry->getTTL());

		cout << "resendRREQ: ttl value is " << snd.getTTL() << endl;

		copyToSendBuf((void *)&(rreqEntry->getRreqOb()), sizeof(RREQ));
		sendPacket(&snd,(void *)sendBuffer,sizeof(RREQ));
	}
	else
	{
		cout << "Error resendRREQ: entry not in rreq List " << endl;
	}
	return ;
}

void	aodv::copyToSendBuf(void *data, int len)
{
	memset(sendBuffer,0,AODVBUFSIZE);
	memcpy(sendBuffer,data,len);
	return;
}

/* generic function to transmit and outgoing packet */
void	aodv::sendPacket(sendData *snd, void *data, int data_len)
{
	struct sockaddr_in	dst;
	int		len, ttl;

	ttl = snd->getTTL();

	cout << "sendPacket: ttl is " << snd->getTTL() << endl;
	cout << "sendPacket: ttl is " << ttl << endl;

	if(ttl == 0)
		return;

#ifdef DEBUG
	cout << "sendPacket: entered" << endl;
#endif

	if(snd->getDestIP() == BROADCAST_ADDR)
		needToSendHello = false;

	bzero((void *)&dst, sizeof(dst));
  	dst.sin_family = AF_INET;
  	dst.sin_port = htons(AODV_PORT);     
    dst.sin_addr.s_addr = snd->getDestIP();
	
	if (ttl > 0 && ttl < 256){ 
		cout << "sendPacket: setting ttl " << endl;

    	if (setsockopt(aodvSock.getSock(), SOL_IP, IP_TTL, &(ttl), sizeof(ttl)) < 0)
		{
			perror("Error setting TTL");
		}
		else
			cout << " sendPacket: ttl set to " << ttl << endl;
	}

	if ((len = sendto(aodvSock.getSock(), data, data_len, 0, 
	     (struct sockaddr *)&dst, sizeof(struct sockaddr))) < 0) {
			perror("Error in sendto");
  	} 

#ifdef DEBUG
	cout << "sendPacket: exiting" << endl;
#endif

	return;
}	


int	aodv::aodv_daemon(char *interface)
{
	/* Initialization */

#ifdef DEBUG
	cout << "inside aodv_daemon" << endl;
#endif

	registerSignal();

	/* start all relevant timers here */
	/* set the reboot timer */
	setRebootTimer();

	/* set periodic refresh timer to periodically update route table entries */
	setPeriodicTimer();

	/* intialization */
	aodv_init(interface);

	/* start the main daemon loop */
	mainDaemonLoop();
	return 0;
}

void	aodv::setRebootTimer()
{
	struct timerData	tData;
	tData.type = REBOOT_TIMER;
	tData.data = 0;
	
	timer_Q.set_timer_first(DELETE_PERIOD, rebootHandler_stub, (void *)&tData);
	return;
}

void	rebootHandler_stub(void *data)
{
	aodvOb.rebootHandler();
}

void	aodv::setPeriodicTimer()
{
	struct timerData	tData;
	tData.type = PERIODIC_TIMER;
	tData.data = 0;
	
	timer_Q.set_timer(PERIODIC_INTERVAL, periodicHandler_stub, (void *)&tData);
	return;
}

void	periodicHandler_stub(void *data)
{
	aodvOb.periodicHandler();
}

void 	aodv::periodicHandler()
{
#ifdef DEBUG
	cout << "periodicHandler: add a periodic timer " << endl;
#endif
	/* insert new periodic timer entry */
	struct	timerData	tData;
	tData.type = PERIODIC_TIMER;
	tData.data = 0;
	timer_Q.timer_add(PERIODIC_INTERVAL, periodicHandler_stub, (void *)&tData);

	/* this timer acts as periodic timer for refreshing route table entries */
	rtable.refreshEntries();
	fw_rreqL.updateEntries();
	black_list.updateEntries();

	return;
}

void	aodv::rebootHandler()
{
#ifdef DEBUG
	cout << "rebootHandler: entered" << endl;
#endif

	duringReboot = false;
	
	/* enter all existing valid route entries into kernel route table */
	rtable.addAllValidRoutes();

	/* start the hello message */
	if(helloSendFlag)
		aodvOb.sendHello();
}

int	aodv::registerSignal()
{
	signal(SIGALRM,global_handler);
	signal(SIGINT,sigint_timer_handler);
	return 0;
}

void	global_handler(int type)
{
	aodvOb.handler(type);
}

void 	sigint_timer_handler(int type)
{
	aodvOb.sigint_handler(type);
}

/* this function sends out a hello message */
void	aodv::sendHello()
{
	/* create and send a hello message */
	sendData	snd;

#ifdef DEBUG
	cout << "sendHello: entered" << endl;
#endif

	if(needToSendHello)
	{
#ifdef DEBUG
		cout << "sendHello: send a hello message" << endl;
#endif

		RREP	rrepOb(g_my_ip,localSeqNum, 0, 0, (ALLOWED_HELLO_LOSS*HELLO_INTERVAL));
		genSndData(&snd, BROADCAST_ADDR, 1);
		copyToSendBuf((void *)&rrepOb, sizeof(RREP));
		sendPacket(&snd,(void *)sendBuffer,sizeof(RREP));
	}

#ifdef DEBUG
	cout << "sendHello: add a hello timer " << endl;
#endif
	struct	timerData	tData;
	tData.type = HELLO_TIMER;
	tData.data = 0;
	timer_Q.timer_add(HELLO_INTERVAL, sendHello_handler, (void *)&tData);

	needToSendHello = true;

#ifdef DEBUG
	cout << "sendHello: exiting " << endl;
#endif
	return;

}

void	sendHello_handler( void * data)
{
	aodvOb.sendHello();
}
void	aodv::handler(int type)
{
	timer_Q.scheduleTimer();
}

void	aodv::sigint_handler(int type)
{
	close_route_request(asl_sock);
	free(recvBuffer);
	free(sendBuffer);
	exit(1);
}

void	aodv::generateRERR(u_int32_t dst, u_int8_t N_flag, bool brdFlag)
{
	RERR	rerrOb;
	sendData	snd;
	rtable_entry	*rtEntry;
	u_int32_t	precCnt=0, seqNum=0;

	rtEntry = rtable.findRoute(dst);

#ifdef DEBUG
	cout << "aodv: generateRERR: entered" << endl;
#endif

	cout << "aodv::generateRERR: rerr type is " << (int)rerrOb.getType() << endl;

	if(rtEntry != NULL)
	{
		seqNum = rtEntry->getDestSeqNum();
		precCnt = rtEntry->getPrecCnt();
	}
	

	if(precCnt > 0 || brdFlag)
	{

		cout << "aodv: generateRERR: send rerr " << endl;

		rerrOb.setNFlag(N_flag);
		rerrOb.setDestCnt(1);
		rerrOb.setUnrchDest((dst),seqNum);

		cout << "aodv::generateRERR: rerr type is " << (int)rerrOb.getType() << endl;

		/* pack rerr for sending */
		char	*buf;
		int			len;

		len = 4*(1+(2*rerrOb.getDestCnt()));
		buf = (char *)malloc(sizeof(len));

		memset(buf,0,len);

#ifdef DEBUG
		cout << " aodv:generateRERR: send rerr type is " << (int)rerrOb.getType() << endl;
#endif
		packBuf(buf,&rerrOb);

		if(precCnt == 1)
		{
			/* unicast RERR */
			u_int32_t	precAddr;

			cout << "aodv: generateRERR: unicast rerr " << endl;
			rtEntry->getPrecAddr(&precAddr);
			aodvOb.genSndData(&snd,precAddr,1);
			aodvOb.copyToSendBuf((void *)buf, len);
			aodvOb.sendPacket(&snd,(void *)sendBuffer,len);

		}	
		else
		{
			/* broadcast RERR */

			cout << "aodv: generateRERR: broadcast rerr " << endl;

			aodvOb.genSndData(&snd,BROADCAST_ADDR,1);
			aodvOb.copyToSendBuf((void *)buf, len);
			aodvOb.sendPacket(&snd,(void *)sendBuffer,len);
		}
		free(buf);
	}
	return;
}

/* the main rouitng daemon loop function */
void	aodv::mainDaemonLoop()
{
	int nfds=0, ret;
	fd_set	rbits, rfds;

#ifdef DEBUG
	cout << "mainDaemonLoop Entered " << endl;
#endif

	FD_ZERO(&rbits);

	for(int i=0; i< handler_cnt; i++)
	{
		FD_SET(handlers[i].fd,&rbits);
		if(handlers[i].fd >= nfds)
			nfds = handlers[i].fd +1;
	}

	while(1)
	{
		memcpy((char *)&rfds, (char *)&rbits, sizeof(rbits));

		if( (ret = select(nfds, &rfds, NULL, NULL, NULL)) < 0)
		{
			cout << "Error in select " << endl;

		}
		else
		{
			for(int i=0;i<handler_cnt;i++)
			{
				if(FD_ISSET(handlers[i].fd, &rfds))
				{
					(*handlers[i].func)();
				}
			}
		}
	}
	
	return;
}