s3:lib/events: s/EVENT_FD/TEVENT_FD
[Samba/gebeck_regimport.git] / lib / tevent / tevent_internal.h
blob8433333558366af2c754823ce2df9cdf830ce28f
1 /*
2 Unix SMB/CIFS implementation.
4 generalised event loop handling
6 INTERNAL STRUCTS. THERE ARE NO API GUARANTEES.
7 External users should only ever have to include this header when
8 implementing new tevent backends.
10 Copyright (C) Stefan Metzmacher 2005-2009
12 ** NOTE! The following LGPL license applies to the tevent
13 ** library. This does NOT imply that all of Samba is released
14 ** under the LGPL
16 This library is free software; you can redistribute it and/or
17 modify it under the terms of the GNU Lesser General Public
18 License as published by the Free Software Foundation; either
19 version 3 of the License, or (at your option) any later version.
21 This library is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 Lesser General Public License for more details.
26 You should have received a copy of the GNU Lesser General Public
27 License along with this library; if not, see <http://www.gnu.org/licenses/>.
30 struct tevent_req {
31 /**
32 * @brief What to do on completion
34 * This is used for the user of an async request, fn is called when
35 * the request completes, either successfully or with an error.
37 struct {
38 /**
39 * @brief Completion function
40 * Completion function, to be filled by the API user
42 tevent_req_fn fn;
43 /**
44 * @brief Private data for the completion function
46 void *private_data;
47 } async;
49 /**
50 * @brief Private state pointer for the actual implementation
52 * The implementation doing the work for the async request needs to
53 * keep around current data like for example a fd event. The user of
54 * an async request should not touch this.
56 void *data;
58 /**
59 * @brief A function to overwrite the default print function
61 * The implementation doing the work may want to implement a
62 * custom function to print the text representation of the async
63 * request.
65 tevent_req_print_fn private_print;
67 /**
68 * @brief A function to cancel the request
70 * The implementation might want to set a function
71 * that is called when the tevent_req_cancel() function
72 * was called.
74 tevent_req_cancel_fn private_cancel;
76 /**
77 * @brief Internal state of the request
79 * Callers should only access this via functions and never directly.
81 struct {
82 /**
83 * @brief The talloc type of the data pointer
85 * This is filled by the tevent_req_create() macro.
87 * This for debugging only.
89 const char *private_type;
91 /**
92 * @brief The location where the request was created
94 * This uses the __location__ macro via the tevent_req_create()
95 * macro.
97 * This for debugging only.
99 const char *create_location;
102 * @brief The location where the request was finished
104 * This uses the __location__ macro via the tevent_req_done(),
105 * tevent_req_error() or tevent_req_nomem() macro.
107 * This for debugging only.
109 const char *finish_location;
112 * @brief The location where the request was canceled
114 * This uses the __location__ macro via the
115 * tevent_req_cancel() macro.
117 * This for debugging only.
119 const char *cancel_location;
122 * @brief The external state - will be queried by the caller
124 * While the async request is being processed, state will remain in
125 * TEVENT_REQ_IN_PROGRESS. A request is finished if
126 * req->state>=TEVENT_REQ_DONE.
128 enum tevent_req_state state;
131 * @brief status code when finished
133 * This status can be queried in the async completion function. It
134 * will be set to 0 when everything went fine.
136 uint64_t error;
139 * @brief the immediate event used by tevent_req_post
142 struct tevent_immediate *trigger;
145 * @brief An event context which will be used to
146 * defer the _tevent_req_notify_callback().
148 struct tevent_context *defer_callback_ev;
151 * @brief the timer event if tevent_req_set_endtime was used
154 struct tevent_timer *timer;
155 } internal;
158 struct tevent_fd {
159 struct tevent_fd *prev, *next;
160 struct tevent_context *event_ctx;
161 int fd;
162 uint16_t flags; /* see TEVENT_FD_* flags */
163 tevent_fd_handler_t handler;
164 tevent_fd_close_fn_t close_fn;
165 /* this is private for the specific handler */
166 void *private_data;
167 /* this is for debugging only! */
168 const char *handler_name;
169 const char *location;
170 /* this is private for the events_ops implementation */
171 uint64_t additional_flags;
172 void *additional_data;
175 struct tevent_timer {
176 struct tevent_timer *prev, *next;
177 struct tevent_context *event_ctx;
178 struct timeval next_event;
179 tevent_timer_handler_t handler;
180 /* this is private for the specific handler */
181 void *private_data;
182 /* this is for debugging only! */
183 const char *handler_name;
184 const char *location;
185 /* this is private for the events_ops implementation */
186 void *additional_data;
189 struct tevent_immediate {
190 struct tevent_immediate *prev, *next;
191 struct tevent_context *event_ctx;
192 tevent_immediate_handler_t handler;
193 /* this is private for the specific handler */
194 void *private_data;
195 /* this is for debugging only! */
196 const char *handler_name;
197 const char *create_location;
198 const char *schedule_location;
199 /* this is private for the events_ops implementation */
200 void (*cancel_fn)(struct tevent_immediate *im);
201 void *additional_data;
204 struct tevent_signal {
205 struct tevent_signal *prev, *next;
206 struct tevent_context *event_ctx;
207 int signum;
208 int sa_flags;
209 tevent_signal_handler_t handler;
210 /* this is private for the specific handler */
211 void *private_data;
212 /* this is for debugging only! */
213 const char *handler_name;
214 const char *location;
215 /* this is private for the events_ops implementation */
216 void *additional_data;
219 struct tevent_debug_ops {
220 void (*debug)(void *context, enum tevent_debug_level level,
221 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
222 void *context;
225 void tevent_debug(struct tevent_context *ev, enum tevent_debug_level level,
226 const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
228 struct tevent_context {
229 /* the specific events implementation */
230 const struct tevent_ops *ops;
232 /* list of fd events - used by common code */
233 struct tevent_fd *fd_events;
235 /* list of timed events - used by common code */
236 struct tevent_timer *timer_events;
238 /* list of immediate events - used by common code */
239 struct tevent_immediate *immediate_events;
241 /* list of signal events - used by common code */
242 struct tevent_signal *signal_events;
244 /* this is private for the events_ops implementation */
245 void *additional_data;
247 /* pipe hack used with signal handlers */
248 struct tevent_fd *pipe_fde;
249 int pipe_fds[2];
251 /* debugging operations */
252 struct tevent_debug_ops debug_ops;
254 /* info about the nesting status */
255 struct {
256 bool allowed;
257 uint32_t level;
258 tevent_nesting_hook hook_fn;
259 void *hook_private;
260 } nesting;
262 struct {
263 tevent_trace_callback_t callback;
264 void *private_data;
265 } tracing;
268 const struct tevent_ops *tevent_find_ops_byname(const char *name);
270 int tevent_common_context_destructor(struct tevent_context *ev);
271 int tevent_common_loop_wait(struct tevent_context *ev,
272 const char *location);
274 int tevent_common_fd_destructor(struct tevent_fd *fde);
275 struct tevent_fd *tevent_common_add_fd(struct tevent_context *ev,
276 TALLOC_CTX *mem_ctx,
277 int fd,
278 uint16_t flags,
279 tevent_fd_handler_t handler,
280 void *private_data,
281 const char *handler_name,
282 const char *location);
283 void tevent_common_fd_set_close_fn(struct tevent_fd *fde,
284 tevent_fd_close_fn_t close_fn);
285 uint16_t tevent_common_fd_get_flags(struct tevent_fd *fde);
286 void tevent_common_fd_set_flags(struct tevent_fd *fde, uint16_t flags);
288 struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev,
289 TALLOC_CTX *mem_ctx,
290 struct timeval next_event,
291 tevent_timer_handler_t handler,
292 void *private_data,
293 const char *handler_name,
294 const char *location);
295 struct timeval tevent_common_loop_timer_delay(struct tevent_context *);
297 void tevent_common_schedule_immediate(struct tevent_immediate *im,
298 struct tevent_context *ev,
299 tevent_immediate_handler_t handler,
300 void *private_data,
301 const char *handler_name,
302 const char *location);
303 bool tevent_common_loop_immediate(struct tevent_context *ev);
305 struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
306 TALLOC_CTX *mem_ctx,
307 int signum,
308 int sa_flags,
309 tevent_signal_handler_t handler,
310 void *private_data,
311 const char *handler_name,
312 const char *location);
313 int tevent_common_check_signal(struct tevent_context *ev);
314 void tevent_cleanup_pending_signal_handlers(struct tevent_signal *se);
316 bool tevent_standard_init(void);
317 bool tevent_select_init(void);
318 bool tevent_poll_init(void);
319 void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
320 struct tevent_fd *fde);
321 bool tevent_poll_mt_init(void);
322 #ifdef HAVE_EPOLL
323 bool tevent_epoll_init(void);
324 bool tevent_epoll_set_panic_fallback(struct tevent_context *ev,
325 bool (*panic_fallback)(struct tevent_context *ev,
326 bool replay));
327 #endif
330 void tevent_trace_point_callback(struct tevent_context *ev,
331 enum tevent_trace_point);