timerqueue.cc

RSA algorithm implementation is given

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


int timerQueue::timer_add(u_int64_t timeVal, timer_hfunc_t func, void *dataVal)
{
	timer	timerOb;
	struct	timerData	*tData, *tempData;
	u_int64_t	currtime=getcurrtime();

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

	tempData = (struct timerData *)dataVal;

	tData = (struct timerData *)malloc(sizeof(struct timerData));
	tData->type = tempData->type;
	tData->data = tempData->data;

#ifdef DEBUG
	cout << "timer_add: timer type is " << tData->type << "timeout is  " << timeVal << "currtime is " << currtime <<endl; 
#endif
	timerOb.timeout = currtime + timeVal; /* absolute time in msec */
#ifdef DEBUG
	cout << "timer_add: absolute timeout is  " << timerOb.timeout <<endl; 
#endif
	timerOb.handler = func;
	timerOb.data = tData;

	/* insert at the right place */
	list<timer>::iterator	iter;
	if(timerQ.size() == 0)
	{
#ifdef DEBUG
		cout << "timer_add: timer size 0 " << endl;
#endif
		timerQ.push_back(timerOb);
	}
	else
	{
#ifdef DEBUG
		cout << "timer_add: timer size " << timerQ.size() << endl;
#endif

		iter=timerQ.begin();
		while(timerOb.timeout > iter->timeout && (iter != timerQ.end()))
		{
			iter++;
#ifdef DEBUG
			cout << "timerQueue: timer_add: within while " << endl;
#endif
		}
		if(iter == timerQ.end())
		{
#ifdef DEBUG
			cout << "timerQueue: timer_add:  iter reached end " << endl;
#endif
			timerQ.push_back(timerOb);
		}
		else
		{
#ifdef DEBUG
			cout << "timerQueue: timer_add:  insert in the middle" << endl;
#endif
			timerQ.insert(iter,timerOb);
		}
	}
	return 0;	
}

int timerQueue::scheduleTimer()
{
	list<timer>::iterator	iter,tmp_iter;
	iter=timerQ.begin();

	u_int64_t	currtime = getcurrtime();

#ifdef DEBUG
	cout << "scheduleTimer: entered timer size is " << timerQ.size() << " timeout is " << iter->timeout  << "currtime is" << currtime << endl;
#endif

	while((iter->timeout <= currtime) && (iter != timerQ.end()))
	{

		iter->handler(iter->data);

		iter++;
		tmp_iter = iter;
		iter--;

		timerQ.erase(iter);
		iter = tmp_iter;
	}

	if((iter->timeout > 0) && (iter->timeout > currtime) && (iter != timerQ.end()))
		setRealTimer((iter->timeout-currtime));

	return 0;
	
}

int timerQueue::set_timer(u_int64_t timeVal, timer_hfunc_t fun, void *dataVal )
{
#ifdef DEBUG
	cout << "timerQueue: set_timer: entered" << endl;
#endif

	/* add to the timer list */
	timer_add(timeVal, fun, dataVal);

	/* find the timer with minimum timeout and set the timer for that value */
	setLowestTimer(timeVal);

	return 0;
}

int timerQueue::set_timer_first(u_int64_t timeVal, timer_hfunc_t fun, void *dataVal )
{

#ifdef DEBUG
	cout << "set_timer_first: entered" << endl;
#endif
	/* add to the timer list */
	timer_add(timeVal, fun, dataVal);

	/* find the timer with minimum timeout and set the timer for that value */
	setRealTimer(timeVal);
	return 0;
}

void	timerQueue::setLowestTimer(u_int64_t timeVal)
{
	u_int64_t	currtime = getcurrtime();
	struct timerData	*tData;
	

#ifdef DEBUG
	cout << "timerQueue: setLowestTimer: entered " << endl;
#endif
	list<timer>::iterator	iter;
	iter=timerQ.begin();

	tData = (struct timerData*) iter->data;
#ifdef DEBUG
	cout << "setLowestTimer: timer queue size is " << timerQ.size() << endl;
	cout << "setLowestTimer: timer type is " << tData->type << endl;
	cout << "setLowestTimer: timeVal is " << timeVal << endl;
	cout << "setLowestTimer: first entry timeout is " << iter->timeout << endl;
	cout << "setLowestTimer: current timeout is " << (currtime+timeVal) << endl;
#endif

	//if(iter->timeout > (currtime+timeVal))
	if(iter->timeout == (currtime+timeVal))
	{
		/* reset the timer to the timeval timeout */
#ifdef DEBUG
		cout << "timerQueue: setLowestTimer: resetting timer " << endl;
#endif
		setRealTimer(timeVal);
	}
	return;
}


/* timeout is the absolute time in ms */
int	timerQueue::setRealTimer(u_int64_t timeout)
{
	struct itimerval itval;
	long	time_sec, time_usec;

#ifdef DEBUG
	cout << " setRealTimer: entered timeout is " << timeout <<  endl;
#endif
	time_sec = timeout/1000;
	time_usec = (timeout - time_sec*1000)*1000;
	itval.it_interval.tv_sec = 0;
	itval.it_value.tv_sec = time_sec;
	itval.it_interval.tv_usec = 0;
	itval.it_value.tv_usec = time_usec;

	if (setitimer(ITIMER_REAL, &itval, (struct itimerval *)NULL) < 0) {
			cout << "ERROR: setting periodic timer"  << endl;
			return -1;
	}

	return 0;
}