Subversion Repositories or1k

/*

 * Copyright (c) 2000 Alex Holden <alex@linuxhacker.org>

 *

 * This file implements the device independant timer functions.

 *

 * When a part of the server wishes to set a timer, it should call the

 * GdAddTimer() function with the timeout parameter set to the number of

 * milliseconds before the timer should activate, the callback argument

 * set to the function which should be called when the timer expires, and

 * the arg argument set to the (void * type) argument which should be supplied

 * to the timer handler function. The GdAddTimer() returns a pointer to the

 * timer structure * which was created (or NULL if the creation failed for

 * some reason). The prototype for the callback function should look like:

 * void callbackfn(void *arg);

 *

 * If a part of the server wishes to destroy a timer before it has expired

 * (it is not necessary to do so after the timer has expired, as the timer

 * structure is automatically destroyed after the callback function is called),

 * it should call the GdDestroyTimer() function with the address of the timer

 * structure (which was returned by GdAddTimer()).

 *

 * If a part of the server wishes to destroy a timer but does not know the

 * address of it's timer structure, it can call GdFindTimer() with the

 * callback argument as a parameter. The argument must be unique to that

 * timer (the address of a structure or function is probably a good choice).

 * This function returns the address of the first timer found with that

 * argument, or NULL if no matching timer was found.

 *

 * The main select() loop needs to be called with a timeout obtained using the

 * GdGetNextTimeout(). GdGetNextTimeout() is called with the event loop

 * timeout in ms, and fills in the specified timeout structure, which should

 * be used as the argument to the select() call. The timeout returned by the

 * GdGetNextTimeout() call is decided by looking through the timer list for

 * the timer with the shortest amount of time remaining, and also at the

 * maximum delay parameter. If there are no timers on the timer list and the

 * timeout argument is 0, it will return FALSE, otherwise it will return TRUE.

 *

 * When the main select() loop times out, the GdTimeout() function should be

 * called. This will go through the timer list and call the callback functions

 * of all timers which have expired, then remove them from the timer list. At

 * the same time, you should check the value of the maximum timeout parameter

 * to see if it has expired (in which case you can then return to the client

 * with a timeout event). This function returns TRUE if the timeout specified in

 * the last GdGetNextTimeout() call has expired, or FALSE otherwise.

 *

 * Note that no guarantees can be made as to when exactly the timer callback

 * will be called as it depends on how often the GdTimeout() function is

 * called and how long any other timeouts in the queue before you take to

 * complete. Especially in the case where the client is linked into the server,

 * the client must call into the server on a regular basis, otherwise the

 * timers may run late.

 */

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include "device.h"

static MWTIMER *timerlist = NULL;

static struct timeval mainloop_timeout;

static struct timeval current_time;

static void calculate_timeval(struct timeval *tv, MWTIMEOUT to);

static signed long time_to_expiry(struct timeval *t);

MWTIMER *GdAddTimer(MWTIMEOUT timeout, MWTIMERCB callback, void *arg)

{

        MWTIMER *newtimer;

        if(!(newtimer = malloc(sizeof(MWTIMER)))) return NULL;

        gettimeofday(&current_time, NULL);

        if(timerlist) timerlist->prev = newtimer;

        calculate_timeval(&newtimer->timeout, timeout);

        newtimer->callback = callback;

        newtimer->arg = arg;

        newtimer->next = timerlist;

        newtimer->prev = NULL;

        newtimer->type   = MWTIMER_ONESHOT;

        newtimer->period = timeout;

        timerlist = newtimer;

        return newtimer;

}

MWTIMER *GdAddPeriodicTimer(MWTIMEOUT timeout, MWTIMERCB callback, void *arg)

{

    MWTIMER *newtimer;

    if(!(newtimer = malloc(sizeof(MWTIMER)))) return NULL;

    gettimeofday (&current_time, NULL);

    if (timerlist) timerlist->prev = newtimer;

    calculate_timeval (&newtimer->timeout, timeout);

    newtimer->callback = callback;

    newtimer->arg      = arg;

    newtimer->next     = timerlist;

    newtimer->prev     = NULL;

    newtimer->type     = MWTIMER_PERIODIC;

    newtimer->period   = timeout;

    timerlist          = newtimer;

    return newtimer;

}

void GdDestroyTimer(MWTIMER *timer)

{

        if(timer->next) timer->next->prev = timer->prev;

        if(timer->prev) timer->prev->next = timer->next;

        if(timer == timerlist) {

                if(timer->next) timerlist = timer->next;

                else timerlist = timer->prev;

        }

        free(timer);

}

MWTIMER *GdFindTimer(void *arg)

{

        MWTIMER *t = timerlist;

        while(t) {

                if(t->arg == arg) break;

                t = t->next;

        }

        return t;

}

MWBOOL GdGetNextTimeout(struct timeval *tv, MWTIMEOUT timeout)

{

        signed long i, lowest_timeout;

        MWTIMER *t = timerlist;

        if(!timeout && !timerlist) return FALSE;

        gettimeofday(&current_time, NULL);

        if(timeout) {

                calculate_timeval(&mainloop_timeout, timeout);

                lowest_timeout = time_to_expiry(&mainloop_timeout);

        } else {

                lowest_timeout = time_to_expiry(&t->timeout);

                mainloop_timeout.tv_sec = -1;

                t = t->next;

        }

        while(t) {

                i = time_to_expiry(&t->timeout);

                if(i < lowest_timeout) lowest_timeout = i;

                t = t->next;

        }

        if(lowest_timeout <= 0) {

                tv->tv_sec = 0;

                tv->tv_usec = 0;

        } else {

                tv->tv_sec = lowest_timeout / 1000;

                tv->tv_usec = (lowest_timeout % 1000) * 1000;

        }

        return TRUE;

}

MWBOOL GdTimeout(void)

{

        MWTIMER *n, *t = timerlist;

        gettimeofday(&current_time, NULL);

        while(t) {

                n = t->next;

                if(time_to_expiry(&t->timeout) <= 0) {

                        t->callback(t->arg);

                        if (t->type == MWTIMER_ONESHOT)

                        {

                            /* One shot timer, is finished delete it now */

                            GdDestroyTimer(t);

                        }

                        else

                        {

                            /* Periodic timer needs to be reset */

                            calculate_timeval (&t->timeout, t->period);

                        }

                }

                t = n;

        }

        if(mainloop_timeout.tv_sec > 0 || mainloop_timeout.tv_usec > 0)

                if(time_to_expiry(&mainloop_timeout) <= 0)

                        return TRUE;

        return FALSE;

}

static void calculate_timeval(struct timeval *tv, MWTIMEOUT to)

{

        tv->tv_sec = current_time.tv_sec + (to / 1000);

        tv->tv_usec = current_time.tv_usec + ((to % 1000) * 1000);

        if(tv->tv_usec > 1000000) {

                tv->tv_sec++;

                tv->tv_usec -= 1000000;

        }

}

static signed long time_to_expiry(struct timeval *t)

{

        MWTIMEOUT ret = (((t->tv_sec - current_time.tv_sec) * 1000) +

                        ((t->tv_usec - current_time.tv_usec) / 1000));

        return ret;

}