[solanum.git] / librb / src / event.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 <librb_config.h>
#include <rb_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;
}

static
struct ev_entry *
rb_event_add_common(const char *name, EVH * func, void *arg, time_t when, time_t frequency)
{
	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 = frequency;
	ev->dead = 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;
}

/*
 * 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)
{
	if (rb_unlikely(when <= 0)) {
		rb_lib_log("rb_event_add: tried to schedule %s event with a delay of "
			"%d seconds", name, (int) when);
		when = 1;
	}

	return rb_event_add_common(name, func, arg, when, when);
}

struct ev_entry *
rb_event_addonce(const char *name, EVH * func, void *arg, time_t when)
{
	if (rb_unlikely(when <= 0)) {
		rb_lib_log("rb_event_addonce: tried to schedule %s event to run in "
			"%d seconds", name, (int) when);
		when = 1;
	}

	return rb_event_add_common(name, func, arg, when, 0);
}

/*
 * 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;

	ev->dead = 1;

	rb_io_unsched_event(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));
}

static time_t
rb_event_frequency(time_t frequency)
{
	if(frequency < 0)
	{
		const time_t two_third = (2 * labs(frequency)) / 3;
		frequency = two_third + ((rand() % 1000) * two_third) / 1000;
	}
	return frequency;
}

/*
 * 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)
{
	delta_ish = labs(delta_ish);
	if(delta_ish >= 3.0)
		delta_ish = -delta_ish;
	return rb_event_add_common(name, func, arg,
		rb_event_frequency(delta_ish), delta_ish);
}


void
rb_run_one_event(struct ev_entry *ev)
{
	rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
	ev->func(ev->arg);
	if(!ev->frequency)
	{
		rb_event_delete(ev);
		return;
	}
	ev->when = rb_current_time() + rb_event_frequency(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->dead)
		{
			rb_dlinkDelete(&ev->node, &event_list);
			rb_free(ev->name);
			rb_free(ev);
			continue;
		}
		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() + rb_event_frequency(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->name);
				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)
{
	char buf[512];
	rb_dlink_node *dptr;
	struct ev_entry *ev;

	snprintf(buf, sizeof buf, "Last event to run: %s", last_event_ran);
	func(buf, ptr);

	rb_strlcpy(buf, "Operation                    Next Execution", sizeof buf);
	func(buf, ptr);

	RB_DLINK_FOREACH(dptr, event_list.head)
	{
		ev = dptr->data;
		snprintf(buf, sizeof buf, "%-28s %-4lld seconds (frequency=%d)", ev->name,
			    (long long)(ev->when - rb_current_time()), (int)ev->frequency);
		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 it's scheduled to run if it's higher
	 * than the new frequency
	 */
	time_t next = rb_event_frequency(freq);
	if((rb_current_time() + next) < ev->when)
		ev->when = rb_current_time() + next;
	return;
}

time_t
rb_event_next(void)
{
	return event_time_min;
}
Commit	Line	Data
db137867 AC	1	/*
	2	* ircd-ratbox: A slightly useful ircd.
	3	* event.c: Event functions.
	4	*
	5	* Copyright (C) 1998-2000 Regents of the University of California
	6	* Copyright (C) 2001-2002 Hybrid Development Team
	7	* Copyright (C) 2002-2005 ircd-ratbox development team
	8	*
	9	* Code borrowed from the squid web cache by Adrian Chadd.
	10	* Original header:
	11	*
	12	* DEBUG: section 41 Event Processing
	13	* AUTHOR: Henrik Nordstrom
	14	*
	15	* SQUID Internet Object Cache http://squid.nlanr.net/Squid/
	16	* ----------------------------------------------------------
	17	*
	18	* Squid is the result of efforts by numerous individuals from the
	19	* Internet community. Development is led by Duane Wessels of the
	20	* National Laboratory for Applied Network Research and funded by the
	21	* National Science Foundation. Squid is Copyrighted (C) 1998 by
	22	* the Regents of the University of California. Please see the
	23	* COPYRIGHT file for full details. Squid incorporates software
	24	* developed and/or copyrighted by other sources. Please see the
	25	* CREDITS file for full details.
	26	*
	27	* This program is free software; you can redistribute it and/or modify
	28	* it under the terms of the GNU General Public License as published by
	29	* the Free Software Foundation; either version 2 of the License, or
	30	* (at your option) any later version.
	31	*
	32	* This program is distributed in the hope that it will be useful,
	33	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	34	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	35	* GNU General Public License for more details.
	36	*
	37	* You should have received a copy of the GNU General Public License
	38	* along with this program; if not, write to the Free Software
	39	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
	40	* USA
	41	*
db137867 AC	42	*/
db137867 AC	43
fe037171 EM	44	#include <librb_config.h>
fe037171 EM	45	#include <rb_lib.h>
db137867 AC	46	#include <commio-int.h>
	47	#include <event-int.h>
	48
3202e249 VY	49	#define EV_NAME_LEN 33
3202e249 VY	50	static char last_event_ran[EV_NAME_LEN];
db137867 AC	51	static rb_dlink_list event_list;
	52
	53	static time_t event_time_min = -1;
db137867 AC	54
db137867 AC	55	/*
55abcbb2	56	* struct ev_entry *
db137867 AC	57	* rb_event_find(EVH func, void arg)
	58	*
	59	* Input: Event function and the argument passed to it
	60	* Output: Index to the slow in the event_table
	61	* Side Effects: None
	62	*/
	63	static struct ev_entry *
	64	rb_event_find(EVH * func, void *arg)
	65	{
	66	rb_dlink_node *ptr;
	67	struct ev_entry *ev;
	68	RB_DLINK_FOREACH(ptr, event_list.head)
	69	{
	70	ev = ptr->data;
	71	if((ev->func == func) && (ev->arg == arg))
	72	return ev;
	73	}
	74
	75	return NULL;
	76	}
	77
8ace0906 SA	78	static
	79	struct ev_entry *
	80	rb_event_add_common(const char name, EVH func, void *arg, time_t when, time_t frequency)
	81	{
	82	struct ev_entry *ev;
	83	ev = rb_malloc(sizeof(struct ev_entry));
	84	ev->func = func;
	85	ev->name = rb_strndup(name, EV_NAME_LEN);
	86	ev->arg = arg;
	87	ev->when = rb_current_time() + when;
	88	ev->next = when;
	89	ev->frequency = frequency;
3576d1b4	90	ev->dead = 0;
8ace0906 SA	91
	92	if((ev->when < event_time_min) \|\| (event_time_min == -1))
	93	event_time_min = ev->when;
	94
	95	rb_dlinkAdd(ev, &ev->node, &event_list);
	96	rb_io_sched_event(ev, when);
	97	return ev;
	98	}
	99
db137867	100	/*
55abcbb2	101	* struct ev_entry *
db137867 AC	102	* rb_event_add(const char name, EVH func, void *arg, time_t when)
	103	*
	104	* Input: Name of event, function to call, arguments to pass, and frequency
	105	* of the event.
	106	* Output: None
	107	* Side Effects: Adds the event to the event list.
	108	*/
	109	struct ev_entry *
	110	rb_event_add(const char name, EVH func, void *arg, time_t when)
	111	{
8db50c03 KB	112	if (rb_unlikely(when <= 0)) {
	113	rb_lib_log("rb_event_add: tried to schedule %s event with a delay of "
	114	"%d seconds", name, (int) when);
	115	when = 1;
	116	}
db137867	117
8ace0906	118	return rb_event_add_common(name, func, arg, when, when);
db137867	119	}
3202e249	120
db137867 AC	121	struct ev_entry *
	122	rb_event_addonce(const char name, EVH func, void *arg, time_t when)
	123	{
8db50c03 KB	124	if (rb_unlikely(when <= 0)) {
	125	rb_lib_log("rb_event_addonce: tried to schedule %s event to run in "
	126	"%d seconds", name, (int) when);
	127	when = 1;
	128	}
db137867	129
8ace0906	130	return rb_event_add_common(name, func, arg, when, 0);
db137867 AC	131	}
	132
	133	/*
	134	* void rb_event_delete(struct ev_entry *ev)
	135	*
	136	* Input: pointer to ev_entry for the event
	137	* Output: None
	138	* Side Effects: Removes the event from the event list
	139	*/
	140	void
	141	rb_event_delete(struct ev_entry *ev)
	142	{
	143	if(ev == NULL)
	144	return;
	145
3576d1b4 EK	146	ev->dead = 1;
3576d1b4 EK	147
db137867	148	rb_io_unsched_event(ev);
db137867 AC	149	}
	150
	151	/*
	152	* void rb_event_find_delete(EVH func, void arg)
	153	*
	154	* Input: pointer to func and data
	155	* Output: None
	156	* Side Effects: Removes the event from the event list
	157	*/
	158	void
3202e249	159	rb_event_find_delete(EVH * func, void *arg)
db137867 AC	160	{
	161	rb_event_delete(rb_event_find(func, arg));
	162	}
	163
8ace0906 SA	164	static time_t
	165	rb_event_frequency(time_t frequency)
	166	{
	167	if(frequency < 0)
	168	{
a1125230	169	const time_t two_third = (2 * labs(frequency)) / 3;
8ace0906 SA	170	frequency = two_third + ((rand() % 1000) * two_third) / 1000;
	171	}
	172	return frequency;
	173	}
	174
55abcbb2	175	/*
db137867 AC	176	* struct ev_entry *
	177	* rb_event_addish(const char name, EVH func, void *arg, time_t delta_isa)
	178	*
	179	* Input: Name of event, function to call, arguments to pass, and frequency
	180	* of the event.
	181	* Output: None
	182	* Side Effects: Adds the event to the event list within +- 1/3 of the
	183	* specified frequency.
	184	*/
	185	struct ev_entry *
	186	rb_event_addish(const char name, EVH func, void *arg, time_t delta_ish)
	187	{
a1125230	188	delta_ish = labs(delta_ish);
db137867	189	if(delta_ish >= 3.0)
8ace0906 SA	190	delta_ish = -delta_ish;
	191	return rb_event_add_common(name, func, arg,
	192	rb_event_frequency(delta_ish), delta_ish);
db137867 AC	193	}
	194
	195
	196	void
0e651b14	197	rb_run_one_event(struct ev_entry *ev)
db137867	198	{
3202e249	199	rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
db137867 AC	200	ev->func(ev->arg);
	201	if(!ev->frequency)
	202	{
1d393245	203	rb_event_delete(ev);
db137867 AC	204	return;
db137867 AC	205	}
8ace0906	206	ev->when = rb_current_time() + rb_event_frequency(ev->frequency);
db137867 AC	207	if((ev->when < event_time_min) \|\| (event_time_min == -1))
	208	event_time_min = ev->when;
	209	}
	210
	211	/*
	212	* void rb_event_run(void)
	213	*
	214	* Input: None
	215	* Output: None
	216	* Side Effects: Runs pending events in the event list
	217	*/
	218	void
	219	rb_event_run(void)
	220	{
	221	rb_dlink_node ptr, next;
	222	struct ev_entry *ev;
3202e249	223
db137867 AC	224	if(rb_io_supports_event())
	225	return;
	226
	227	event_time_min = -1;
	228	RB_DLINK_FOREACH_SAFE(ptr, next, event_list.head)
	229	{
	230	ev = ptr->data;
3576d1b4 EK	231	if (ev->dead)
	232	{
	233	rb_dlinkDelete(&ev->node, &event_list);
	234	rb_free(ev->name);
	235	rb_free(ev);
	236	continue;
	237	}
db137867 AC	238	if(ev->when <= rb_current_time())
db137867 AC	239	{
3202e249	240	rb_strlcpy(last_event_ran, ev->name, sizeof(last_event_ran));
db137867 AC	241	ev->func(ev->arg);
	242
	243	/* event is scheduled more than once */
3202e249	244	if(ev->frequency)
db137867	245	{
8ace0906	246	ev->when = rb_current_time() + rb_event_frequency(ev->frequency);
db137867 AC	247	if((ev->when < event_time_min) \|\| (event_time_min == -1))
	248	event_time_min = ev->when;
	249	}
	250	else
	251	{
	252	rb_dlinkDelete(&ev->node, &event_list);
ad516b7d	253	rb_free(ev->name);
db137867 AC	254	rb_free(ev);
db137867 AC	255	}
3202e249 VY	256	}
	257	else
	258	{
db137867 AC	259	if((ev->when < event_time_min) \|\| (event_time_min == -1))
	260	event_time_min = ev->when;
	261	}
	262	}
	263	}
	264
	265	void
	266	rb_event_io_register_all(void)
	267	{
	268	rb_dlink_node *ptr;
	269	struct ev_entry *ev;
030272f3	270
db137867 AC	271	if(!rb_io_supports_event())
db137867 AC	272	return;
3202e249	273
db137867	274	RB_DLINK_FOREACH(ptr, event_list.head)
3202e249	275	{
db137867	276	ev = ptr->data;
030272f3	277	rb_io_sched_event(ev, ev->next);
db137867 AC	278	}
db137867 AC	279	}
3202e249	280
db137867 AC	281	/*
	282	* void rb_event_init(void)
	283	*
	284	* Input: None
	285	* Output: None
55abcbb2	286	* Side Effects: Initializes the event system.
db137867 AC	287	*/
	288	void
	289	rb_event_init(void)
	290	{
3202e249	291	rb_strlcpy(last_event_ran, "NONE", sizeof(last_event_ran));
db137867 AC	292	}
	293
	294	void
	295	rb_dump_events(void (func) (char , void ), void ptr)
	296	{
db137867 AC	297	char buf[512];
	298	rb_dlink_node *dptr;
	299	struct ev_entry *ev;
3202e249	300
57aa79ac	301	snprintf(buf, sizeof buf, "Last event to run: %s", last_event_ran);
3202e249 VY	302	func(buf, ptr);
3202e249 VY	303
57aa79ac	304	rb_strlcpy(buf, "Operation Next Execution", sizeof buf);
db137867 AC	305	func(buf, ptr);
	306
	307	RB_DLINK_FOREACH(dptr, event_list.head)
	308	{
	309	ev = dptr->data;
5c01fc8b MM	310	snprintf(buf, sizeof buf, "%-28s %-4lld seconds (frequency=%d)", ev->name,
5c01fc8b MM	311	(long long)(ev->when - rb_current_time()), (int)ev->frequency);
db137867 AC	312	func(buf, ptr);
	313	}
	314	}
	315
55abcbb2	316	/*
db137867 AC	317	* void rb_set_back_events(time_t by)
	318	* Input: Time to set back events by.
	319	* Output: None.
	320	* Side-effects: Sets back all events by "by" seconds.
	321	*/
	322	void
	323	rb_set_back_events(time_t by)
	324	{
	325	rb_dlink_node *ptr;
	326	struct ev_entry *ev;
	327	RB_DLINK_FOREACH(ptr, event_list.head)
	328	{
	329	ev = ptr->data;
	330	if(ev->when > by)
	331	ev->when -= by;
	332	else
	333	ev->when = 0;
	334	}
	335	}
	336
	337	void
	338	rb_event_update(struct ev_entry *ev, time_t freq)
	339	{
	340	if(ev == NULL)
	341	return;
	342
	343	ev->frequency = freq;
	344
8ace0906	345	/* update when it's scheduled to run if it's higher
db137867 AC	346	* than the new frequency
db137867 AC	347	*/
8ace0906 SA	348	time_t next = rb_event_frequency(freq);
	349	if((rb_current_time() + next) < ev->when)
	350	ev->when = rb_current_time() + next;
db137867 AC	351	return;
	352	}
	353
	354	time_t
	355	rb_event_next(void)
	356	{
	357	return event_time_min;
	358	}