source: vendor/current/lib/tevent/tevent_internal.h

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 10.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 generalised event loop handling
5
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.
9
10 Copyright (C) Stefan Metzmacher 2005-2009
11
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
15
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.
20
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.
25
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/>.
28*/
29
30struct tevent_req {
31 /**
32 * @brief What to do on completion
33 *
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.
36 */
37 struct {
38 /**
39 * @brief Completion function
40 * Completion function, to be filled by the API user
41 */
42 tevent_req_fn fn;
43 /**
44 * @brief Private data for the completion function
45 */
46 void *private_data;
47 } async;
48
49 /**
50 * @brief Private state pointer for the actual implementation
51 *
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.
55 */
56 void *data;
57
58 /**
59 * @brief A function to overwrite the default print function
60 *
61 * The implementation doing the work may want to implement a
62 * custom function to print the text representation of the async
63 * request.
64 */
65 tevent_req_print_fn private_print;
66
67 /**
68 * @brief A function to cancel the request
69 *
70 * The implementation might want to set a function
71 * that is called when the tevent_req_cancel() function
72 * was called.
73 */
74 tevent_req_cancel_fn private_cancel;
75
76 /**
77 * @brief A function to cleanup the request
78 *
79 * The implementation might want to set a function
80 * that is called before the tevent_req_done() and tevent_req_error()
81 * trigger the callers callback function.
82 */
83 struct {
84 tevent_req_cleanup_fn fn;
85 enum tevent_req_state state;
86 } private_cleanup;
87
88 /**
89 * @brief Internal state of the request
90 *
91 * Callers should only access this via functions and never directly.
92 */
93 struct {
94 /**
95 * @brief The talloc type of the data pointer
96 *
97 * This is filled by the tevent_req_create() macro.
98 *
99 * This for debugging only.
100 */
101 const char *private_type;
102
103 /**
104 * @brief The location where the request was created
105 *
106 * This uses the __location__ macro via the tevent_req_create()
107 * macro.
108 *
109 * This for debugging only.
110 */
111 const char *create_location;
112
113 /**
114 * @brief The location where the request was finished
115 *
116 * This uses the __location__ macro via the tevent_req_done(),
117 * tevent_req_error() or tevent_req_nomem() macro.
118 *
119 * This for debugging only.
120 */
121 const char *finish_location;
122
123 /**
124 * @brief The location where the request was canceled
125 *
126 * This uses the __location__ macro via the
127 * tevent_req_cancel() macro.
128 *
129 * This for debugging only.
130 */
131 const char *cancel_location;
132
133 /**
134 * @brief The external state - will be queried by the caller
135 *
136 * While the async request is being processed, state will remain in
137 * TEVENT_REQ_IN_PROGRESS. A request is finished if
138 * req->state>=TEVENT_REQ_DONE.
139 */
140 enum tevent_req_state state;
141
142 /**
143 * @brief status code when finished
144 *
145 * This status can be queried in the async completion function. It
146 * will be set to 0 when everything went fine.
147 */
148 uint64_t error;
149
150 /**
151 * @brief the immediate event used by tevent_req_post
152 *
153 */
154 struct tevent_immediate *trigger;
155
156 /**
157 * @brief An event context which will be used to
158 * defer the _tevent_req_notify_callback().
159 */
160 struct tevent_context *defer_callback_ev;
161
162 /**
163 * @brief the timer event if tevent_req_set_endtime was used
164 *
165 */
166 struct tevent_timer *timer;
167 } internal;
168};
169
170struct tevent_fd {
171 struct tevent_fd *prev, *next;
172 struct tevent_context *event_ctx;
173 int fd;
174 uint16_t flags; /* see TEVENT_FD_* flags */
175 tevent_fd_handler_t handler;
176 tevent_fd_close_fn_t close_fn;
177 /* this is private for the specific handler */
178 void *private_data;
179 /* this is for debugging only! */
180 const char *handler_name;
181 const char *location;
182 /* this is private for the events_ops implementation */
183 uint64_t additional_flags;
184 void *additional_data;
185};
186
187struct tevent_timer {
188 struct tevent_timer *prev, *next;
189 struct tevent_context *event_ctx;
190 struct timeval next_event;
191 tevent_timer_handler_t handler;
192 /* this is private for the specific handler */
193 void *private_data;
194 /* this is for debugging only! */
195 const char *handler_name;
196 const char *location;
197 /* this is private for the events_ops implementation */
198 void *additional_data;
199};
200
201struct tevent_immediate {
202 struct tevent_immediate *prev, *next;
203 struct tevent_context *event_ctx;
204 tevent_immediate_handler_t handler;
205 /* this is private for the specific handler */
206 void *private_data;
207 /* this is for debugging only! */
208 const char *handler_name;
209 const char *create_location;
210 const char *schedule_location;
211 /* this is private for the events_ops implementation */
212 void (*cancel_fn)(struct tevent_immediate *im);
213 void *additional_data;
214};
215
216struct tevent_signal {
217 struct tevent_signal *prev, *next;
218 struct tevent_context *event_ctx;
219 int signum;
220 int sa_flags;
221 tevent_signal_handler_t handler;
222 /* this is private for the specific handler */
223 void *private_data;
224 /* this is for debugging only! */
225 const char *handler_name;
226 const char *location;
227 /* this is private for the events_ops implementation */
228 void *additional_data;
229};
230
231struct tevent_debug_ops {
232 void (*debug)(void *context, enum tevent_debug_level level,
233 const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
234 void *context;
235};
236
237void tevent_debug(struct tevent_context *ev, enum tevent_debug_level level,
238 const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
239
240struct tevent_context {
241 /* the specific events implementation */
242 const struct tevent_ops *ops;
243
244 /* list of fd events - used by common code */
245 struct tevent_fd *fd_events;
246
247 /* list of timed events - used by common code */
248 struct tevent_timer *timer_events;
249
250 /* list of immediate events - used by common code */
251 struct tevent_immediate *immediate_events;
252
253 /* list of signal events - used by common code */
254 struct tevent_signal *signal_events;
255
256 /* this is private for the events_ops implementation */
257 void *additional_data;
258
259 /* pipe hack used with signal handlers */
260 struct tevent_fd *pipe_fde;
261 int pipe_fds[2];
262
263 /* debugging operations */
264 struct tevent_debug_ops debug_ops;
265
266 /* info about the nesting status */
267 struct {
268 bool allowed;
269 uint32_t level;
270 tevent_nesting_hook hook_fn;
271 void *hook_private;
272 } nesting;
273
274 struct {
275 tevent_trace_callback_t callback;
276 void *private_data;
277 } tracing;
278
279 /*
280 * an optimization pointer into timer_events
281 * used by used by common code via
282 * tevent_common_add_timer_v2()
283 */
284 struct tevent_timer *last_zero_timer;
285};
286
287const struct tevent_ops *tevent_find_ops_byname(const char *name);
288
289int tevent_common_context_destructor(struct tevent_context *ev);
290int tevent_common_loop_wait(struct tevent_context *ev,
291 const char *location);
292
293int tevent_common_fd_destructor(struct tevent_fd *fde);
294struct tevent_fd *tevent_common_add_fd(struct tevent_context *ev,
295 TALLOC_CTX *mem_ctx,
296 int fd,
297 uint16_t flags,
298 tevent_fd_handler_t handler,
299 void *private_data,
300 const char *handler_name,
301 const char *location);
302void tevent_common_fd_set_close_fn(struct tevent_fd *fde,
303 tevent_fd_close_fn_t close_fn);
304uint16_t tevent_common_fd_get_flags(struct tevent_fd *fde);
305void tevent_common_fd_set_flags(struct tevent_fd *fde, uint16_t flags);
306
307struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev,
308 TALLOC_CTX *mem_ctx,
309 struct timeval next_event,
310 tevent_timer_handler_t handler,
311 void *private_data,
312 const char *handler_name,
313 const char *location);
314struct tevent_timer *tevent_common_add_timer_v2(struct tevent_context *ev,
315 TALLOC_CTX *mem_ctx,
316 struct timeval next_event,
317 tevent_timer_handler_t handler,
318 void *private_data,
319 const char *handler_name,
320 const char *location);
321struct timeval tevent_common_loop_timer_delay(struct tevent_context *);
322
323void tevent_common_schedule_immediate(struct tevent_immediate *im,
324 struct tevent_context *ev,
325 tevent_immediate_handler_t handler,
326 void *private_data,
327 const char *handler_name,
328 const char *location);
329bool tevent_common_loop_immediate(struct tevent_context *ev);
330
331struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
332 TALLOC_CTX *mem_ctx,
333 int signum,
334 int sa_flags,
335 tevent_signal_handler_t handler,
336 void *private_data,
337 const char *handler_name,
338 const char *location);
339int tevent_common_check_signal(struct tevent_context *ev);
340void tevent_cleanup_pending_signal_handlers(struct tevent_signal *se);
341
342bool tevent_standard_init(void);
343bool tevent_select_init(void);
344bool tevent_poll_init(void);
345void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
346 struct tevent_fd *fde);
347bool tevent_poll_mt_init(void);
348#ifdef HAVE_EPOLL
349bool tevent_epoll_init(void);
350void tevent_epoll_set_panic_fallback(struct tevent_context *ev,
351 bool (*panic_fallback)(struct tevent_context *ev,
352 bool replay));
353#endif
354#ifdef HAVE_SOLARIS_PORTS
355bool tevent_port_init(void);
356#endif
357
358
359void tevent_trace_point_callback(struct tevent_context *ev,
360 enum tevent_trace_point);
Note: See TracBrowser for help on using the repository browser.