Annotation of embedaddon/igmpproxy/src/callout.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** igmpproxy - IGMP proxy based multicast router
! 3: ** Copyright (C) 2005 Johnny Egeland <johnny@rlo.org>
! 4: **
! 5: ** This program is free software; you can redistribute it and/or modify
! 6: ** it under the terms of the GNU General Public License as published by
! 7: ** the Free Software Foundation; either version 2 of the License, or
! 8: ** (at your option) any later version.
! 9: **
! 10: ** This program is distributed in the hope that it will be useful,
! 11: ** but WITHOUT ANY WARRANTY; without even the implied warranty of
! 12: ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 13: ** GNU General Public License for more details.
! 14: **
! 15: ** You should have received a copy of the GNU General Public License
! 16: ** along with this program; if not, write to the Free Software
! 17: ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
! 18: **
! 19: **----------------------------------------------------------------------------
! 20: **
! 21: ** This software is derived work from the following software. The original
! 22: ** source code has been modified from it's original state by the author
! 23: ** of igmpproxy.
! 24: **
! 25: ** smcroute 0.92 - Copyright (C) 2001 Carsten Schill <carsten@cschill.de>
! 26: ** - Licensed under the GNU General Public License, version 2
! 27: **
! 28: ** mrouted 3.9-beta3 - COPYRIGHT 1989 by The Board of Trustees of
! 29: ** Leland Stanford Junior University.
! 30: ** - Original license can be found in the Stanford.txt file.
! 31: **
! 32: */
! 33:
! 34:
! 35: #include "igmpproxy.h"
! 36:
! 37: /* the code below implements a callout queue */
! 38: static int id = 0;
! 39: static struct timeOutQueue *queue = 0; /* pointer to the beginning of timeout queue */
! 40:
! 41: struct timeOutQueue {
! 42: struct timeOutQueue *next; // Next event in queue
! 43: int id;
! 44: timer_f func; // function to call
! 45: void *data; // Data for function
! 46: int time; // Time offset for next event
! 47: };
! 48:
! 49: // Method for dumping the Queue to the log.
! 50: static void debugQueue(void);
! 51:
! 52: /**
! 53: * Initializes the callout queue
! 54: */
! 55: void callout_init() {
! 56: queue = NULL;
! 57: }
! 58:
! 59: /**
! 60: * Clears all scheduled timeouts...
! 61: */
! 62: void free_all_callouts() {
! 63: struct timeOutQueue *p;
! 64:
! 65: while (queue) {
! 66: p = queue;
! 67: queue = queue->next;
! 68: free(p);
! 69: }
! 70: }
! 71:
! 72:
! 73: /**
! 74: * elapsed_time seconds have passed; perform all the events that should
! 75: * happen.
! 76: */
! 77: void age_callout_queue(int elapsed_time) {
! 78: struct timeOutQueue *ptr;
! 79: int i = 0;
! 80:
! 81: for (ptr = queue; ptr; ptr = queue, i++) {
! 82: if (ptr->time > elapsed_time) {
! 83: ptr->time -= elapsed_time;
! 84: return;
! 85: } else {
! 86: elapsed_time -= ptr->time;
! 87: queue = queue->next;
! 88: my_log(LOG_DEBUG, 0, "About to call timeout %d (#%d)", ptr->id, i);
! 89:
! 90: if (ptr->func)
! 91: ptr->func(ptr->data);
! 92: free(ptr);
! 93: }
! 94: }
! 95: }
! 96:
! 97: /**
! 98: * Return in how many seconds age_callout_queue() would like to be called.
! 99: * Return -1 if there are no events pending.
! 100: */
! 101: int timer_nextTimer() {
! 102: if (queue) {
! 103: if (queue->time < 0) {
! 104: my_log(LOG_WARNING, 0, "timer_nextTimer top of queue says %d",
! 105: queue->time);
! 106: return 0;
! 107: }
! 108: return queue->time;
! 109: }
! 110: return -1;
! 111: }
! 112:
! 113: /**
! 114: * Inserts a timer in queue.
! 115: * @param delay - Number of seconds the timeout should happen in.
! 116: * @param action - The function to call on timeout.
! 117: * @param data - Pointer to the function data to supply...
! 118: */
! 119: int timer_setTimer(int delay, timer_f action, void *data) {
! 120: struct timeOutQueue *ptr, *node, *prev;
! 121: int i = 0;
! 122:
! 123: /* create a node */
! 124: node = (struct timeOutQueue *)malloc(sizeof(struct timeOutQueue));
! 125: if (node == 0) {
! 126: my_log(LOG_WARNING, 0, "Malloc Failed in timer_settimer\n");
! 127: return -1;
! 128: }
! 129: node->func = action;
! 130: node->data = data;
! 131: node->time = delay;
! 132: node->next = 0;
! 133: node->id = ++id;
! 134:
! 135: prev = ptr = queue;
! 136:
! 137: /* insert node in the queue */
! 138:
! 139: /* if the queue is empty, insert the node and return */
! 140: if (!queue) {
! 141: queue = node;
! 142: }
! 143: else {
! 144: /* chase the pointer looking for the right place */
! 145: while (ptr) {
! 146: if (delay < ptr->time) {
! 147: // We found the correct node
! 148: node->next = ptr;
! 149: if (ptr == queue) {
! 150: queue = node;
! 151: }
! 152: else {
! 153: prev->next = node;
! 154: }
! 155: ptr->time -= node->time;
! 156: my_log(LOG_DEBUG, 0,
! 157: "Created timeout %d (#%d) - delay %d secs",
! 158: node->id, i, node->time);
! 159: debugQueue();
! 160: return node->id;
! 161: } else {
! 162: // Continur to check nodes.
! 163: delay -= ptr->time; node->time = delay;
! 164: prev = ptr;
! 165: ptr = ptr->next;
! 166: }
! 167: i++;
! 168: }
! 169: prev->next = node;
! 170: }
! 171: my_log(LOG_DEBUG, 0, "Created timeout %d (#%d) - delay %d secs",
! 172: node->id, i, node->time);
! 173: debugQueue();
! 174:
! 175: return node->id;
! 176: }
! 177:
! 178: /**
! 179: * returns the time until the timer is scheduled
! 180: */
! 181: int timer_leftTimer(int timer_id) {
! 182: struct timeOutQueue *ptr;
! 183: int left = 0;
! 184:
! 185: if (!timer_id)
! 186: return -1;
! 187:
! 188: for (ptr = queue; ptr; ptr = ptr->next) {
! 189: left += ptr->time;
! 190: if (ptr->id == timer_id) {
! 191: return left;
! 192: }
! 193: }
! 194: return -1;
! 195: }
! 196:
! 197: /**
! 198: * clears the associated timer. Returns 1 if succeeded.
! 199: */
! 200: int timer_clearTimer(int timer_id) {
! 201: struct timeOutQueue *ptr, *prev;
! 202: int i = 0;
! 203:
! 204: if (!timer_id)
! 205: return 0;
! 206:
! 207: prev = ptr = queue;
! 208:
! 209: /*
! 210: * find the right node, delete it. the subsequent node's time
! 211: * gets bumped up
! 212: */
! 213:
! 214: debugQueue();
! 215: while (ptr) {
! 216: if (ptr->id == timer_id) {
! 217: /* got the right node */
! 218:
! 219: /* unlink it from the queue */
! 220: if (ptr == queue)
! 221: queue = queue->next;
! 222: else
! 223: prev->next = ptr->next;
! 224:
! 225: /* increment next node if any */
! 226: if (ptr->next != 0)
! 227: (ptr->next)->time += ptr->time;
! 228:
! 229: if (ptr->data)
! 230: free(ptr->data);
! 231: my_log(LOG_DEBUG, 0, "deleted timer %d (#%d)", ptr->id, i);
! 232: free(ptr);
! 233: debugQueue();
! 234: return 1;
! 235: }
! 236: prev = ptr;
! 237: ptr = ptr->next;
! 238: i++;
! 239: }
! 240: // If we get here, the timer was not deleted.
! 241: my_log(LOG_DEBUG, 0, "failed to delete timer %d (#%d)", timer_id, i);
! 242: debugQueue();
! 243: return 0;
! 244: }
! 245:
! 246: /**
! 247: * debugging utility
! 248: */
! 249: static void debugQueue() {
! 250: struct timeOutQueue *ptr;
! 251:
! 252: for (ptr = queue; ptr; ptr = ptr->next) {
! 253: my_log(LOG_DEBUG, 0, "(Id:%d, Time:%d) ", ptr->id, ptr->time);
! 254: }
! 255: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to callout.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / igmpproxy / src