dhcp-timer.c

来自「this is sample about DHCP-agent」· C语言 代码 · 共 197 行

/* $Header: /cvsroot/dhcp-agent/dhcp-agent/src/dhcp-timer.c,v 1.11 2003/06/23 06:05:03 actmodern Exp $
 * 
 * Copyright 2002 Thamer Alharbash <[e-mail]>
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in
 * the documentation and/or other materials provided with the
 * distribution.
 * 3. The names of the authors may not be used to endorse or promote
 * products derived from this software without specific prior
 * written permission.
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Timer keeper object to keep track of an infinite number of timers.
 * We can add new timers to it, activate it when we want to,
 * deactivate it, and remove timers.
 *
 * All timers have an unsigned 32-bit integer ID assigned to them.
 *
 */

#define MODULE_NAME "dhcp-timer"

#include "dhcp-local.h"
#include "dhcp-libutil.h"

/* compare triggers by returning smallest id as highest. */
static int compare_triggers_shortest(void *trigger1_p, void *trigger2_p)
{
    timer_trigger_t *trigger1, *trigger2;

    trigger1 = trigger1_p;
    trigger2 = trigger2_p;

    if(trigger1->id < trigger2->id)
        return 1;

    if(trigger1->id > trigger2->id)
        return -1;

    return 0;
}

/* create a new trigger. */
static timer_trigger_t *create_trigger(uint32_t trigger_time, uint32_t id)
{
    timer_trigger_t *trigger = xmalloc(sizeof(timer_trigger_t));

    trigger->seconds = trigger_time;
    trigger->id = id;
    trigger->time_set = time(NULL);

    return trigger;
}

/* destroy a trigger. */
static void destroy_trigger(timer_trigger_t *trigger)
{
    xfree(trigger);
}

/* destroy a trigger in a list. */
static void destroy_trigger_l(void *trigger)
{
    destroy_trigger(trigger);
}

/* create a new timer keeper. */
timer_keeper_t *create_timer(void)
{
    timer_keeper_t *timer;

    timer = xmalloc(sizeof(timer_keeper_t));
    timer->triggers = list_create();

    return timer;
}

/* destroy a timer keeper. */
void destroy_timer(timer_keeper_t *timer)
{
    list_destroy(timer->triggers, destroy_trigger_l);
    xfree(timer);

    return;
}

void reinitialize_timer(timer_keeper_t *timer)
{
    list_destroy(timer->triggers, destroy_trigger_l);
    timer->triggers = list_create();
}

/* add a new trigger. */
void timer_add_trigger(timer_keeper_t *timer, uint32_t trigger_time, uint32_t id)
{
    timer_trigger_t *trigger = create_trigger(trigger_time, id);
    list_add(timer->triggers, trigger);
    timer->triggers = list_sort(timer->triggers, compare_triggers_shortest);

    return;
}

/* utility to grab next valid timer: this will delete ones which have passed since. */
static timer_trigger_t *get_next_timer(timer_keeper_t *timer)
{
    uint32_t time_left;
    timer_trigger_t *trigger;
    uint32_t time_now;

  begin:

    if(list_get_len(timer->triggers) == 0)
        return NULL;

    trigger = list_first(timer->triggers);
    time_now = time(NULL);
    time_left = trigger->seconds - (time_now - trigger->time_set);

    if(time_left > trigger->seconds) {
        /* overflow. get the next timer. */
        list_remove_by_datum(timer->triggers, trigger);
        destroy_trigger(trigger);

        goto begin;
    }

    trigger->seconds = time_left;
    trigger->time_set = time_now;
    return trigger;
}

/* timer setup next trigger. */
int timer_set_next(timer_keeper_t *timer)
{

    timer_trigger_t *trigger;
    trigger = get_next_timer(timer);

    if(trigger == NULL)
        return 1;

    set_alarm(trigger->seconds);
    timer->current_id = trigger->id;
    list_remove_by_datum(timer->triggers, trigger);
    destroy_trigger(trigger);

    return 0;
}

uint32_t timer_get_current_id(timer_keeper_t *timer)
{
    return timer->current_id;
}

uint32_t timer_peek_next_timer(timer_keeper_t *timer)
{
    timer_trigger_t *trigger;

    trigger = get_next_timer(timer);

    if(trigger == NULL)
        return INFINITE_TIME;

    return trigger->seconds;
}

/* make a copy of a timer: achtung this doesn't fiddle with any
 * timers already set. */
timer_keeper_t *timer_copy(timer_keeper_t *timer)
{
    timer_keeper_t *timer_copy;
    timer_trigger_t *trigger;

    timer_copy = create_timer();

    /* now copy over individual triggers by recreating them. */

    list_rewind(timer->triggers);
    while((trigger = list_next(timer->triggers)) != NULL) {

       list_add(timer_copy->triggers, create_trigger(trigger->seconds, trigger->id));
    }

    timer_copy->triggers = list_sort(timer_copy->triggers, compare_triggers_shortest);
    return timer_copy;
}