2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Volker Lendecke 2005
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.
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.
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/>.
24 struct timed_event
*next
, *prev
;
25 struct event_context
*event_ctx
;
27 const char *event_name
;
28 void (*handler
)(struct event_context
*event_ctx
,
29 struct timed_event
*te
,
36 struct fd_event
*prev
, *next
;
37 struct event_context
*event_ctx
;
39 uint16_t flags
; /* see EVENT_FD_* flags */
40 void (*handler
)(struct event_context
*event_ctx
,
41 struct fd_event
*event
,
47 struct event_context
{
48 struct timed_event
*timed_events
;
49 struct fd_event
*fd_events
;
52 static int timed_event_destructor(struct timed_event
*te
)
54 DEBUG(10, ("Destroying timed event %lx \"%s\"\n", (unsigned long)te
,
56 if (te
->event_ctx
!= NULL
) {
57 DLIST_REMOVE(te
->event_ctx
->timed_events
, te
);
62 /****************************************************************************
64 ****************************************************************************/
66 static void add_event_by_time(struct timed_event
*te
)
68 struct event_context
*ctx
= te
->event_ctx
;
69 struct timed_event
*last_te
, *cur_te
;
71 /* Keep the list ordered by time. We must preserve this. */
73 for (cur_te
= ctx
->timed_events
; cur_te
; cur_te
= cur_te
->next
) {
74 /* if the new event comes before the current one break */
75 if (!timeval_is_zero(&cur_te
->when
) &&
76 timeval_compare(&te
->when
, &cur_te
->when
) < 0) {
82 DLIST_ADD_AFTER(ctx
->timed_events
, te
, last_te
);
85 /****************************************************************************
86 Schedule a function for future calling, cancel with TALLOC_FREE().
87 It's the responsibility of the handler to call TALLOC_FREE() on the event
89 ****************************************************************************/
91 struct timed_event
*_event_add_timed(struct event_context
*event_ctx
,
94 const char *event_name
,
95 void (*handler
)(struct event_context
*event_ctx
,
96 struct timed_event
*te
,
101 struct timed_event
*te
;
103 te
= TALLOC_P(mem_ctx
, struct timed_event
);
105 DEBUG(0, ("talloc failed\n"));
109 te
->event_ctx
= event_ctx
;
111 te
->event_name
= event_name
;
112 te
->handler
= handler
;
113 te
->private_data
= private_data
;
115 add_event_by_time(te
);
117 talloc_set_destructor(te
, timed_event_destructor
);
119 DEBUG(10, ("Added timed event \"%s\": %lx\n", event_name
,
124 static int fd_event_destructor(struct fd_event
*fde
)
126 if (fde
->event_ctx
!= NULL
) {
127 DLIST_REMOVE(fde
->event_ctx
->fd_events
, fde
);
132 struct fd_event
*event_add_fd(struct event_context
*event_ctx
,
134 int fd
, uint16_t flags
,
135 void (*handler
)(struct event_context
*event_ctx
,
136 struct fd_event
*event
,
141 struct fd_event
*fde
;
143 if (fd
< 0 || fd
>= FD_SETSIZE
) {
148 if (!(fde
= TALLOC_P(mem_ctx
, struct fd_event
))) {
152 fde
->event_ctx
= event_ctx
;
155 fde
->handler
= handler
;
156 fde
->private_data
= private_data
;
158 DLIST_ADD(event_ctx
->fd_events
, fde
);
160 talloc_set_destructor(fde
, fd_event_destructor
);
164 void event_fd_set_writeable(struct fd_event
*fde
)
166 fde
->flags
|= EVENT_FD_WRITE
;
169 void event_fd_set_not_writeable(struct fd_event
*fde
)
171 fde
->flags
&= ~EVENT_FD_WRITE
;
174 void event_fd_set_readable(struct fd_event
*fde
)
176 fde
->flags
|= EVENT_FD_READ
;
179 void event_fd_set_not_readable(struct fd_event
*fde
)
181 fde
->flags
&= ~EVENT_FD_READ
;
185 * Return if there's something in the queue
188 bool event_add_to_select_args(struct event_context
*event_ctx
,
189 const struct timeval
*now
,
190 fd_set
*read_fds
, fd_set
*write_fds
,
191 struct timeval
*timeout
, int *maxfd
)
193 struct fd_event
*fde
;
197 for (fde
= event_ctx
->fd_events
; fde
; fde
= fde
->next
) {
198 if (fde
->fd
< 0 || fde
->fd
>= FD_SETSIZE
) {
199 /* We ignore here, as it shouldn't be
200 possible to add an invalid fde->fd
201 but we don't want FD_SET to see an
206 if (fde
->flags
& EVENT_FD_READ
) {
207 FD_SET(fde
->fd
, read_fds
);
210 if (fde
->flags
& EVENT_FD_WRITE
) {
211 FD_SET(fde
->fd
, write_fds
);
215 if ((fde
->flags
& (EVENT_FD_READ
|EVENT_FD_WRITE
))
216 && (fde
->fd
> *maxfd
)) {
221 if (event_ctx
->timed_events
== NULL
) {
225 diff
= timeval_until(now
, &event_ctx
->timed_events
->when
);
226 *timeout
= timeval_min(timeout
, &diff
);
231 bool run_events(struct event_context
*event_ctx
,
232 int selrtn
, fd_set
*read_fds
, fd_set
*write_fds
)
234 struct fd_event
*fde
;
239 if ((event_ctx
->timed_events
!= NULL
)
240 && (timeval_compare(&now
, &event_ctx
->timed_events
->when
) >= 0)) {
242 DEBUG(10, ("Running event \"%s\" %lx\n",
243 event_ctx
->timed_events
->event_name
,
244 (unsigned long)event_ctx
->timed_events
));
246 event_ctx
->timed_events
->handler(
248 event_ctx
->timed_events
, now
,
249 event_ctx
->timed_events
->private_data
);
261 for (fde
= event_ctx
->fd_events
; fde
; fde
= fde
->next
) {
264 if (FD_ISSET(fde
->fd
, read_fds
)) flags
|= EVENT_FD_READ
;
265 if (FD_ISSET(fde
->fd
, write_fds
)) flags
|= EVENT_FD_WRITE
;
267 if (flags
& fde
->flags
) {
268 fde
->handler(event_ctx
, fde
, flags
, fde
->private_data
);
277 struct timeval
*get_timed_events_timeout(struct event_context
*event_ctx
,
278 struct timeval
*to_ret
)
282 if (event_ctx
->timed_events
== NULL
) {
286 now
= timeval_current();
287 *to_ret
= timeval_until(&now
, &event_ctx
->timed_events
->when
);
289 DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret
->tv_sec
,
290 (int)to_ret
->tv_usec
));
295 int event_loop_once(struct event_context
*ev
)
297 struct timeval now
, to
;
305 to
.tv_sec
= 9999; /* Max timeout */
310 if (!event_add_to_select_args(ev
, &now
, &r_fds
, &w_fds
, &to
, &maxfd
)) {
314 if (timeval_is_zero(&to
)) {
315 run_events(ev
, 0, NULL
, NULL
);
319 ret
= sys_select(maxfd
+1, &r_fds
, &w_fds
, NULL
, &to
);
321 if (ret
== -1 && errno
!= EINTR
) {
325 run_events(ev
, ret
, &r_fds
, &w_fds
);
329 static int event_context_destructor(struct event_context
*ev
)
331 while (ev
->fd_events
!= NULL
) {
332 ev
->fd_events
->event_ctx
= NULL
;
333 DLIST_REMOVE(ev
->fd_events
, ev
->fd_events
);
335 while (ev
->timed_events
!= NULL
) {
336 ev
->timed_events
->event_ctx
= NULL
;
337 DLIST_REMOVE(ev
->timed_events
, ev
->timed_events
);
342 void event_context_reinit(struct event_context
*ev
)
344 event_context_destructor(ev
);
348 struct event_context
*event_context_init(TALLOC_CTX
*mem_ctx
)
350 struct event_context
*result
;
352 result
= TALLOC_ZERO_P(mem_ctx
, struct event_context
);
353 if (result
== NULL
) {
357 talloc_set_destructor(result
, event_context_destructor
);
361 void dump_event_list(struct event_context
*event_ctx
)
363 struct timed_event
*te
;
365 struct timeval evt
, now
;
371 now
= timeval_current();
373 DEBUG(10,("dump_event_list:\n"));
375 for (te
= event_ctx
->timed_events
; te
; te
= te
->next
) {
377 evt
= timeval_until(&now
, &te
->when
);
379 DEBUGADD(10,("Timed Event \"%s\" %lx handled in %d seconds (at %s)\n",
383 http_timestring(te
->when
.tv_sec
)));
386 for (fe
= event_ctx
->fd_events
; fe
; fe
= fe
->next
) {
388 DEBUGADD(10,("FD Event %d %lx, flags: 0x%04x\n",