![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to events.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow|
Return to events.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / trafshow |
1.1 misho 1: /*
2: * Copyright (c) 1999-2003 Rinet Corp., Novosibirsk, Russia
3: *
4: * Redistribution and use in source forms, with and without modification,
5: * are permitted provided that this entire comment appears intact.
6: *
7: * THIS SOURCE CODE IS PROVIDED ``AS IS'' WITHOUT ANY WARRANTIES OF ANY KIND.
8: */
9:
10: #ifdef HAVE_CONFIG_H
11: #include <config.h>
12: #endif
13:
14: #include <sys/types.h>
15: #include <sys/time.h>
16: #include <time.h>
17: #include <stdlib.h>
18: #include <string.h>
19:
20: #include "events.h"
21:
22: #define dprintf(x) /* nope */
23:
24: static EVENT *first_event = 0; /* first system event in table */
25:
26: /*
27: * Subtract 2 timeval structs: out = out - in. Out result always greater 0.
28: */
29: void
30: tv_sub(out, in)
31: struct timeval *out;
32: const struct timeval *in;
33: {
34: if (out->tv_sec > in->tv_sec) {
35: out->tv_sec -= in->tv_sec;
36: if (out->tv_usec >= in->tv_usec) {
37: out->tv_usec -= in->tv_usec;
38: } else {
39: out->tv_sec--;
40: out->tv_usec += 1000000L - in->tv_usec;
41: }
42: } else if (out->tv_sec == in->tv_sec) {
43: out->tv_sec = 0L;
44: out->tv_usec -= in->tv_usec;
45: if (out->tv_usec < 1)
46: out->tv_usec = 100L; /* not zero anyway */
47: } else {
48: out->tv_sec = 0L;
49: out->tv_usec = 100L; /* not zero anyway */
50: }
51: }
52:
53: void
54: tv_add(out, in)
55: struct timeval *out;
56: const struct timeval *in;
57: {
58: out->tv_sec += in->tv_sec;
59: out->tv_usec += in->tv_usec;
60: if (out->tv_usec >= 1000000L) {
61: out->tv_sec++;
62: out->tv_usec -= 1000000L;
63: }
64: }
65:
66: /*
67: * Round timeval to seconds.
68: */
69: u_long
70: tv_round(in)
71: const struct timeval *in;
72: {
73: u_long sec = in->tv_sec;
74: if (in->tv_usec >= 500000L)
75: sec++;
76: return sec;
77: }
78:
79: /*
80: * Return time difference in milliseconds.
81: */
82: u_long
83: tv_diff(tvp1, tvp2)
84: const struct timeval *tvp1, *tvp2;
85: {
86: struct timeval diff;
87:
88: if (!timerisset(tvp1) || !timerisset(tvp2))
89: return 0;
90:
91: if (timercmp(tvp1, tvp2, >)) {
92: diff = *tvp1;
93: tv_sub(&diff, tvp2);
94: } else {
95: diff = *tvp2;
96: tv_sub(&diff, tvp1);
97: }
98: return (diff.tv_sec * 1000 + diff.tv_usec / 1000);
99: }
100:
101: /*
102: * Shift the time to be sharp at (12am + N * period), local time.
103: */
104: void
105: tv_sharp(tvp, period)
106: struct timeval *tvp;
107: int period;
108: {
109: time_t defect;
110: struct tm *tm;
111:
112: if (!tvp) return;
113:
114: tm = localtime((time_t *)&tvp->tv_sec);
115: defect = tm->tm_sec + 60 * tm->tm_min + 3600 * tm->tm_hour;
116: defect %= period;
117: period -= defect;
118: if (period < 1) period = 1;
119: tvp->tv_sec += period;
120: tvp->tv_usec = (long)random() % 1000000L;
121: }
122:
123: /*
124: * Execute pending event and schedule the next nearest.
125: */
126: int
127: select_event(tvp)
128: struct timeval *tvp;
129: {
130: EVENT *ep, *next_event;
131: struct timeval now, gap, earliest;
132:
133: gettimeofday(&now, 0);
134: gap.tv_sec = 0;
135: gap.tv_usec = 1000L; /* 0.001sec grip */
136: tv_add(&gap, &now);
137: again:
138: next_event = 0;
139: timerclear(&earliest);
140:
141: for (ep = first_event; ep; ep = ep->next) {
142: /* skip over the empty slots */
143: if (!ep->func) continue;
144:
145: if (timercmp(&gap, &ep->tv, >)) {
146: void (*func)() = ep->func;
147: ep->func = 0; /* free event slot before */
148:
149: dprintf(("-call_event(%p/%p)", func, ep->arg));
150:
151: (*func)(ep->arg); /* call event function */
152: goto again;
153:
154: } else if (!timerisset(&earliest) ||
155: timercmp(&ep->tv, &earliest, <)) {
156: earliest = ep->tv;
157: next_event = ep;
158: }
159: }
160: if (!next_event) { /* no more awaiting events */
161:
162: dprintf(("select_event: no timeout"));
163:
164: return 1; /* timeout undefined */
165: }
166: if (tvp) {
167: tv_sub(&earliest, &now);
168: *tvp = earliest;
169:
170: dprintf(("=wait_event(%p/%p): timeout=%u.%03d",
171: next_event->func, next_event->arg,
172: (unsigned)tvp->tv_sec, (int)(tvp->tv_usec / 1000)));
173: }
174: return 0; /* timeout defined */
175: }
176:
177: /*
178: * Add the new system event to be executed at the given time.
179: */
180: int
181: add_event(tvp, func, arg)
182: struct timeval *tvp;
183: void (*func)(void *);
184: void *arg;
185: {
186: EVENT *ep, *prev = 0, *next = 0;
187: struct timeval now, gap;
188:
189: if (!tvp) {
190: gettimeofday(&now, 0);
191: gap.tv_sec = 0;
192: gap.tv_usec = 250000L; /* 0.25sec mean a bit later */
193: tv_add(&gap, &now);
194: tvp = ⪆
195: }
196:
197: /*
198: * The same event in queue may cause a looping! Prevent it.
199: */
200: for (ep = first_event; ep; ep = ep->next) {
201: if (ep->func == func && ep->arg == arg) {
202: ep->tv = *tvp;
203: dprintf(("=add_event(%p/%p): modify time", func, arg));
204: return 0;
205: }
206: }
207:
208: /*
209: * Search for first empty or last event slot.
210: */
211: for (ep = first_event; ep; ep = ep->next) {
212: if (!ep->func) {
213: next = ep->next;
214: break;
215: }
216: prev = ep;
217: }
218: if (!ep && (ep = (EVENT *)malloc(sizeof(EVENT))) == 0)
219: return -1;
220: memset(ep, 0, sizeof(EVENT));
221: ep->tv = *tvp;
222: ep->func = func;
223: ep->arg = arg;
224: if (next) ep->next = next;
225: else if (prev) prev->next = ep;
226: if (!first_event) first_event = ep;
227:
228: #ifdef notdef
229: {
230: char at_time[50];
231: strftime(at_time, sizeof(at_time), "%T",
232: localtime((time_t *)&ep->tv.tv_sec));
233: dprintf(("+add_event(%p/%p): schedule=%s.%03d",
234: func, arg, at_time, (int)(tvp->tv_usec / 1000)));
235: }
236: #endif
237: return 0;
238: }
239:
240: /*
241: * Remove system event from queue if any.
242: */
243: int
244: remove_event(func, arg)
245: void (*func)(void *);
246: void *arg;
247: {
248: int found = 0;
249: EVENT *ep;
250:
251: for (ep = first_event; ep; ep = ep->next) {
252: if ((!func || ep->func == func) && ep->arg == arg) {
253: ep->func = 0;
254: found++;
255: }
256: }
257: return found;
258: }
259:
260: /*
261: * Modify existing system event in queue for the new function argument.
262: */
263: int
264: change_event(func, arg, new_arg)
265: void (*func)(void *);
266: void *arg, *new_arg;
267: {
268: int found = 0;
269: EVENT *ep;
270:
271: for (ep = first_event; ep; ep = ep->next) {
272: if ((!func || ep->func == func) && ep->arg == arg) {
273: ep->arg = new_arg;
274: found++;
275: }
276: }
277: return found;
278: }
279:
280: EVENT *
281: find_event(func, arg)
282: void (*func)(void *);
283: void *arg;
284: {
285: EVENT *ep;
286:
287: for (ep = first_event; ep; ep = ep->next) {
288: if (ep->func == func && ep->arg == arg)
289: return ep;
290: }
291: return 0;
292: }
293:
294: void
295: free_events()
296: {
297: EVENT *ep, *next;
298:
299: ep = first_event;
300: while (ep) {
301: next = ep->next;
302: free(ep);
303: ep = next;
304: }
305: first_event = 0;
306: }