56d0da39276ee3489b59b8d81ab495d601266903
[ira/wip.git] / lib / tevent / tevent.c
1 /* 
2    Unix SMB/CIFS implementation.
3    main select loop and event handling
4    Copyright (C) Andrew Tridgell 2003
5    Copyright (C) Stefan Metzmacher 2009
6
7      ** NOTE! The following LGPL license applies to the tevent
8      ** library. This does NOT imply that all of Samba is released
9      ** under the LGPL
10
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 3 of the License, or (at your option) any later version.
15
16    This library is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 /*
26   PLEASE READ THIS BEFORE MODIFYING!
27
28   This module is a general abstraction for the main select loop and
29   event handling. Do not ever put any localised hacks in here, instead
30   register one of the possible event types and implement that event
31   somewhere else.
32
33   There are 2 types of event handling that are handled in this module:
34
35   1) a file descriptor becoming readable or writeable. This is mostly
36      used for network sockets, but can be used for any type of file
37      descriptor. You may only register one handler for each file
38      descriptor/io combination or you will get unpredictable results
39      (this means that you can have a handler for read events, and a
40      separate handler for write events, but not two handlers that are
41      both handling read events)
42
43   2) a timed event. You can register an event that happens at a
44      specific time.  You can register as many of these as you
45      like. They are single shot - add a new timed event in the event
46      handler to get another event.
47
48   To setup a set of events you first need to create a event_context
49   structure using the function tevent_context_init(); This returns a
50   'struct tevent_context' that you use in all subsequent calls.
51
52   After that you can add/remove events that you are interested in
53   using tevent_add_*() and talloc_free()
54
55   Finally, you call tevent_loop_wait_once() to block waiting for one of the
56   events to occor or tevent_loop_wait() which will loop
57   forever.
58
59 */
60 #include "replace.h"
61 #include "system/filesys.h"
62 #define TEVENT_DEPRECATED 1
63 #include "tevent.h"
64 #include "tevent_internal.h"
65 #include "tevent_util.h"
66
67 struct tevent_ops_list {
68         struct tevent_ops_list *next, *prev;
69         const char *name;
70         const struct tevent_ops *ops;
71 };
72
73 /* list of registered event backends */
74 static struct tevent_ops_list *tevent_backends = NULL;
75 static char *tevent_default_backend = NULL;
76
77 /*
78   register an events backend
79 */
80 bool tevent_register_backend(const char *name, const struct tevent_ops *ops)
81 {
82         struct tevent_ops_list *e;
83
84         for (e = tevent_backends; e != NULL; e = e->next) {
85                 if (0 == strcmp(e->name, name)) {
86                         /* already registered, skip it */
87                         return true;
88                 }
89         }
90
91         e = talloc(talloc_autofree_context(), struct tevent_ops_list);
92         if (e == NULL) return false;
93
94         e->name = name;
95         e->ops = ops;
96         DLIST_ADD(tevent_backends, e);
97
98         return true;
99 }
100
101 /*
102   set the default event backend
103  */
104 void tevent_set_default_backend(const char *backend)
105 {
106         talloc_free(tevent_default_backend);
107         tevent_default_backend = talloc_strdup(talloc_autofree_context(),
108                                                backend);
109 }
110
111 /*
112   initialise backends if not already done
113 */
114 static void tevent_backend_init(void)
115 {
116         tevent_select_init();
117         tevent_standard_init();
118 #ifdef HAVE_EPOLL
119         tevent_epoll_init();
120 #endif
121 }
122
123 /*
124   list available backends
125 */
126 const char **tevent_backend_list(TALLOC_CTX *mem_ctx)
127 {
128         const char **list = NULL;
129         struct tevent_ops_list *e;
130
131         tevent_backend_init();
132
133         for (e=tevent_backends;e;e=e->next) {
134                 list = ev_str_list_add(list, e->name);
135         }
136
137         talloc_steal(mem_ctx, list);
138
139         return list;
140 }
141
142 int tevent_common_context_destructor(struct tevent_context *ev)
143 {
144         struct tevent_fd *fd, *fn;
145         struct tevent_timer *te, *tn;
146         struct tevent_immediate *ie, *in;
147         struct tevent_signal *se, *sn;
148
149         if (ev->pipe_fde) {
150                 talloc_free(ev->pipe_fde);
151                 close(ev->pipe_fds[0]);
152                 close(ev->pipe_fds[1]);
153                 ev->pipe_fde = NULL;
154         }
155
156         for (fd = ev->fd_events; fd; fd = fn) {
157                 fn = fd->next;
158                 fd->event_ctx = NULL;
159                 DLIST_REMOVE(ev->fd_events, fd);
160         }
161
162         for (te = ev->timer_events; te; te = tn) {
163                 tn = te->next;
164                 te->event_ctx = NULL;
165                 DLIST_REMOVE(ev->timer_events, te);
166         }
167
168         for (ie = ev->immediate_events; ie; ie = in) {
169                 in = ie->next;
170                 ie->event_ctx = NULL;
171                 ie->cancel_fn = NULL;
172                 DLIST_REMOVE(ev->immediate_events, ie);
173         }
174
175         for (se = ev->signal_events; se; se = sn) {
176                 sn = se->next;
177                 se->event_ctx = NULL;
178                 DLIST_REMOVE(ev->signal_events, se);
179         }
180
181         return 0;
182 }
183
184 /*
185   create a event_context structure for a specific implemementation.
186   This must be the first events call, and all subsequent calls pass
187   this event_context as the first element. Event handlers also
188   receive this as their first argument.
189
190   This function is for allowing third-party-applications to hook in gluecode
191   to their own event loop code, so that they can make async usage of our client libs
192
193   NOTE: use tevent_context_init() inside of samba!
194 */
195 static struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
196                                                       const struct tevent_ops *ops)
197 {
198         struct tevent_context *ev;
199         int ret;
200
201         ev = talloc_zero(mem_ctx, struct tevent_context);
202         if (!ev) return NULL;
203
204         talloc_set_destructor(ev, tevent_common_context_destructor);
205
206         ev->ops = ops;
207
208         ret = ev->ops->context_init(ev);
209         if (ret != 0) {
210                 talloc_free(ev);
211                 return NULL;
212         }
213
214         return ev;
215 }
216
217 /*
218   create a event_context structure. This must be the first events
219   call, and all subsequent calls pass this event_context as the first
220   element. Event handlers also receive this as their first argument.
221 */
222 struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx,
223                                                   const char *name)
224 {
225         struct tevent_ops_list *e;
226
227         tevent_backend_init();
228
229         if (name == NULL) {
230                 name = tevent_default_backend;
231         }
232         if (name == NULL) {
233                 name = "standard";
234         }
235
236         for (e=tevent_backends;e;e=e->next) {
237                 if (strcmp(name, e->name) == 0) {
238                         return tevent_context_init_ops(mem_ctx, e->ops);
239                 }
240         }
241         return NULL;
242 }
243
244
245 /*
246   create a event_context structure. This must be the first events
247   call, and all subsequent calls pass this event_context as the first
248   element. Event handlers also receive this as their first argument.
249 */
250 struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx)
251 {
252         return tevent_context_init_byname(mem_ctx, NULL);
253 }
254
255 /*
256   add a fd based event
257   return NULL on failure (memory allocation error)
258
259   if flags contains TEVENT_FD_AUTOCLOSE then the fd will be closed when
260   the returned fd_event context is freed
261 */
262 struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
263                                  TALLOC_CTX *mem_ctx,
264                                  int fd,
265                                  uint16_t flags,
266                                  tevent_fd_handler_t handler,
267                                  void *private_data,
268                                  const char *handler_name,
269                                  const char *location)
270 {
271         return ev->ops->add_fd(ev, mem_ctx, fd, flags, handler, private_data,
272                                handler_name, location);
273 }
274
275 /*
276   set a close function on the fd event
277 */
278 void tevent_fd_set_close_fn(struct tevent_fd *fde,
279                             tevent_fd_close_fn_t close_fn)
280 {
281         if (!fde) return;
282         if (!fde->event_ctx) return;
283         fde->event_ctx->ops->set_fd_close_fn(fde, close_fn);
284 }
285
286 static void tevent_fd_auto_close_fn(struct tevent_context *ev,
287                                     struct tevent_fd *fde,
288                                     int fd,
289                                     void *private_data)
290 {
291         close(fd);
292 }
293
294 void tevent_fd_set_auto_close(struct tevent_fd *fde)
295 {
296         tevent_fd_set_close_fn(fde, tevent_fd_auto_close_fn);
297 }
298
299 /*
300   return the fd event flags
301 */
302 uint16_t tevent_fd_get_flags(struct tevent_fd *fde)
303 {
304         if (!fde) return 0;
305         if (!fde->event_ctx) return 0;
306         return fde->event_ctx->ops->get_fd_flags(fde);
307 }
308
309 /*
310   set the fd event flags
311 */
312 void tevent_fd_set_flags(struct tevent_fd *fde, uint16_t flags)
313 {
314         if (!fde) return;
315         if (!fde->event_ctx) return;
316         fde->event_ctx->ops->set_fd_flags(fde, flags);
317 }
318
319 bool tevent_signal_support(struct tevent_context *ev)
320 {
321         if (ev->ops->add_signal) {
322                 return true;
323         }
324         return false;
325 }
326
327 static void (*tevent_abort_fn)(const char *reason);
328
329 void tevent_set_abort_fn(void (*abort_fn)(const char *reason))
330 {
331         tevent_abort_fn = abort_fn;
332 }
333
334 static void tevent_abort(struct tevent_context *ev, const char *reason)
335 {
336         tevent_debug(ev, TEVENT_DEBUG_FATAL,
337                      "abort: %s\n", reason);
338
339         if (!tevent_abort_fn) {
340                 abort();
341         }
342
343         tevent_abort_fn(reason);
344 }
345
346 /*
347   add a timer event
348   return NULL on failure
349 */
350 struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
351                                        TALLOC_CTX *mem_ctx,
352                                        struct timeval next_event,
353                                        tevent_timer_handler_t handler,
354                                        void *private_data,
355                                        const char *handler_name,
356                                        const char *location)
357 {
358         return ev->ops->add_timer(ev, mem_ctx, next_event, handler, private_data,
359                                   handler_name, location);
360 }
361
362 /*
363   allocate an immediate event
364   return NULL on failure (memory allocation error)
365 */
366 struct tevent_immediate *_tevent_create_immediate(TALLOC_CTX *mem_ctx,
367                                                   const char *location)
368 {
369         struct tevent_immediate *im;
370
371         im = talloc(mem_ctx, struct tevent_immediate);
372         if (im == NULL) return NULL;
373
374         im->prev                = NULL;
375         im->next                = NULL;
376         im->event_ctx           = NULL;
377         im->create_location     = location;
378         im->handler             = NULL;
379         im->private_data        = NULL;
380         im->handler_name        = NULL;
381         im->schedule_location   = NULL;
382         im->cancel_fn           = NULL;
383         im->additional_data     = NULL;
384
385         return im;
386 }
387
388 /*
389   schedule an immediate event
390   return NULL on failure
391 */
392 void _tevent_schedule_immediate(struct tevent_immediate *im,
393                                 struct tevent_context *ev,
394                                 tevent_immediate_handler_t handler,
395                                 void *private_data,
396                                 const char *handler_name,
397                                 const char *location)
398 {
399         ev->ops->schedule_immediate(im, ev, handler, private_data,
400                                     handler_name, location);
401 }
402
403 /*
404   add a signal event
405
406   sa_flags are flags to sigaction(2)
407
408   return NULL on failure
409 */
410 struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
411                                          TALLOC_CTX *mem_ctx,
412                                          int signum,
413                                          int sa_flags,
414                                          tevent_signal_handler_t handler,
415                                          void *private_data,
416                                          const char *handler_name,
417                                          const char *location)
418 {
419         return ev->ops->add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data,
420                                    handler_name, location);
421 }
422
423 void tevent_loop_allow_nesting(struct tevent_context *ev)
424 {
425         ev->nesting.allowed = true;
426 }
427
428 void tevent_loop_set_nesting_hook(struct tevent_context *ev,
429                                   tevent_nesting_hook hook,
430                                   void *private_data)
431 {
432         if (ev->nesting.hook_fn && 
433             (ev->nesting.hook_fn != hook ||
434              ev->nesting.hook_private != private_data)) {
435                 /* the way the nesting hook code is currently written
436                    we cannot support two different nesting hooks at the
437                    same time. */
438                 tevent_abort(ev, "tevent: Violation of nesting hook rules\n");
439         }
440         ev->nesting.hook_fn = hook;
441         ev->nesting.hook_private = private_data;
442 }
443
444 static void tevent_abort_nesting(struct tevent_context *ev, const char *location)
445 {
446         const char *reason;
447
448         reason = talloc_asprintf(NULL, "tevent_loop_once() nesting at %s",
449                                  location);
450         if (!reason) {
451                 reason = "tevent_loop_once() nesting";
452         }
453
454         tevent_abort(ev, reason);
455 }
456
457 /*
458   do a single event loop using the events defined in ev 
459 */
460 int _tevent_loop_once(struct tevent_context *ev, const char *location)
461 {
462         int ret;
463         void *nesting_stack_ptr = NULL;
464
465         ev->nesting.level++;
466
467         if (ev->nesting.level > 1) {
468                 if (!ev->nesting.allowed) {
469                         tevent_abort_nesting(ev, location);
470                         errno = ELOOP;
471                         return -1;
472                 }
473         }
474         if (ev->nesting.level > 0) {
475                 if (ev->nesting.hook_fn) {
476                         int ret2;
477                         ret2 = ev->nesting.hook_fn(ev,
478                                                    ev->nesting.hook_private,
479                                                    ev->nesting.level,
480                                                    true,
481                                                    (void *)&nesting_stack_ptr,
482                                                    location);
483                         if (ret2 != 0) {
484                                 ret = ret2;
485                                 goto done;
486                         }
487                 }
488         }
489
490         ret = ev->ops->loop_once(ev, location);
491
492         if (ev->nesting.level > 0) {
493                 if (ev->nesting.hook_fn) {
494                         int ret2;
495                         ret2 = ev->nesting.hook_fn(ev,
496                                                    ev->nesting.hook_private,
497                                                    ev->nesting.level,
498                                                    false,
499                                                    (void *)&nesting_stack_ptr,
500                                                    location);
501                         if (ret2 != 0) {
502                                 ret = ret2;
503                                 goto done;
504                         }
505                 }
506         }
507
508 done:
509         ev->nesting.level--;
510         return ret;
511 }
512
513 /*
514   this is a performance optimization for the samba4 nested event loop problems
515 */
516 int _tevent_loop_until(struct tevent_context *ev,
517                        bool (*finished)(void *private_data),
518                        void *private_data,
519                        const char *location)
520 {
521         int ret = 0;
522         void *nesting_stack_ptr = NULL;
523
524         ev->nesting.level++;
525
526         if (ev->nesting.level > 1) {
527                 if (!ev->nesting.allowed) {
528                         tevent_abort_nesting(ev, location);
529                         errno = ELOOP;
530                         return -1;
531                 }
532         }
533         if (ev->nesting.level > 0) {
534                 if (ev->nesting.hook_fn) {
535                         int ret2;
536                         ret2 = ev->nesting.hook_fn(ev,
537                                                    ev->nesting.hook_private,
538                                                    ev->nesting.level,
539                                                    true,
540                                                    (void *)&nesting_stack_ptr,
541                                                    location);
542                         if (ret2 != 0) {
543                                 ret = ret2;
544                                 goto done;
545                         }
546                 }
547         }
548
549         while (!finished(private_data)) {
550                 ret = ev->ops->loop_once(ev, location);
551                 if (ret != 0) {
552                         break;
553                 }
554         }
555
556         if (ev->nesting.level > 0) {
557                 if (ev->nesting.hook_fn) {
558                         int ret2;
559                         ret2 = ev->nesting.hook_fn(ev,
560                                                    ev->nesting.hook_private,
561                                                    ev->nesting.level,
562                                                    false,
563                                                    (void *)&nesting_stack_ptr,
564                                                    location);
565                         if (ret2 != 0) {
566                                 ret = ret2;
567                                 goto done;
568                         }
569                 }
570         }
571
572 done:
573         ev->nesting.level--;
574         return ret;
575 }
576
577 /*
578   return on failure or (with 0) if all fd events are removed
579 */
580 int tevent_common_loop_wait(struct tevent_context *ev,
581                             const char *location)
582 {
583         /*
584          * loop as long as we have events pending
585          */
586         while (ev->fd_events ||
587                ev->timer_events ||
588                ev->immediate_events ||
589                ev->signal_events) {
590                 int ret;
591                 ret = _tevent_loop_once(ev, location);
592                 if (ret != 0) {
593                         tevent_debug(ev, TEVENT_DEBUG_FATAL,
594                                      "_tevent_loop_once() failed: %d - %s\n",
595                                      ret, strerror(errno));
596                         return ret;
597                 }
598         }
599
600         tevent_debug(ev, TEVENT_DEBUG_WARNING,
601                      "tevent_common_loop_wait() out of events\n");
602         return 0;
603 }
604
605 /*
606   return on failure or (with 0) if all fd events are removed
607 */
608 int _tevent_loop_wait(struct tevent_context *ev, const char *location)
609 {
610         return ev->ops->loop_wait(ev, location);
611 }