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
,
30 const struct timeval
*now
,
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 #define EVENT_FD_WRITEABLE(fde) \
48 event_set_fd_flags(fde, event_get_fd_flags(fde) | EVENT_FD_WRITE)
49 #define EVENT_FD_READABLE(fde) \
50 event_set_fd_flags(fde, event_get_fd_flags(fde) | EVENT_FD_READ)
52 #define EVENT_FD_NOT_WRITEABLE(fde) \
53 event_set_fd_flags(fde, event_get_fd_flags(fde) & ~EVENT_FD_WRITE)
54 #define EVENT_FD_NOT_READABLE(fde) \
55 event_set_fd_flags(fde, event_get_fd_flags(fde) & ~EVENT_FD_READ)
57 struct event_context
{
58 struct timed_event
*timed_events
;
59 struct fd_event
*fd_events
;
62 static int timed_event_destructor(struct timed_event
*te
)
64 DEBUG(10, ("Destroying timed event %lx \"%s\"\n", (unsigned long)te
,
67 DLIST_REMOVE(te
->event_ctx
->timed_events
, te
);
72 /****************************************************************************
74 ****************************************************************************/
76 static void add_event_by_time(struct timed_event
*te
)
78 struct event_context
*ctx
= te
->event_ctx
;
79 struct timed_event
*last_te
, *cur_te
;
81 /* Keep the list ordered by time. We must preserve this. */
83 for (cur_te
= ctx
->timed_events
; cur_te
; cur_te
= cur_te
->next
) {
84 /* if the new event comes before the current one break */
85 if (!timeval_is_zero(&cur_te
->when
) &&
86 timeval_compare(&te
->when
, &cur_te
->when
) < 0) {
92 DLIST_ADD_AFTER(ctx
->timed_events
, te
, last_te
);
95 /****************************************************************************
96 Schedule a function for future calling, cancel with TALLOC_FREE().
97 It's the responsibility of the handler to call TALLOC_FREE() on the event
99 ****************************************************************************/
101 struct timed_event
*event_add_timed(struct event_context
*event_ctx
,
104 const char *event_name
,
105 void (*handler
)(struct event_context
*event_ctx
,
106 struct timed_event
*te
,
107 const struct timeval
*now
,
111 struct timed_event
*te
;
113 te
= TALLOC_P(mem_ctx
, struct timed_event
);
115 DEBUG(0, ("talloc failed\n"));
119 te
->event_ctx
= event_ctx
;
121 te
->event_name
= event_name
;
122 te
->handler
= handler
;
123 te
->private_data
= private_data
;
125 add_event_by_time(te
);
127 talloc_set_destructor(te
, timed_event_destructor
);
129 DEBUG(10, ("Added timed event \"%s\": %lx\n", event_name
,
134 static int fd_event_destructor(struct fd_event
*fde
)
136 struct event_context
*event_ctx
= fde
->event_ctx
;
139 DLIST_REMOVE(event_ctx
->fd_events
, fde
);
144 struct fd_event
*event_add_fd(struct event_context
*event_ctx
,
146 int fd
, uint16_t flags
,
147 void (*handler
)(struct event_context
*event_ctx
,
148 struct fd_event
*event
,
153 struct fd_event
*fde
;
155 if (!(fde
= TALLOC_P(mem_ctx
, struct fd_event
))) {
159 fde
->event_ctx
= event_ctx
;
162 fde
->handler
= handler
;
163 fde
->private_data
= private_data
;
165 DLIST_ADD(event_ctx
->fd_events
, fde
);
167 talloc_set_destructor(fde
, fd_event_destructor
);
171 void event_fd_set_writeable(struct fd_event
*fde
)
173 fde
->flags
|= EVENT_FD_WRITE
;
176 void event_fd_set_not_writeable(struct fd_event
*fde
)
178 fde
->flags
&= ~EVENT_FD_WRITE
;
181 void event_fd_set_readable(struct fd_event
*fde
)
183 fde
->flags
|= EVENT_FD_READ
;
186 void event_fd_set_not_readable(struct fd_event
*fde
)
188 fde
->flags
&= ~EVENT_FD_READ
;
192 * Return if there's something in the queue
195 bool event_add_to_select_args(struct event_context
*event_ctx
,
196 const struct timeval
*now
,
197 fd_set
*read_fds
, fd_set
*write_fds
,
198 struct timeval
*timeout
, int *maxfd
)
200 struct fd_event
*fde
;
204 for (fde
= event_ctx
->fd_events
; fde
; fde
= fde
->next
) {
205 if (fde
->flags
& EVENT_FD_READ
) {
206 FD_SET(fde
->fd
, read_fds
);
209 if (fde
->flags
& EVENT_FD_WRITE
) {
210 FD_SET(fde
->fd
, write_fds
);
214 if ((fde
->flags
& (EVENT_FD_READ
|EVENT_FD_WRITE
))
215 && (fde
->fd
> *maxfd
)) {
220 if (event_ctx
->timed_events
== NULL
) {
224 diff
= timeval_until(now
, &event_ctx
->timed_events
->when
);
225 *timeout
= timeval_min(timeout
, &diff
);
230 bool events_pending(struct event_context
*event_ctx
)
232 struct fd_event
*fde
;
234 if (event_ctx
->timed_events
!= NULL
) {
237 for (fde
= event_ctx
->fd_events
; fde
; fde
= fde
->next
) {
238 if (fde
->flags
& (EVENT_FD_READ
|EVENT_FD_WRITE
)) {
245 bool run_events(struct event_context
*event_ctx
,
246 int selrtn
, fd_set
*read_fds
, fd_set
*write_fds
)
248 struct fd_event
*fde
;
253 if ((event_ctx
->timed_events
!= NULL
)
254 && (timeval_compare(&now
, &event_ctx
->timed_events
->when
) >= 0)) {
256 DEBUG(10, ("Running event \"%s\" %lx\n",
257 event_ctx
->timed_events
->event_name
,
258 (unsigned long)event_ctx
->timed_events
));
260 event_ctx
->timed_events
->handler(
262 event_ctx
->timed_events
, &now
,
263 event_ctx
->timed_events
->private_data
);
275 for (fde
= event_ctx
->fd_events
; fde
; fde
= fde
->next
) {
278 if (FD_ISSET(fde
->fd
, read_fds
)) flags
|= EVENT_FD_READ
;
279 if (FD_ISSET(fde
->fd
, write_fds
)) flags
|= EVENT_FD_WRITE
;
282 fde
->handler(event_ctx
, fde
, flags
, fde
->private_data
);
291 struct timeval
*get_timed_events_timeout(struct event_context
*event_ctx
,
292 struct timeval
*to_ret
)
296 if (event_ctx
->timed_events
== NULL
) {
300 now
= timeval_current();
301 *to_ret
= timeval_until(&now
, &event_ctx
->timed_events
->when
);
303 DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret
->tv_sec
,
304 (int)to_ret
->tv_usec
));
309 int event_loop_once(struct event_context
*ev
)
311 struct timeval now
, to
;
319 to
.tv_sec
= 9999; /* Max timeout */
324 if (!event_add_to_select_args(ev
, &now
, &r_fds
, &w_fds
, &to
, &maxfd
)) {
328 if (timeval_is_zero(&to
)) {
329 run_events(ev
, 0, NULL
, NULL
);
333 ret
= sys_select(maxfd
+1, &r_fds
, &w_fds
, NULL
, &to
);
335 if (ret
== -1 && errno
!= EINTR
) {
339 run_events(ev
, ret
, &r_fds
, &w_fds
);
343 static int event_context_destructor(struct event_context
*ev
)
345 while (ev
->fd_events
!= NULL
) {
346 ev
->fd_events
->event_ctx
= NULL
;
347 DLIST_REMOVE(ev
->fd_events
, ev
->fd_events
);
349 while (ev
->timed_events
!= NULL
) {
350 ev
->timed_events
->event_ctx
= NULL
;
351 DLIST_REMOVE(ev
->timed_events
, ev
->timed_events
);
356 void event_context_reinit(struct event_context
*ev
)
358 event_context_destructor(ev
);
362 struct event_context
*event_context_init(TALLOC_CTX
*mem_ctx
)
364 struct event_context
*result
;
366 result
= TALLOC_ZERO_P(mem_ctx
, struct event_context
);
367 if (result
== NULL
) {
371 talloc_set_destructor(result
, event_context_destructor
);
375 void dump_event_list(struct event_context
*event_ctx
)
377 struct timed_event
*te
;
379 struct timeval evt
, now
;
385 now
= timeval_current();
387 DEBUG(10,("dump_event_list:\n"));
389 for (te
= event_ctx
->timed_events
; te
; te
= te
->next
) {
391 evt
= timeval_until(&now
, &te
->when
);
393 DEBUGADD(10,("Timed Event \"%s\" %lx handled in %d seconds (at %s)\n",
397 http_timestring(te
->when
.tv_sec
)));
400 for (fe
= event_ctx
->fd_events
; fe
; fe
= fe
->next
) {
402 DEBUGADD(10,("FD Event %d %lx, flags: 0x%04x\n",