dsdv.cc

RSA algorithm implementation is given

/*
 *   User Space DSDV Implementation
 *
 *   Binita Gupta
 *   University of Illinois at Urbana Champaign
 *   
 *   Email: [e-mail]
 *   
 *
 *   This software is Open Source under the GNU General Public License
 *
 *
 *******************************************
 *
 *       General Description:
 *      ----------------------
 *     
 *     This file defines all the functions of dsdv class. This is the main file
 *     which implements most of the dadv logic.
 *
 *
 *
 *
 *       Internal Procedures:
 *       
 *
 *
 *
 * 	 External Procedures:
 *      
 *
 *********************************************
 *
 */

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

void	process_dsdv_handler();
void	rebootHandler_stub(void *data);
void	updateHandler_stub(void *data);
void	periodicHandler_stub(void *data);
void	global_handler(int type);
void 	sigint_timer_handler(int type);
void	traffic_handler();

/* main dsdv initailize function */
void dsdv::dsdv_init(char *interface)
{
	struct sockaddr_in my_addr;

	if(check_root() == -1)
	{
		cout<< "You must be root to run this program" << endl;
		exit(1);
	}

	dsdvSock.createSock(interface, &my_addr);
	register_handler_function(dsdvSock.getSock(),process_dsdv_handler );

	if (get_interface_ip(dsdvSock.getSock(), interface, &my_addr) == -1)
	{
	      cout << "Error getting Interface IP" << endl;
	      exit(1);
	}

	/* open socket for communication with kernel routing table */
	ksock = init_krtsocket();
	if(ksock == -1)
	  {	
		cout << "Error Initializing kernel socket" << endl;
		exit(1);
	  }


	rTableForward.init_KRT();
	rTableBroadcast.init_RT();

	lastFullDumpTime = 0;
	is_broadcast = false;

	/* TRAFFIC */
	traffic_sock = open_and_bind_sock();
	if(traffic_sock < 0)
	{
		cout <<"Error opening traffic socket " << endl;
		exit(1);
	}
	register_handler_function(traffic_sock, traffic_handler );
	sprintf(logfile_name,"%s%s%s",LOGFILE_NAME,"_",getDotIP(g_my_ip));
	
	return; 
}

/* TRAFFIC */
void	traffic_handler()
{
	dsdvOb.process_traffic_data();
}

void	dsdv::process_traffic_data()
{
	if(read(traffic_sock,&traffic_data,sizeof(traffic_data)) < 0)
	{
		perror("Error in reading from traffic");
	}
	
#ifdef DEBUG
	cout << "dsdv:process_traffic_data: data read is " << traffic_data << endl;
#endif
	
	if(traffic_data == START_SIMULATION)
	{
		/* start counting the routing overhead */
	}
	else if (traffic_data == STOP_SIMULATION)
	{
		if((dsdv_log_file = fopen(logfile_name,"a")) == NULL)
		{
			perror("Error opening log file");
			exit(1);
		}

		fprintf(dsdv_log_file,"Routing Overhead is %d\n",routing_overhead_in_bytes);

		routing_overhead_in_bytes=0;
		traffic_data = NO_SIMULATION;
		fclose(dsdv_log_file);
	}
		
}


void	dsdv::register_handler_function(int fd, hfunc_t fun)
{
	handlers[handler_cnt].fd = fd;
	handlers[handler_cnt].func = fun;
	handler_cnt++;

	return;
}



void	process_dsdv_handler()
{
	dsdvOb.process_dsdv();
}

void	dsdv::process_dsdv()
{
	int length;
	u_int32_t	src;

	length = dsdvSock.readFromSock(&src);
	processRecvMsg(src);
}

void	dsdv::processRecvMsg(u_int32_t src)
{
	DSDV_Msg	*dsdv_msg;
	dsdv_msg = (DSDV_Msg*)recvBuffer;

#ifdef DEBUG
	cout << "dsdv:processRecvMsg: entered " << endl;
#endif

	if(src == g_my_ip)
	{
#ifdef DEBUG
		cout << "dsdv: processREcvMsg: ignore message from the local node " << endl;
#endif
		return;
	}
	
	switch(dsdv_msg->type){
		case DSDV_PERIODIC_UPDATE:
			processPeriodicUpdate(src);
			break;
		default:
#ifdef DEBUG
			cout << "dsdv: processRecvMsg: default case" << endl;
#endif
			break;
	}
	return;
}

void	dsdv::processPeriodicUpdate(u_int32_t src)
{

#ifdef DEBUG
		cout << "dsdv:processPeriodicUpdate: not during reboot " << endl;
#endif

		updateMessage	umsg;

		umsg.createMessage(recvBuffer);

#ifdef DEBUG
		umsg.printUpdate();
#endif

		umsg.applyUpdates(src);

		if( (!duringReboot) && is_broadcast)
		{
			is_broadcast=false;
			broadcastRTable();
		}
}

/* main dsdv daemon function - takes interface name as the input parameter*/
int dsdv::dsdv_daemon(char *interface)
{

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

	registerSignal();

	/* start all relevant timers here */

	setRebootTimer();
	setPeriodicTimer();

	/* do initialization */
	dsdv_init(interface);

	mainDaemonLoop();

	return 0;
}

void	dsdv::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)
{
	dsdvOb.rebootHandler();
}

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

	duringReboot = false;

	/* do the first broadcast */
	/* check if the local seq num is odd, make it the next even value */
	if((localSeqNum%2)==1)
	{
		localSeqNum++;
		rTableForward.setLocalSeqNum();
		rTableBroadcast.setLocalSeqNum();
	}

	broadcastRTable();

	startUpdateTimer();
}

void	dsdv::startUpdateTimer()
{
	struct timerData	tData;
	tData.type = PERIODIC_UPDATE_TIMER;
	tData.data = 0;
	
	timer_Q.set_timer(PERIODIC_UPDATE_INTERVAL, updateHandler_stub, (void *)&tData);
	return;

}

void	updateHandler_stub(void *data)
{
	dsdvOb.updateHandler();
}

void	dsdv::updateHandler()
{
	/* do a broadcast here */
	/* since this is a periodic update, increment the seq num */
	rTableForward.incrementLocalSeqNum();
	rTableBroadcast.incrementLocalSeqNum();

	broadcastRTable();

	/*reset the update timer */
	struct timerData	tData;
	tData.type = PERIODIC_UPDATE_TIMER;
	tData.data = 0;
	
	timer_Q.set_timer(PERIODIC_UPDATE_INTERVAL, updateHandler_stub, (void *)&tData);
	return;
}
                                                                      
void	dsdv::setPeriodicTimer()
{
	struct timerData	tData;
	tData.type = BROKEN_LINK_TIMER;
	tData.data = 0;
	
	timer_Q.set_timer(BROKEN_LINK_TIMER_INTERVAL, periodicHandler_stub, (void *)&tData);
	return;
}

void	periodicHandler_stub(void *data)
{
	dsdvOb.periodicHandler();
	return;
}

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

	/* this timer acts as periodic timer for refreshing route table entries */
	doBroadcast = rTableForward.refreshEntries();
	if(doBroadcast && (!duringReboot))
	{
		/* this is a triggered broadcast ..
		 * don't need to sync routing tables here */
		broadcastRTable();
	}

	return;
}


void	dsdv::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)
		{
#ifdef DEBUG
			cout << "Error in select " << endl;
#endif
		}
		else
		{
			for(int i=0;i<handler_cnt;i++)
			{
				if(FD_ISSET(handlers[i].fd, &rfds))
				{
					(*handlers[i].func)();
				}
			}
		}
	}
	return;
}

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

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

void	dsdv::handler(int type)
{
	timer_Q.scheduleTimer();
}


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

void	dsdv::sigint_handler(int type)
{
	free(recvBuffer);
	free(sendBuffer);
	exit(1);
}

void	dsdv::settling_time_handler(void *data)
{
	struct	timerData	*tData;
	u_int32_t	dst;

	tData = (struct timerData *)data;

	dst=tData->data;

	/* since this is an update after settling time period..
	 * sync both the routing tables */
	rTableForward.syncRTables(dst);

	broadcastRTable();
	return;
}


/* this takes care of broadcast routing updates */
void dsdv::broadcastRTable()
{

	bool full_dump=false;
	u_int32_t	len;

#ifdef DEBUG
	cout << "broadcastRtable: Entered" << endl;
#endif
	
	full_dump = isFullDumpNeeded();

	updateMessage	umsg;

	rTableBroadcast.generateUpdateMessage(&umsg,full_dump);

	len = 4*(1+3*umsg.getEntriesCnt());

	umsg.copyIntoBuf(sendBuffer);

#ifdef DEBUG
	cout << "dsdv:broadcast message is" << endl;
	umsg.printUpdate();
#endif

	/* send the broadcast list to the network */
	send_datagram(sendBuffer,len);

	return;

}


bool	dsdv::isFullDumpNeeded()
{
	u_int8_t	num_changed_entries=0;
	u_int64_t	currtime=getcurrtime();

	if(lastFullDumpTime == 0)
	{
		lastFullDumpTime=currtime;
#ifdef DEBUG
		cout << "dsdv:isFullDumpneeded: do full dump " << endl;
#endif
		return true;
	}
	else
	{
		num_changed_entries = rTableBroadcast.getChangedEntriesCnt();
		if((num_changed_entries > (FULL_DUMP_FACTOR * rTableBroadcast.getSize())) || 
		((currtime - lastFullDumpTime) > MAX_FULL_DUMP_TIMEOUT))
		{
			lastFullDumpTime=currtime;
#ifdef DEBUG
			cout << "dsdv:isFullDumpneeded: do full dump " << endl;
#endif
			return true;
		}
	}
	return false;
}

	
/* This function actually writes the periodic update packets out to the wire...
 * it calls above function to generate the sending buffer*/
void dsdv::send_datagram(void *data_buf, int data_len)
{
	struct sockaddr_in	their_addr;
	int		len;

#ifdef DEBUG
	cout << "send_datagram: Entered" << endl;
#endif

	bzero((void *)&their_addr,sizeof(struct sockaddr_in));

	/* send it out to the broadcast address */
	their_addr.sin_family = AF_INET;
  	their_addr.sin_port = htons(DSDVPORT);
  	their_addr.sin_addr.s_addr = BROADCAST_ADDR;
  	bzero(&(their_addr.sin_zero), 8);

	if(traffic_data == START_SIMULATION)
		routing_overhead_in_bytes +=data_len;

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

#ifdef DEBUG
	cout<< "send_datagram: num of bytes sent is   " << len << endl;
#endif
	return;
}