344 lines
7.8 KiB
C
344 lines
7.8 KiB
C
/*
|
|
* ircd-ratbox: A slightly useful ircd.
|
|
* event.c: Event functions.
|
|
*
|
|
* Copyright (C) 1998-2000 Regents of the University of California
|
|
* Copyright (C) 2001-2002 Hybrid Development Team
|
|
* Copyright (C) 2002-2005 ircd-ratbox development team
|
|
*
|
|
* Code borrowed from the squid web cache by Adrian Chadd.
|
|
* Original header:
|
|
*
|
|
* DEBUG: section 41 Event Processing
|
|
* AUTHOR: Henrik Nordstrom
|
|
*
|
|
* SQUID Internet Object Cache http://squid.nlanr.net/Squid/
|
|
* ----------------------------------------------------------
|
|
*
|
|
* Squid is the result of efforts by numerous individuals from the
|
|
* Internet community. Development is led by Duane Wessels of the
|
|
* National Laboratory for Applied Network Research and funded by the
|
|
* National Science Foundation. Squid is Copyrighted (C) 1998 by
|
|
* the Regents of the University of California. Please see the
|
|
* COPYRIGHT file for full details. Squid incorporates software
|
|
* developed and/or copyrighted by other sources. Please see the
|
|
* CREDITS file for full details.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
|
|
* USA
|
|
*
|
|
*/
|
|
|
|
#include <libratbox_config.h>
|
|
#include <ratbox_lib.h>
|
|
#include <commio-int.h>
|
|
#include <event-int.h>
|
|
|
|
#define EV_NAME_LEN 33
|
|
static char last_event_ran[EV_NAME_LEN];
|
|
static rb_dlink_list event_list;
|
|
|
|
static time_t event_time_min = -1;
|
|
|
|
/*
|
|
* struct ev_entry *
|
|
* rb_event_find(EVH *func, void *arg)
|
|
*
|
|
* Input: Event function and the argument passed to it
|
|
* Output: Index to the slow in the event_table
|
|
* Side Effects: None
|
|
*/
|
|
static struct ev_entry *
|
|
rb_event_find(EVH * func, void *arg)
|
|
{
|
|
rb_dlink_node *ptr;
|
|
struct ev_entry *ev;
|
|
RB_DLINK_FOREACH(ptr, event_list.head)
|
|
{
|
|
ev = ptr->data;
|
|
if((ev->func == func) && (ev->arg == arg))
|
|
return ev;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* struct ev_entry *
|
|
* rb_event_add(const char *name, EVH *func, void *arg, time_t when)
|
|
*
|
|
* Input: Name of event, function to call, arguments to pass, and frequency
|
|
* of the event.
|
|
* Output: None
|
|
* Side Effects: Adds the event to the event list.
|
|
*/
|
|
struct ev_entry *
|
|
rb_event_add(const char *name, EVH * func, void *arg, time_t when)
|
|
{
|
|
struct ev_entry *ev;
|
|
ev = rb_malloc(sizeof(struct ev_entry));
|
|
ev->func = func;
|
|
ev->name = rb_strndup(name, EV_NAME_LEN);
|
|
ev->arg = arg;
|
|
ev->when = rb_current_time() + when;
|
|
ev->next = when;
|
|
ev->frequency = when;
|
|
|
|
if((ev->when < event_time_min) || (event_time_min == -1))
|
|
{
|
|
event_time_min = ev->when;
|
|
}
|
|
rb_dlinkAdd(ev, &ev->node, &event_list);
|
|
rb_io_sched_event(ev, when);
|
|
return ev;
|
|
}
|
|
|
|
struct ev_entry *
|
|
rb_event_addonce(const char *name, EVH * func, void *arg, time_t when)
|
|
{
|
|
struct ev_entry *ev;
|
|
ev = rb_malloc(sizeof(struct ev_entry));
|
|
ev->func = func;
|
|
ev->name = rb_strndup(name, EV_NAME_LEN);
|
|
ev->arg = arg;
|
|
ev->when = rb_current_time() + when;
|
|
ev->next = when;
|
|
ev->frequency = 0;
|
|
|
|
if((ev->when < event_time_min) || (event_time_min == -1))
|
|
event_time_min = ev->when;
|
|
|
|
rb_dlinkAdd(ev, &ev->node, &event_list);
|
|
rb_io_sched_event(ev, when);
|
|
return ev;
|
|
}
|
|
|
|
/*
|
|
* void rb_event_delete(struct ev_entry *ev)
|
|
*
|
|
* Input: pointer to ev_entry for the event
|
|
* Output: None
|
|
* Side Effects: Removes the event from the event list
|
|
*/
|
|
void
|
|
rb_event_delete(struct ev_entry *ev)
|
|
{
|
|
if(ev == NULL)
|
|
return;
|
|
|
|
rb_dlinkDelete(&ev->node, &event_list);
|
|
rb_io_unsched_event(ev);
|
|
rb_free(ev->name);
|
|
rb_free(ev);
|
|
}
|
|
|
|
/*
|
|
* void rb_event_find_delete(EVH *func, void *arg)
|
|
*
|
|
* Input: pointer to func and data
|
|
* Output: None
|
|
* Side Effects: Removes the event from the event list
|
|
*/
|
|
void
|
|
rb_event_find_delete(EVH * func, void *arg)
|
|
{
|
|
rb_event_delete(rb_event_find(func, arg));
|
|
}
|
|
|
|
/*
|
|
* struct ev_entry *
|
|
* rb_event_addish(const char *name, EVH *func, void *arg, time_t delta_isa)
|
|
*
|
|
* Input: Name of event, function to call, arguments to pass, and frequency
|
|
* of the event.
|
|
* Output: None
|
|
* Side Effects: Adds the event to the event list within +- 1/3 of the
|
|
* specified frequency.
|
|
*/
|
|
struct ev_entry *
|
|
rb_event_addish(const char *name, EVH * func, void *arg, time_t delta_ish)
|
|
{
|
|
if(delta_ish >= 3.0)
|
|
{
|
|
const time_t two_third = (2 * delta_ish) / 3;
|
|
delta_ish = two_third + ((rand() % 1000) * two_third) / 1000;
|
|
/*
|
|
* XXX I hate the above magic, I don't even know if its right.
|
|
* Grr. -- adrian
|
|
*/
|
|
}
|
|
return rb_event_add(name, func, arg, delta_ish);
|
|
}
|
|
|
|
|
|
void
|
|
rb_run_event(struct ev_entry *ev)
|
|
{
|
|
rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
|
|
ev->func(ev->arg);
|
|
if(!ev->frequency)
|
|
{
|
|
rb_io_unsched_event(ev);
|
|
rb_dlinkDelete(&ev->node, &event_list);
|
|
rb_free(ev);
|
|
return;
|
|
}
|
|
ev->when = rb_current_time() + ev->frequency;
|
|
if((ev->when < event_time_min) || (event_time_min == -1))
|
|
event_time_min = ev->when;
|
|
}
|
|
|
|
/*
|
|
* void rb_event_run(void)
|
|
*
|
|
* Input: None
|
|
* Output: None
|
|
* Side Effects: Runs pending events in the event list
|
|
*/
|
|
void
|
|
rb_event_run(void)
|
|
{
|
|
rb_dlink_node *ptr, *next;
|
|
struct ev_entry *ev;
|
|
|
|
if(rb_io_supports_event())
|
|
return;
|
|
|
|
event_time_min = -1;
|
|
RB_DLINK_FOREACH_SAFE(ptr, next, event_list.head)
|
|
{
|
|
ev = ptr->data;
|
|
if(ev->when <= rb_current_time())
|
|
{
|
|
rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
|
|
ev->func(ev->arg);
|
|
|
|
/* event is scheduled more than once */
|
|
if(ev->frequency)
|
|
{
|
|
ev->when = rb_current_time() + ev->frequency;
|
|
if((ev->when < event_time_min) || (event_time_min == -1))
|
|
event_time_min = ev->when;
|
|
}
|
|
else
|
|
{
|
|
rb_dlinkDelete(&ev->node, &event_list);
|
|
rb_free(ev);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((ev->when < event_time_min) || (event_time_min == -1))
|
|
event_time_min = ev->when;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
rb_event_io_register_all(void)
|
|
{
|
|
rb_dlink_node *ptr;
|
|
struct ev_entry *ev;
|
|
|
|
if(!rb_io_supports_event())
|
|
return;
|
|
|
|
RB_DLINK_FOREACH(ptr, event_list.head)
|
|
{
|
|
ev = ptr->data;
|
|
rb_io_sched_event(ev, ev->next);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* void rb_event_init(void)
|
|
*
|
|
* Input: None
|
|
* Output: None
|
|
* Side Effects: Initializes the event system.
|
|
*/
|
|
void
|
|
rb_event_init(void)
|
|
{
|
|
rb_strlcpy(last_event_ran, "NONE", sizeof(last_event_ran));
|
|
}
|
|
|
|
void
|
|
rb_dump_events(void (*func) (char *, void *), void *ptr)
|
|
{
|
|
int len;
|
|
char buf[512];
|
|
rb_dlink_node *dptr;
|
|
struct ev_entry *ev;
|
|
len = sizeof(buf);
|
|
|
|
rb_snprintf(buf, len, "Last event to run: %s", last_event_ran);
|
|
func(buf, ptr);
|
|
|
|
rb_strlcpy(buf, "Operation Next Execution", len);
|
|
func(buf, ptr);
|
|
|
|
RB_DLINK_FOREACH(dptr, event_list.head)
|
|
{
|
|
ev = dptr->data;
|
|
rb_snprintf(buf, len, "%-28s %-4ld seconds", ev->name,
|
|
ev->when - (long)rb_current_time());
|
|
func(buf, ptr);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* void rb_set_back_events(time_t by)
|
|
* Input: Time to set back events by.
|
|
* Output: None.
|
|
* Side-effects: Sets back all events by "by" seconds.
|
|
*/
|
|
void
|
|
rb_set_back_events(time_t by)
|
|
{
|
|
rb_dlink_node *ptr;
|
|
struct ev_entry *ev;
|
|
RB_DLINK_FOREACH(ptr, event_list.head)
|
|
{
|
|
ev = ptr->data;
|
|
if(ev->when > by)
|
|
ev->when -= by;
|
|
else
|
|
ev->when = 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
rb_event_update(struct ev_entry *ev, time_t freq)
|
|
{
|
|
if(ev == NULL)
|
|
return;
|
|
|
|
ev->frequency = freq;
|
|
|
|
/* update when its scheduled to run if its higher
|
|
* than the new frequency
|
|
*/
|
|
if((rb_current_time() + freq) < ev->when)
|
|
ev->when = rb_current_time() + freq;
|
|
return;
|
|
}
|
|
|
|
time_t
|
|
rb_event_next(void)
|
|
{
|
|
return event_time_min;
|
|
}
|