source: trunk/server/source3/lib/events.c@ 559

Last change on this file since 559 was 429, checked in by Silvan Scherrer, 16 years ago

Samba 3.5.x: trunk update to 3.5.2
File size: 7.6 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Timed event library.
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Volker Lendecke 2005
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22#include <tevent_internal.h>
23
24void event_fd_set_writeable(struct tevent_fd *fde)
25{
26 TEVENT_FD_WRITEABLE(fde);
27}
28
29void event_fd_set_not_writeable(struct tevent_fd *fde)
30{
31 TEVENT_FD_NOT_WRITEABLE(fde);
32}
33
34void event_fd_set_readable(struct tevent_fd *fde)
35{
36 TEVENT_FD_READABLE(fde);
37}
38
39void event_fd_set_not_readable(struct tevent_fd *fde)
40{
41 TEVENT_FD_NOT_READABLE(fde);
42}
43
44/*
45 * Return if there's something in the queue
46 */
47
48bool event_add_to_select_args(struct tevent_context *ev,
49 const struct timeval *now,
50 fd_set *read_fds, fd_set *write_fds,
51 struct timeval *timeout, int *maxfd)
52{
53 struct tevent_fd *fde;
54 struct timeval diff;
55 bool ret = false;
56
57 for (fde = ev->fd_events; fde; fde = fde->next) {
58 if (fde->flags & EVENT_FD_READ) {
59 FD_SET(fde->fd, read_fds);
60 ret = true;
61 }
62 if (fde->flags & EVENT_FD_WRITE) {
63 FD_SET(fde->fd, write_fds);
64 ret = true;
65 }
66
67 if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
68 && (fde->fd > *maxfd)) {
69 *maxfd = fde->fd;
70 }
71 }
72
73 if (ev->immediate_events != NULL) {
74 *timeout = timeval_zero();
75 return true;
76 }
77
78 if (ev->timer_events == NULL) {
79 return ret;
80 }
81
82 diff = timeval_until(now, &ev->timer_events->next_event);
83 *timeout = timeval_min(timeout, &diff);
84
85 return true;
86}
87
88bool run_events(struct tevent_context *ev,
89 int selrtn, fd_set *read_fds, fd_set *write_fds)
90{
91 struct tevent_fd *fde;
92 struct timeval now;
93
94 if (ev->signal_events &&
95 tevent_common_check_signal(ev)) {
96 return true;
97 }
98
99 if (ev->immediate_events &&
100 tevent_common_loop_immediate(ev)) {
101 return true;
102 }
103
104 GetTimeOfDay(&now);
105
106 if ((ev->timer_events != NULL)
107 && (timeval_compare(&now, &ev->timer_events->next_event) >= 0)) {
108 /* this older events system did not auto-free timed
109 events on running them, and had a race condition
110 where the event could be called twice if the
111 talloc_free of the te happened after the callback
112 made a call which invoked the event loop. To avoid
113 this while still allowing old code which frees the
114 te, we need to create a temporary context which
115 will be used to ensure the te is freed. We also
116 remove the te from the timed event list before we
117 call the handler, to ensure we can't loop */
118
119 struct tevent_timer *te = ev->timer_events;
120 TALLOC_CTX *tmp_ctx = talloc_new(ev);
121
122 DEBUG(10, ("Running timed event \"%s\" %p\n",
123 ev->timer_events->handler_name, ev->timer_events));
124
125 DLIST_REMOVE(ev->timer_events, te);
126 talloc_steal(tmp_ctx, te);
127
128 te->handler(ev, te, now, te->private_data);
129
130 talloc_free(tmp_ctx);
131 return true;
132 }
133
134 if (selrtn == 0) {
135 /*
136 * No fd ready
137 */
138 return false;
139 }
140
141 for (fde = ev->fd_events; fde; fde = fde->next) {
142 uint16 flags = 0;
143
144 if (FD_ISSET(fde->fd, read_fds)) flags |= EVENT_FD_READ;
145 if (FD_ISSET(fde->fd, write_fds)) flags |= EVENT_FD_WRITE;
146
147 if (flags & fde->flags) {
148 fde->handler(ev, fde, flags, fde->private_data);
149 return true;
150 }
151 }
152
153 return false;
154}
155
156
157struct timeval *get_timed_events_timeout(struct tevent_context *ev,
158 struct timeval *to_ret)
159{
160 struct timeval now;
161
162 if ((ev->timer_events == NULL) && (ev->immediate_events == NULL)) {
163 return NULL;
164 }
165 if (ev->immediate_events != NULL) {
166 *to_ret = timeval_zero();
167 return to_ret;
168 }
169
170 now = timeval_current();
171 *to_ret = timeval_until(&now, &ev->timer_events->next_event);
172
173 DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret->tv_sec,
174 (int)to_ret->tv_usec));
175
176 return to_ret;
177}
178
179static int s3_event_loop_once(struct tevent_context *ev, const char *location)
180{
181 struct timeval now, to;
182 fd_set r_fds, w_fds;
183 int maxfd = 0;
184 int ret;
185
186 FD_ZERO(&r_fds);
187 FD_ZERO(&w_fds);
188
189 to.tv_sec = 9999; /* Max timeout */
190 to.tv_usec = 0;
191
192 if (run_events(ev, 0, NULL, NULL)) {
193 return 0;
194 }
195
196 GetTimeOfDay(&now);
197
198 if (!event_add_to_select_args(ev, &now, &r_fds, &w_fds, &to, &maxfd)) {
199 return -1;
200 }
201
202 ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
203
204 if (ret == -1 && errno != EINTR) {
205 tevent_debug(ev, TEVENT_DEBUG_FATAL,
206 "sys_select() failed: %d:%s\n",
207 errno, strerror(errno));
208 return -1;
209 }
210
211 run_events(ev, ret, &r_fds, &w_fds);
212 return 0;
213}
214
215void event_context_reinit(struct tevent_context *ev)
216{
217 tevent_common_context_destructor(ev);
218 return;
219}
220
221static int s3_event_context_init(struct tevent_context *ev)
222{
223 return 0;
224}
225
226void dump_event_list(struct tevent_context *ev)
227{
228 struct tevent_timer *te;
229 struct tevent_fd *fe;
230 struct timeval evt, now;
231
232 if (!ev) {
233 return;
234 }
235
236 now = timeval_current();
237
238 DEBUG(10,("dump_event_list:\n"));
239
240 for (te = ev->timer_events; te; te = te->next) {
241
242 evt = timeval_until(&now, &te->next_event);
243
244 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
245 te->handler_name,
246 te,
247 (int)evt.tv_sec,
248 http_timestring(talloc_tos(), te->next_event.tv_sec)));
249 }
250
251 for (fe = ev->fd_events; fe; fe = fe->next) {
252
253 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
254 fe->fd,
255 fe,
256 fe->flags));
257 }
258}
259
260static const struct tevent_ops s3_event_ops = {
261 .context_init = s3_event_context_init,
262 .add_fd = tevent_common_add_fd,
263 .set_fd_close_fn = tevent_common_fd_set_close_fn,
264 .get_fd_flags = tevent_common_fd_get_flags,
265 .set_fd_flags = tevent_common_fd_set_flags,
266 .add_timer = tevent_common_add_timer,
267 .schedule_immediate = tevent_common_schedule_immediate,
268 .add_signal = tevent_common_add_signal,
269 .loop_once = s3_event_loop_once,
270 .loop_wait = tevent_common_loop_wait,
271};
272
273static bool s3_tevent_init(void)
274{
275 static bool initialized;
276 if (initialized) {
277 return true;
278 }
279 initialized = tevent_register_backend("s3", &s3_event_ops);
280 tevent_set_default_backend("s3");
281 return initialized;
282}
283
284/*
285 this is used to catch debug messages from events
286*/
287static void s3_event_debug(void *context, enum tevent_debug_level level,
288 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
289
290static void s3_event_debug(void *context, enum tevent_debug_level level,
291 const char *fmt, va_list ap)
292{
293 int samba_level = -1;
294 char *s = NULL;
295 switch (level) {
296 case TEVENT_DEBUG_FATAL:
297 samba_level = 0;
298 break;
299 case TEVENT_DEBUG_ERROR:
300 samba_level = 1;
301 break;
302 case TEVENT_DEBUG_WARNING:
303 samba_level = 2;
304 break;
305 case TEVENT_DEBUG_TRACE:
306 samba_level = 11;
307 break;
308
309 };
310 if (vasprintf(&s, fmt, ap) == -1) {
311 return;
312 }
313 DEBUG(samba_level, ("s3_event: %s", s));
314 free(s);
315}
316
317struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
318{
319 struct tevent_context *ev;
320
321 s3_tevent_init();
322
323 ev = tevent_context_init_byname(mem_ctx, "s3");
324 if (ev) {
325 tevent_set_debug(ev, s3_event_debug, NULL);
326 }
327
328 return ev;
329}
330
Note: See TracBrowser for help on using the repository browser.