202 lines
3.7 KiB
C
202 lines
3.7 KiB
C
/*
|
|
* The mrouted program is covered by the license in the accompanying file
|
|
* named "LICENSE". Use of the mrouted program represents acceptance of
|
|
* the terms and conditions listed in that file.
|
|
*
|
|
* The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
|
|
* Leland Stanford Junior University.
|
|
*
|
|
*
|
|
* $Id: callout.c,v 1.1 1994/08/24 23:52:49 thyagara Exp $
|
|
*/
|
|
|
|
#include "defs.h"
|
|
|
|
/* the code below implements a callout queue */
|
|
static int id = 0;
|
|
static struct timeout_q *Q = 0; /* pointer to the beginning of timeout queue */
|
|
|
|
static int in_callout= 0;
|
|
|
|
typedef void (* cfunc_t)();
|
|
|
|
struct timeout_q {
|
|
struct timeout_q *next; /* next event */
|
|
int id;
|
|
cfunc_t func ; /* function to call */
|
|
char *data; /* func's data */
|
|
int time; /* time offset to next event*/
|
|
};
|
|
|
|
|
|
callout_init()
|
|
{
|
|
Q = (struct timeout_q *) 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* signal handler for SIGALARM that is called once every second
|
|
*/
|
|
age_callout_queue()
|
|
{
|
|
struct timeout_q *ptr;
|
|
|
|
if (in_callout)
|
|
return;
|
|
|
|
in_callout = 1;
|
|
ptr = Q;
|
|
|
|
while (ptr){
|
|
if (!ptr->time ) {
|
|
/* timeout has happened */
|
|
if(ptr->func)
|
|
ptr->func(ptr->data);
|
|
Q = Q->next;
|
|
|
|
free(ptr);
|
|
ptr = Q;
|
|
}
|
|
else {
|
|
ptr->time --;
|
|
#ifdef IGMP_DEBUG
|
|
log(LOG_DEBUG,0,"[callout, age_callout_queue] -- time (%d)", ptr->time);
|
|
#endif IGMP_DEBUG
|
|
in_callout = 0; return;
|
|
}
|
|
}
|
|
in_callout = 0;
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* sets the timer
|
|
*/
|
|
int timer_setTimer(delay, action, data)
|
|
int delay; /* number of units for timeout */
|
|
cfunc_t action; /* function to be called on timeout */
|
|
char *data; /* what to call the timeout function with */
|
|
{
|
|
struct timeout_q *ptr, *node, *prev;
|
|
|
|
if (in_callout)
|
|
return;
|
|
|
|
in_callout = 1;
|
|
|
|
/* create a node */
|
|
node = (struct timeout_q *)malloc(sizeof(struct timeout_q));
|
|
if ((int) node <= 0) {
|
|
log(LOG_WARNING, 0, "Malloc Failed in timer_settimer\n");
|
|
in_callout = 0;
|
|
return -1;
|
|
}
|
|
node->func = action;
|
|
node->data = data;
|
|
node->time = delay;
|
|
node->next = 0;
|
|
node->id = ++id;
|
|
|
|
prev = ptr = Q;
|
|
|
|
/* insert node in the queue */
|
|
|
|
/* if the queue is empty, insert the node and return */
|
|
if (!Q)
|
|
Q = node;
|
|
else {
|
|
/* chase the pointer looking for the right place */
|
|
while (ptr){
|
|
|
|
if (delay < ptr->time){
|
|
/* right place */
|
|
|
|
node->next = ptr;
|
|
if (ptr == Q)
|
|
Q = node;
|
|
else
|
|
prev->next = node;
|
|
ptr->time -= node->time;
|
|
print_Q();
|
|
in_callout = 0;
|
|
return node->id;
|
|
}
|
|
else {
|
|
/* keep moving */
|
|
|
|
delay -= ptr->time; node->time = delay;
|
|
prev = ptr;
|
|
ptr = ptr->next;
|
|
}
|
|
}
|
|
prev->next = node;
|
|
}
|
|
print_Q();
|
|
in_callout = 0;
|
|
return node->id;
|
|
}
|
|
|
|
|
|
/* clears the associated timer */
|
|
void timer_clearTimer( id)
|
|
int id;
|
|
{
|
|
struct timeout_q *ptr, *prev;
|
|
|
|
if (in_callout) return;
|
|
in_callout = 1;
|
|
|
|
|
|
if ( !id ) {in_callout = 0; return;}
|
|
|
|
prev = ptr = Q;
|
|
|
|
/*
|
|
* find the right node, delete it. the subsequent node's time
|
|
* gets bumped up
|
|
*/
|
|
|
|
print_Q();
|
|
while (ptr){
|
|
if (ptr->id == id){
|
|
/* got the right node */
|
|
|
|
/* unlink it from the queue */
|
|
if ( ptr == Q)
|
|
Q = Q->next;
|
|
else
|
|
prev->next = ptr->next;
|
|
|
|
/* increment next node if any */
|
|
if (ptr->next != 0)
|
|
(ptr->next)->time += ptr->time;
|
|
|
|
free(ptr->data);
|
|
free(ptr);
|
|
print_Q();
|
|
in_callout = 0;
|
|
return;
|
|
}
|
|
prev = ptr;
|
|
ptr = ptr->next;
|
|
}
|
|
print_Q();
|
|
in_callout = 0;
|
|
}
|
|
|
|
/*
|
|
* debugging utility
|
|
*/
|
|
print_Q()
|
|
{
|
|
struct timeout_q *ptr;
|
|
|
|
#ifdef IGMP_DEBUG
|
|
for(ptr = Q; ptr; ptr = ptr->next)
|
|
log(LOG_DEBUG,0,"(%d,%d) ", ptr->id, ptr->time);
|
|
#endif IGMP_DEBUG
|
|
}
|
|
|