All calls to event_add_to_select_args() call GetTimeOfDay() and
[samba.git] / source3 / lib / events.c
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 #include "../lib/util/select.h"
24
25 /*
26  * Return if there's something in the queue
27  */
28
29 bool event_add_to_select_args(struct tevent_context *ev,
30                               fd_set *read_fds, fd_set *write_fds,
31                               struct timeval *timeout, int *maxfd)
32 {
33         struct timeval now;
34         struct tevent_fd *fde;
35         struct timeval diff;
36         bool ret = false;
37
38         for (fde = ev->fd_events; fde; fde = fde->next) {
39                 if (fde->flags & EVENT_FD_READ) {
40                         FD_SET(fde->fd, read_fds);
41                         ret = true;
42                 }
43                 if (fde->flags & EVENT_FD_WRITE) {
44                         FD_SET(fde->fd, write_fds);
45                         ret = true;
46                 }
47
48                 if ((fde->flags & (EVENT_FD_READ|EVENT_FD_WRITE))
49                     && (fde->fd > *maxfd)) {
50                         *maxfd = fde->fd;
51                 }
52         }
53
54         if (ev->immediate_events != NULL) {
55                 *timeout = timeval_zero();
56                 return true;
57         }
58
59         if (ev->timer_events == NULL) {
60                 return ret;
61         }
62
63         now = timeval_current();
64         diff = timeval_until(&now, &ev->timer_events->next_event);
65         *timeout = timeval_min(timeout, &diff);
66
67         return true;
68 }
69
70 bool run_events(struct tevent_context *ev,
71                 int *selrtn, fd_set *read_fds, fd_set *write_fds)
72 {
73         struct tevent_fd *fde;
74         struct timeval now;
75
76         if (ev->signal_events &&
77             tevent_common_check_signal(ev)) {
78                 return true;
79         }
80
81         if (ev->immediate_events &&
82             tevent_common_loop_immediate(ev)) {
83                 return true;
84         }
85
86         GetTimeOfDay(&now);
87
88         if ((ev->timer_events != NULL)
89             && (timeval_compare(&now, &ev->timer_events->next_event) >= 0)) {
90                 /* this older events system did not auto-free timed
91                    events on running them, and had a race condition
92                    where the event could be called twice if the
93                    talloc_free of the te happened after the callback
94                    made a call which invoked the event loop. To avoid
95                    this while still allowing old code which frees the
96                    te, we need to create a temporary context which
97                    will be used to ensure the te is freed. We also
98                    remove the te from the timed event list before we
99                    call the handler, to ensure we can't loop */
100
101                 struct tevent_timer *te = ev->timer_events;
102                 TALLOC_CTX *tmp_ctx = talloc_new(ev);
103
104                 DEBUG(10, ("Running timed event \"%s\" %p\n",
105                            ev->timer_events->handler_name, ev->timer_events));
106
107                 DLIST_REMOVE(ev->timer_events, te);
108                 talloc_steal(tmp_ctx, te);
109
110                 te->handler(ev, te, now, te->private_data);
111
112                 talloc_free(tmp_ctx);
113                 return true;
114         }
115
116         if (*selrtn <= 0) {
117                 /*
118                  * No fd ready
119                  */
120                 return false;
121         }
122
123         for (fde = ev->fd_events; fde; fde = fde->next) {
124                 uint16 flags = 0;
125
126                 if (FD_ISSET(fde->fd, read_fds)) {
127                         flags |= EVENT_FD_READ;
128                         FD_CLR(fde->fd, read_fds);
129                         (*selrtn)--;
130                 }
131                 if (FD_ISSET(fde->fd, write_fds)) {
132                         flags |= EVENT_FD_WRITE;
133                         FD_CLR(fde->fd, write_fds);
134                         (*selrtn)--;
135                 }
136
137                 if (flags & fde->flags) {
138                         fde->handler(ev, fde, flags, fde->private_data);
139                         return true;
140                 }
141         }
142
143         return false;
144 }
145
146
147 struct timeval *get_timed_events_timeout(struct tevent_context *ev,
148                                          struct timeval *to_ret)
149 {
150         struct timeval now;
151
152         if ((ev->timer_events == NULL) && (ev->immediate_events == NULL)) {
153                 return NULL;
154         }
155         if (ev->immediate_events != NULL) {
156                 *to_ret = timeval_zero();
157                 return to_ret;
158         }
159
160         now = timeval_current();
161         *to_ret = timeval_until(&now, &ev->timer_events->next_event);
162
163         DEBUG(10, ("timed_events_timeout: %d/%d\n", (int)to_ret->tv_sec,
164                 (int)to_ret->tv_usec));
165
166         return to_ret;
167 }
168
169 static int s3_event_loop_once(struct tevent_context *ev, const char *location)
170 {
171         struct timeval to;
172         fd_set r_fds, w_fds;
173         int maxfd = 0;
174         int ret = 0;
175
176         FD_ZERO(&r_fds);
177         FD_ZERO(&w_fds);
178
179         to.tv_sec = 9999;       /* Max timeout */
180         to.tv_usec = 0;
181
182         if (run_events(ev, &ret, NULL, NULL)) {
183                 return 0;
184         }
185
186         if (!event_add_to_select_args(ev, &r_fds, &w_fds, &to, &maxfd)) {
187                 return -1;
188         }
189
190         ret = sys_select(maxfd+1, &r_fds, &w_fds, NULL, &to);
191
192         if (ret == -1 && errno != EINTR) {
193                 tevent_debug(ev, TEVENT_DEBUG_FATAL,
194                              "sys_select() failed: %d:%s\n",
195                              errno, strerror(errno));
196                 return -1;
197         }
198
199         run_events(ev, &ret, &r_fds, &w_fds);
200         return 0;
201 }
202
203 static int s3_event_context_init(struct tevent_context *ev)
204 {
205         return 0;
206 }
207
208 void dump_event_list(struct tevent_context *ev)
209 {
210         struct tevent_timer *te;
211         struct tevent_fd *fe;
212         struct timeval evt, now;
213
214         if (!ev) {
215                 return;
216         }
217
218         now = timeval_current();
219
220         DEBUG(10,("dump_event_list:\n"));
221
222         for (te = ev->timer_events; te; te = te->next) {
223
224                 evt = timeval_until(&now, &te->next_event);
225
226                 DEBUGADD(10,("Timed Event \"%s\" %p handled in %d seconds (at %s)\n",
227                            te->handler_name,
228                            te,
229                            (int)evt.tv_sec,
230                            http_timestring(talloc_tos(), te->next_event.tv_sec)));
231         }
232
233         for (fe = ev->fd_events; fe; fe = fe->next) {
234
235                 DEBUGADD(10,("FD Event %d %p, flags: 0x%04x\n",
236                            fe->fd,
237                            fe,
238                            fe->flags));
239         }
240 }
241
242 static const struct tevent_ops s3_event_ops = {
243         .context_init           = s3_event_context_init,
244         .add_fd                 = tevent_common_add_fd,
245         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
246         .get_fd_flags           = tevent_common_fd_get_flags,
247         .set_fd_flags           = tevent_common_fd_set_flags,
248         .add_timer              = tevent_common_add_timer,
249         .schedule_immediate     = tevent_common_schedule_immediate,
250         .add_signal             = tevent_common_add_signal,
251         .loop_once              = s3_event_loop_once,
252         .loop_wait              = tevent_common_loop_wait,
253 };
254
255 static bool s3_tevent_init(void)
256 {
257         static bool initialized;
258         if (initialized) {
259                 return true;
260         }
261         initialized = tevent_register_backend("s3", &s3_event_ops);
262         tevent_set_default_backend("s3");
263         return initialized;
264 }
265
266 /*
267   this is used to catch debug messages from events
268 */
269 static void s3_event_debug(void *context, enum tevent_debug_level level,
270                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
271
272 static void s3_event_debug(void *context, enum tevent_debug_level level,
273                            const char *fmt, va_list ap)
274 {
275         int samba_level = -1;
276         char *s = NULL;
277         switch (level) {
278         case TEVENT_DEBUG_FATAL:
279                 samba_level = 0;
280                 break;
281         case TEVENT_DEBUG_ERROR:
282                 samba_level = 1;
283                 break;
284         case TEVENT_DEBUG_WARNING:
285                 samba_level = 2;
286                 break;
287         case TEVENT_DEBUG_TRACE:
288                 samba_level = 11;
289                 break;
290
291         };
292         if (vasprintf(&s, fmt, ap) == -1) {
293                 return;
294         }
295         DEBUG(samba_level, ("s3_event: %s", s));
296         free(s);
297 }
298
299 struct tevent_context *s3_tevent_context_init(TALLOC_CTX *mem_ctx)
300 {
301         struct tevent_context *ev;
302
303         s3_tevent_init();
304
305         ev = tevent_context_init_byname(mem_ctx, "s3");
306         if (ev) {
307                 tevent_set_debug(ev, s3_event_debug, NULL);
308         }
309
310         return ev;
311 }
312