Add tevent_req_notify_callback
[ira/wip.git] / lib / tevent / tevent.h
1 /* 
2    Unix SMB/CIFS implementation.
3
4    generalised event loop handling
5
6    Copyright (C) Andrew Tridgell 2005
7    Copyright (C) Stefan Metzmacher 2005-2009
8    Copyright (C) Volker Lendecke 2008
9
10      ** NOTE! The following LGPL license applies to the tevent
11      ** library. This does NOT imply that all of Samba is released
12      ** under the LGPL
13
14    This library is free software; you can redistribute it and/or
15    modify it under the terms of the GNU Lesser General Public
16    License as published by the Free Software Foundation; either
17    version 3 of the License, or (at your option) any later version.
18
19    This library is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
22    Lesser General Public License for more details.
23
24    You should have received a copy of the GNU Lesser General Public
25    License along with this library; if not, see <http://www.gnu.org/licenses/>.
26 */
27
28 #ifndef __TEVENT_H__
29 #define __TEVENT_H__
30
31 #include <stdint.h>
32 #include <talloc.h>
33 #include <sys/time.h>
34 #include <stdbool.h>
35
36 struct tevent_context;
37 struct tevent_ops;
38 struct tevent_fd;
39 struct tevent_timer;
40 struct tevent_immediate;
41 struct tevent_signal;
42
43 /* event handler types */
44 typedef void (*tevent_fd_handler_t)(struct tevent_context *ev,
45                                     struct tevent_fd *fde,
46                                     uint16_t flags,
47                                     void *private_data);
48 typedef void (*tevent_fd_close_fn_t)(struct tevent_context *ev,
49                                      struct tevent_fd *fde,
50                                      int fd,
51                                      void *private_data);
52 typedef void (*tevent_timer_handler_t)(struct tevent_context *ev,
53                                        struct tevent_timer *te,
54                                        struct timeval current_time,
55                                        void *private_data);
56 typedef void (*tevent_immediate_handler_t)(struct tevent_context *ctx,
57                                            struct tevent_immediate *im,
58                                            void *private_data);
59 typedef void (*tevent_signal_handler_t)(struct tevent_context *ev,
60                                         struct tevent_signal *se,
61                                         int signum,
62                                         int count,
63                                         void *siginfo,
64                                         void *private_data);
65
66 struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx);
67 struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx, const char *name);
68 const char **tevent_backend_list(TALLOC_CTX *mem_ctx);
69 void tevent_set_default_backend(const char *backend);
70
71 struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
72                                  TALLOC_CTX *mem_ctx,
73                                  int fd,
74                                  uint16_t flags,
75                                  tevent_fd_handler_t handler,
76                                  void *private_data,
77                                  const char *handler_name,
78                                  const char *location);
79 #define tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data) \
80         _tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data, \
81                        #handler, __location__)
82
83 struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
84                                        TALLOC_CTX *mem_ctx,
85                                        struct timeval next_event,
86                                        tevent_timer_handler_t handler,
87                                        void *private_data,
88                                        const char *handler_name,
89                                        const char *location);
90 #define tevent_add_timer(ev, mem_ctx, next_event, handler, private_data) \
91         _tevent_add_timer(ev, mem_ctx, next_event, handler, private_data, \
92                           #handler, __location__)
93
94 struct tevent_immediate *_tevent_create_immediate(TALLOC_CTX *mem_ctx,
95                                                   const char *location);
96 #define tevent_create_immediate(mem_ctx) \
97         _tevent_create_immediate(mem_ctx, __location__)
98
99 void _tevent_schedule_immediate(struct tevent_immediate *im,
100                                 struct tevent_context *ctx,
101                                 tevent_immediate_handler_t handler,
102                                 void *private_data,
103                                 const char *handler_name,
104                                 const char *location);
105 #define tevent_schedule_immediate(im, ctx, handler, private_data) \
106         _tevent_schedule_immediate(im, ctx, handler, private_data, \
107                                    #handler, __location__);
108
109 struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
110                                          TALLOC_CTX *mem_ctx,
111                                          int signum,
112                                          int sa_flags,
113                                          tevent_signal_handler_t handler,
114                                          void *private_data,
115                                          const char *handler_name,
116                                          const char *location);
117 #define tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data) \
118         _tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data, \
119                            #handler, __location__)
120
121 int _tevent_loop_once(struct tevent_context *ev, const char *location);
122 #define tevent_loop_once(ev) \
123         _tevent_loop_once(ev, __location__) \
124
125 int _tevent_loop_wait(struct tevent_context *ev, const char *location);
126 #define tevent_loop_wait(ev) \
127         _tevent_loop_wait(ev, __location__) \
128
129 void tevent_fd_set_close_fn(struct tevent_fd *fde,
130                             tevent_fd_close_fn_t close_fn);
131 void tevent_fd_set_auto_close(struct tevent_fd *fde);
132 uint16_t tevent_fd_get_flags(struct tevent_fd *fde);
133 void tevent_fd_set_flags(struct tevent_fd *fde, uint16_t flags);
134
135 bool tevent_signal_support(struct tevent_context *ev);
136
137 void tevent_set_abort_fn(void (*abort_fn)(const char *reason));
138
139 /* bits for file descriptor event flags */
140 #define TEVENT_FD_READ 1
141 #define TEVENT_FD_WRITE 2
142
143 #define TEVENT_FD_WRITEABLE(fde) \
144         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) | TEVENT_FD_WRITE)
145 #define TEVENT_FD_READABLE(fde) \
146         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) | TEVENT_FD_READ)
147
148 #define TEVENT_FD_NOT_WRITEABLE(fde) \
149         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_WRITE)
150 #define TEVENT_FD_NOT_READABLE(fde) \
151         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_READ)
152
153 /* DEBUG */
154 enum tevent_debug_level {
155         TEVENT_DEBUG_FATAL,
156         TEVENT_DEBUG_ERROR,
157         TEVENT_DEBUG_WARNING,
158         TEVENT_DEBUG_TRACE
159 };
160
161 int tevent_set_debug(struct tevent_context *ev,
162                      void (*debug)(void *context,
163                                    enum tevent_debug_level level,
164                                    const char *fmt,
165                                    va_list ap) PRINTF_ATTRIBUTE(3,0),
166                      void *context);
167 int tevent_set_debug_stderr(struct tevent_context *ev);
168
169 /**
170  * An async request moves between the following 4 states:
171  */
172 enum tevent_req_state {
173         /**
174          * we are creating the request
175          */
176         TEVENT_REQ_INIT,
177         /**
178          * we are waiting the request to complete
179          */
180         TEVENT_REQ_IN_PROGRESS,
181         /**
182          * the request is finished
183          */
184         TEVENT_REQ_DONE,
185         /**
186          * A user error has occured
187          */
188         TEVENT_REQ_USER_ERROR,
189         /**
190          * Request timed out
191          */
192         TEVENT_REQ_TIMED_OUT,
193         /**
194          * No memory in between
195          */
196         TEVENT_REQ_NO_MEMORY,
197         /**
198          * the request is already received by the caller
199          */
200         TEVENT_REQ_RECEIVED
201 };
202
203 /**
204  * @brief An async request
205  *
206  * This represents an async request being processed by callbacks via an event
207  * context. A user can issue for example a write request to a socket, giving
208  * an implementation function the fd, the buffer and the number of bytes to
209  * transfer. The function issuing the request will immediately return without
210  * blocking most likely without having sent anything. The API user then fills
211  * in req->async.fn and req->async.private_data, functions that are called
212  * when the request is finished.
213  *
214  * It is up to the user of the async request to talloc_free it after it has
215  * finished. This can happen while the completion function is called.
216  */
217
218 struct tevent_req;
219
220 typedef void (*tevent_req_fn)(struct tevent_req *);
221
222 void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt);
223 void *_tevent_req_callback_data(struct tevent_req *req);
224 void *_tevent_req_data(struct tevent_req *req);
225
226 #define tevent_req_callback_data(_req, _type) \
227         talloc_get_type_abort(_tevent_req_callback_data(_req), _type)
228 #define tevent_req_callback_data_void(_req) \
229         _tevent_req_callback_data(_req)
230 #define tevent_req_data(_req, _type) \
231         talloc_get_type_abort(_tevent_req_data(_req), _type)
232
233 typedef char *(*tevent_req_print_fn)(struct tevent_req *, TALLOC_CTX *);
234
235 void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn);
236
237 char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx);
238
239 char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req);
240
241 struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
242                                       void *pstate,
243                                       size_t state_size,
244                                       const char *type,
245                                       const char *location);
246
247 #define tevent_req_create(_mem_ctx, _pstate, _type) \
248         _tevent_req_create((_mem_ctx), (_pstate), sizeof(_type), \
249                            #_type, __location__)
250
251 bool tevent_req_set_endtime(struct tevent_req *req,
252                             struct tevent_context *ev,
253                             struct timeval endtime);
254
255 void _tevent_req_notify_callback(struct tevent_req *req, const char *location);
256 #define tevent_req_notify_callback(req)         \
257         _tevent_req_notify_callback(req, __location__)
258
259 void _tevent_req_done(struct tevent_req *req,
260                       const char *location);
261 #define tevent_req_done(req) \
262         _tevent_req_done(req, __location__)
263
264 bool _tevent_req_error(struct tevent_req *req,
265                        uint64_t error,
266                        const char *location);
267 #define tevent_req_error(req, error) \
268         _tevent_req_error(req, error, __location__)
269
270 bool _tevent_req_nomem(const void *p,
271                        struct tevent_req *req,
272                        const char *location);
273 #define tevent_req_nomem(p, req) \
274         _tevent_req_nomem(p, req, __location__)
275
276 struct tevent_req *tevent_req_post(struct tevent_req *req,
277                                    struct tevent_context *ev);
278
279 bool tevent_req_is_in_progress(struct tevent_req *req);
280
281 bool tevent_req_poll(struct tevent_req *req,
282                      struct tevent_context *ev);
283
284 bool tevent_req_is_error(struct tevent_req *req,
285                          enum tevent_req_state *state,
286                          uint64_t *error);
287
288 void tevent_req_received(struct tevent_req *req);
289
290 struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
291                                       struct tevent_context *ev,
292                                       struct timeval wakeup_time);
293 bool tevent_wakeup_recv(struct tevent_req *req);
294
295 int tevent_timeval_compare(const struct timeval *tv1,
296                            const struct timeval *tv2);
297
298 struct timeval tevent_timeval_zero(void);
299
300 struct timeval tevent_timeval_current(void);
301
302 struct timeval tevent_timeval_set(uint32_t secs, uint32_t usecs);
303
304 struct timeval tevent_timeval_until(const struct timeval *tv1,
305                                     const struct timeval *tv2);
306
307 bool tevent_timeval_is_zero(const struct timeval *tv);
308
309 struct timeval tevent_timeval_add(const struct timeval *tv, uint32_t secs,
310                                   uint32_t usecs);
311
312 struct timeval tevent_timeval_current_ofs(uint32_t secs, uint32_t usecs);
313
314 struct tevent_queue;
315
316 struct tevent_queue *_tevent_queue_create(TALLOC_CTX *mem_ctx,
317                                           const char *name,
318                                           const char *location);
319
320 #define tevent_queue_create(_mem_ctx, _name) \
321         _tevent_queue_create((_mem_ctx), (_name), __location__)
322
323 typedef void (*tevent_queue_trigger_fn_t)(struct tevent_req *req,
324                                           void *private_data);
325 bool tevent_queue_add(struct tevent_queue *queue,
326                       struct tevent_context *ev,
327                       struct tevent_req *req,
328                       tevent_queue_trigger_fn_t trigger,
329                       void *private_data);
330 void tevent_queue_start(struct tevent_queue *queue);
331 void tevent_queue_stop(struct tevent_queue *queue);
332
333 size_t tevent_queue_length(struct tevent_queue *queue);
334
335 typedef int (*tevent_nesting_hook)(struct tevent_context *ev,
336                                    void *private_data,
337                                    uint32_t level,
338                                    bool begin,
339                                    void *stack_ptr,
340                                    const char *location);
341 #ifdef TEVENT_DEPRECATED
342 #ifndef _DEPRECATED_
343 #if (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 1 )
344 #define _DEPRECATED_ __attribute__ ((deprecated))
345 #else
346 #define _DEPRECATED_
347 #endif
348 #endif
349 void tevent_loop_allow_nesting(struct tevent_context *ev) _DEPRECATED_;
350 void tevent_loop_set_nesting_hook(struct tevent_context *ev,
351                                   tevent_nesting_hook hook,
352                                   void *private_data) _DEPRECATED_;
353 int _tevent_loop_until(struct tevent_context *ev,
354                        bool (*finished)(void *private_data),
355                        void *private_data,
356                        const char *location) _DEPRECATED_;
357 #define tevent_loop_until(ev, finished, private_data) \
358         _tevent_loop_until(ev, finished, private_data, __location__)
359 #endif
360
361 #ifdef TEVENT_COMPAT_DEFINES
362
363 #define event_context   tevent_context
364 #define event_ops       tevent_ops
365 #define fd_event        tevent_fd
366 #define timed_event     tevent_timer
367 #define signal_event    tevent_signal
368
369 #define event_fd_handler_t      tevent_fd_handler_t
370 #define event_timed_handler_t   tevent_timer_handler_t
371 #define event_signal_handler_t  tevent_signal_handler_t
372
373 #define event_context_init(mem_ctx) \
374         tevent_context_init(mem_ctx)
375
376 #define event_context_init_byname(mem_ctx, name) \
377         tevent_context_init_byname(mem_ctx, name)
378
379 #define event_backend_list(mem_ctx) \
380         tevent_backend_list(mem_ctx)
381
382 #define event_set_default_backend(backend) \
383         tevent_set_default_backend(backend)
384
385 #define event_add_fd(ev, mem_ctx, fd, flags, handler, private_data) \
386         tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data)
387
388 #define event_add_timed(ev, mem_ctx, next_event, handler, private_data) \
389         tevent_add_timer(ev, mem_ctx, next_event, handler, private_data)
390
391 #define event_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data) \
392         tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data)
393
394 #define event_loop_once(ev) \
395         tevent_loop_once(ev)
396
397 #define event_loop_wait(ev) \
398         tevent_loop_wait(ev)
399
400 #define event_get_fd_flags(fde) \
401         tevent_fd_get_flags(fde)
402
403 #define event_set_fd_flags(fde, flags) \
404         tevent_fd_set_flags(fde, flags)
405
406 #define EVENT_FD_READ           TEVENT_FD_READ
407 #define EVENT_FD_WRITE          TEVENT_FD_WRITE
408
409 #define EVENT_FD_WRITEABLE(fde) \
410         TEVENT_FD_WRITEABLE(fde)
411
412 #define EVENT_FD_READABLE(fde) \
413         TEVENT_FD_READABLE(fde)
414
415 #define EVENT_FD_NOT_WRITEABLE(fde) \
416         TEVENT_FD_NOT_WRITEABLE(fde)
417
418 #define EVENT_FD_NOT_READABLE(fde) \
419         TEVENT_FD_NOT_READABLE(fde)
420
421 #define ev_debug_level          tevent_debug_level
422
423 #define EV_DEBUG_FATAL          TEVENT_DEBUG_FATAL
424 #define EV_DEBUG_ERROR          TEVENT_DEBUG_ERROR
425 #define EV_DEBUG_WARNING        TEVENT_DEBUG_WARNING
426 #define EV_DEBUG_TRACE          TEVENT_DEBUG_TRACE
427
428 #define ev_set_debug(ev, debug, context) \
429         tevent_set_debug(ev, debug, context)
430
431 #define ev_set_debug_stderr(_ev) tevent_set_debug_stderr(ev)
432
433 #endif /* TEVENT_COMPAT_DEFINES */
434
435 #endif /* __TEVENT_H__ */