updatemessage.cc

RSA algorithm implementation is given

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

void	stlTimeHandler(void *data);

void	updateMessage::printUpdate()
{
	cout << "updateMessage: printUpdate: num of entries " << entries_cnt << endl;

	list<broadcast_entry>::iterator		iter;
	iter = brentry_list.begin();
	while(iter != brentry_list.end())
	{
		cout << "\t" << getDotIP(iter->getDestIP());
		cout << "\t" << iter->getDestSeqNum();
		cout << "\t" << iter->getRTMetric();
		cout << endl;
		iter++;
	}

}

void	updateMessage::createMessage(char *buf)
{
	
	u_int32_t	dst, seqNum, metric;
	int			i;

	type = buf[0];
	reserved1 = buf[1];
	reserved2 = buf[2];
	entries_cnt = buf[3];

#ifdef DEBUG
	cout << "updateMessage: createMessage: entries cnt is " << (int)entries_cnt << endl;
#endif

	for(i=0;i<entries_cnt;i++)
	{
		memcpy(&dst,(buf+4+i*12),4);
		memcpy(&seqNum,(buf+8+i*12),4);
		memcpy(&metric,(buf+12+i*12),4);
		addToBrdcstList(dst,seqNum,metric);
	}
	return;

}	

void	updateMessage::insertIntoList(u_int32_t dst, u_int32_t seq, u_int32_t metric)
{
	broadcast_entry		brEntry;
	brEntry.createEntry(dst,seq,metric);

	brentry_list.push_back(brEntry);
	return;
}


void	updateMessage::addToBrdcstList(u_int32_t dst, u_int32_t seq, u_int32_t metric)
{
	broadcast_entry		brEntry;
	brEntry.createEntry(dst,seq,metric);

	brentry_list.push_back(brEntry);
	return;

}

void	updateMessage::applyUpdates(u_int32_t	src)
{

	u_int32_t	dst, new_metric, prevMetric, prevNextHop;
	list<broadcast_entry>::iterator		iter;
	bool		add_flag= false;

	u_int64_t	currtime=getcurrtime();

	iter = brentry_list.begin();

	while(iter != brentry_list.end())
	{
		dst = iter->getDestIP();

		if(dst != g_my_ip)
		{
			rtable_entry	*rtEntry;
			rtEntry = rTableForward.findRoute(dst);

			if(rtEntry != NULL)
			{
				prevMetric = rtEntry->getRTMetric();
				prevNextHop = rtEntry->getNextHop();

				if(iter->getRTMetric() == INFINITY)
					new_metric = INFINITY;
				else
					new_metric = iter->getRTMetric()+1;

#ifdef DEBUG
				cout << "updateMessage: applyUpdates: an entry exist " << endl;
#endif
				if(iter->getDestSeqNum() > rtEntry->getDestSeqNum())
				{
#ifdef DEBUG
					cout << "updateMessage: applyUpdates: entry received with higher seq num " << endl;
#endif
					
					/* set the change bit in the routing flag */
					u_int32_t	temp_flag=1;
					temp_flag = temp_flag << 31;
					rtEntry->setRFlags(temp_flag);

					if((rtEntry->getRTMetric() != INFINITY))
					{
#ifdef DEBUG
						cout << "updateMessage: applyUpdates: an entry exist in kernel " << endl;
#endif
						/* check if it needs to be changed */
						if((rtEntry->getNextHop() != src) || 
							(rtEntry->getRTMetric() != new_metric))
						{
							del_kroute(*rtEntry);
							add_flag = true;
						}
					}
					else
					{
#ifdef DEBUG
						cout << "updateMessage: applyUpdates: an entry does not\
							exist in kernel " << endl;
#endif
						add_flag = true;
					}

					if(iter->getRTMetric() == INFINITY)
						add_flag = false;

					rtEntry->setNextHop(src);
					rtEntry->setDestSeqNum(iter->getDestSeqNum());
					rtEntry->setRTMetric(new_metric);
					rtEntry->setLifeTime(currtime+ROUTE_TIMEOUT);

					if(add_flag)
						add_kroute(*rtEntry);

					if(new_metric != INFINITY)
					{
#ifdef DEBUG
						cout << "updateMessages: set the last recv time in settling time table " << endl;
#endif
						stlTable.setLastRecvTime(rtEntry->getDestIP());
					}

					if(new_metric == INFINITY || (new_metric < prevMetric) 
						|| ((new_metric == prevMetric) && (src != prevNextHop)))
					{
#ifdef DEBUG
						cout << "updateMessage: applyUpdates: do an immediate broadcast " << endl;
#endif
						/* sync the two routing tables */
						rTableForward.syncRTables(rtEntry->getDestIP());
						is_broadcast = true;
					}
					else
					{
#ifdef DEBUG
						cout << "updateMessage: applyUpdates: do a delayed  broadcast " << endl;
#endif
						/* add a timer for delayed broadcast here */
						/* there could be two cases:
						 * new_metric > prevMetric or new_metric==prevMetric */
						if(new_metric == prevMetric && src == prevNextHop)
						{
#ifdef DEBUG
							cout << "just seq number change " << endl; 
#endif
							rTableForward.syncRTables(rtEntry->getDestIP());
						}
						else
						{
							u_int64_t	stime =  stlTable.getSettleTime(rtEntry->getDestIP());

							if(stime == 0)
							{
#ifdef DEBUG
								cout << "updateMessage: no stl time data, broadcast immediately " << endl;
#endif
								rTableForward.syncRTables(rtEntry->getDestIP());
								is_broadcast=true;
							}
							else
							{
								struct timerData	tData;
								tData.type = DELAYED_UPDATE_TIMER;
								tData.data = rtEntry->getDestIP();
								timer_Q.set_timer(STL_TIME_FACTOR*stime, stlTimeHandler, (void *) &tData);
							}
						}
					}

				}
				else if(iter->getDestSeqNum() < rtEntry->getDestSeqNum())
				{
#ifdef DEBUG
					cout << "updateMessage: applyUpdates: entry received with smaller seq number " << endl; 
#endif
					if(new_metric == INFINITY)
						is_broadcast=true;

				}
				else
				{
#ifdef DEBUG
					cout << "updateMessage: applyUpdates: entry	with a same seq number " << endl;
#endif

					if((iter->getRTMetric()+1) < rtEntry->getRTMetric())
					{
						/* set the change bit in the routing flag */
						u_int32_t	temp_flag=1;
						temp_flag = temp_flag << 31;
						rtEntry->setRFlags(temp_flag);
						
						//stlTable.setAvgStlTime(rtEntry->getDestIP());
						stlTable.setNewStlTime(rtEntry->getDestIP());
						stlTable.setLastRecvTime(rtEntry->getDestIP());

						is_broadcast=true;
						rTableForward.syncRTables(rtEntry->getDestIP());

						if(rtEntry->getRTMetric() != INFINITY)
							del_kroute(*rtEntry);

						rtEntry->setNextHop(src);
						rtEntry->setDestSeqNum(iter->getDestSeqNum());
						rtEntry->setRTMetric(new_metric);
						rtEntry->setLifeTime(currtime+ROUTE_TIMEOUT);

						add_kroute(*rtEntry);


					}
				}
			}
			else {
#ifdef DEBUG
				cout << "updateMessage: applyUpdates: an entry does not exist " << endl;
#endif
				rtable_entry	rtEntry;

				if(iter->getRTMetric() == INFINITY)
					new_metric = INFINITY;
				else 
					new_metric = iter->getRTMetric()+1;

				rtEntry.createEntry(iter->getDestIP(),src, iter->getDestSeqNum(),(new_metric),(getcurrtime()+ROUTE_TIMEOUT),0); 

				/* set the change bit in the routing flag */
				u_int32_t	temp_flag=1;
				temp_flag = temp_flag << 31;
				rtEntry.setRFlags(temp_flag);

				rTableForward.insertRoute(rtEntry);

				if(new_metric !=INFINITY)
					add_kroute(rtEntry);

				stlTable.setLastRecvTime(rtEntry.getDestIP());
				rTableForward.syncRTables(rtEntry.getDestIP());
				is_broadcast=true;

			}
		}
		else
		{
#ifdef DEBUG
			cout << "updateMessages: local node entry " << endl;
#endif
			if(duringReboot)
			{
				/*update local seq number */
				if(localSeqNum < iter->getDestSeqNum())
				{
					localSeqNum=iter->getDestSeqNum();
					rTableForward.setLocalSeqNum();
					rTableBroadcast.setLocalSeqNum();
				}
				
			}
		}
		iter++;
	}
}

void	stlTimeHandler(void *data)
{
	dsdvOb.settling_time_handler(data);
	/* do a broadcast in this handler function */
}


void	updateMessage::copyIntoBuf(char *buf)
{
	u_int32_t	dst,seq,metric;

	buf[0]=type;
	buf[1]=0;
	buf[2]=0;
	buf[3]=entries_cnt;
	
	list<broadcast_entry>::iterator		iter;
	iter=brentry_list.begin();

	int i=0;
	while(iter != brentry_list.end())
	{
		dst=iter->getDestIP();
		seq=iter->getDestSeqNum();
		metric=iter->getRTMetric();

		memcpy((buf+4+i*12),&dst,4);
		memcpy((buf+8+i*12),&seq,4);
		memcpy((buf+12+i*12),&metric,4);
		i++;
		iter++;
	}
	return;
}