Commit | Line | Data |
---|---|---|
460b9539 | 1 | /* |
2 | * This file is part of DisOrder. | |
e8c92ba7 | 3 | * Copyright (C) 2004, 2007 Richard Kettlewell |
460b9539 | 4 | * |
e7eb3a27 | 5 | * This program is free software: you can redistribute it and/or modify |
460b9539 | 6 | * it under the terms of the GNU General Public License as published by |
e7eb3a27 | 7 | * the Free Software Foundation, either version 3 of the License, or |
460b9539 | 8 | * (at your option) any later version. |
e7eb3a27 RK |
9 | * |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
460b9539 | 15 | * You should have received a copy of the GNU General Public License |
e7eb3a27 | 16 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
460b9539 | 17 | */ |
18 | ||
19 | #ifndef EVENT_H | |
20 | #define EVENT_H | |
21 | ||
fdca70ee RK |
22 | #include <sys/socket.h> |
23 | ||
460b9539 | 24 | typedef struct ev_source ev_source; |
25 | ||
26 | struct rusage; | |
27 | struct sink; | |
28 | ||
29 | ev_source *ev_new(void); | |
30 | /* create a new event loop */ | |
31 | ||
32 | int ev_run(ev_source *ev); | |
33 | /* run an event loop. If any callback returns nonzero then that value | |
34 | * is returned. If an error occurs then -1 is returned and @error@ is | |
35 | * called. */ | |
36 | ||
37 | /* file descriptors ***********************************************************/ | |
38 | ||
39 | typedef enum { | |
40 | ev_read, | |
41 | ev_write, | |
42 | ev_except, | |
43 | ||
44 | ev_nmodes | |
45 | } ev_fdmode; | |
46 | ||
47 | typedef int ev_fd_callback(ev_source *ev, int fd, void *u); | |
48 | /* signature for fd callback functions */ | |
49 | ||
50 | int ev_fd(ev_source *ev, | |
51 | ev_fdmode mode, | |
52 | int fd, | |
53 | ev_fd_callback *callback, | |
e8c92ba7 RK |
54 | void *u, |
55 | const char *what); | |
460b9539 | 56 | /* register a callback on a file descriptor */ |
57 | ||
58 | int ev_fd_cancel(ev_source *ev, | |
59 | ev_fdmode mode, | |
60 | int fd); | |
61 | /* cancel a callback on a file descriptor */ | |
62 | ||
63 | int ev_fd_disable(ev_source *ev, | |
64 | ev_fdmode mode, | |
65 | int fd); | |
66 | /* temporarily disable callbacks on a file descriptor */ | |
67 | ||
68 | int ev_fd_enable(ev_source *ev, | |
69 | ev_fdmode mode, | |
70 | int fd); | |
71 | /* re-enable callbacks on a file descriptor */ | |
72 | ||
768d7355 RK |
73 | void ev_report(ev_source *ev); |
74 | ||
460b9539 | 75 | /* timeouts *******************************************************************/ |
76 | ||
77 | typedef int ev_timeout_callback(ev_source *ev, | |
78 | const struct timeval *now, | |
79 | void *u); | |
80 | /* signature for timeout callback functions */ | |
81 | ||
82 | typedef void *ev_timeout_handle; | |
83 | ||
84 | int ev_timeout(ev_source *ev, | |
85 | ev_timeout_handle *handlep, | |
86 | const struct timeval *when, | |
87 | ev_timeout_callback *callback, | |
88 | void *u); | |
89 | /* register a timeout callback. If @handlep@ is not a null pointer then a | |
90 | * handle suitable for ev_timeout_cancel() below is returned through it. */ | |
91 | ||
92 | int ev_timeout_cancel(ev_source *ev, | |
93 | ev_timeout_handle handle); | |
94 | /* cancel a timeout callback */ | |
95 | ||
96 | /* signals ********************************************************************/ | |
97 | ||
98 | typedef int ev_signal_callback(ev_source *ev, | |
99 | int sig, | |
100 | void *u); | |
101 | /* signature for signal callback functions */ | |
102 | ||
103 | int ev_signal(ev_source *ev, | |
104 | int sig, | |
105 | ev_signal_callback *callback, | |
106 | void *u); | |
107 | /* register a signal callback */ | |
108 | ||
109 | int ev_signal_cancel(ev_source *ev, | |
110 | int sig); | |
111 | /* cancel a signal callback */ | |
112 | ||
113 | void ev_signal_atfork(ev_source *ev); | |
114 | /* unhandle and unblock handled signals - call after calling fork and | |
115 | * then setting @exitfn@ */ | |
116 | ||
117 | /* child processes ************************************************************/ | |
118 | ||
119 | typedef int ev_child_callback(ev_source *ev, | |
120 | pid_t pid, | |
121 | int status, | |
122 | const struct rusage *rusage, | |
123 | void *u); | |
124 | /* signature for child wait callbacks */ | |
125 | ||
126 | int ev_child_setup(ev_source *ev); | |
127 | /* must be called exactly once before @ev_child@ */ | |
128 | ||
129 | int ev_child(ev_source *ev, | |
130 | pid_t pid, | |
131 | int options, | |
132 | ev_child_callback *callback, | |
133 | void *u); | |
134 | /* register a child callback. @options@ must be 0 or WUNTRACED. */ | |
135 | ||
136 | int ev_child_cancel(ev_source *ev, | |
137 | pid_t pid); | |
138 | /* cancel a child callback. */ | |
139 | ||
140 | /* socket listeners ***********************************************************/ | |
141 | ||
142 | typedef int ev_listen_callback(ev_source *ev, | |
143 | int newfd, | |
144 | const struct sockaddr *remote, | |
145 | socklen_t rlen, | |
146 | void *u); | |
147 | /* callback when a connection arrives. */ | |
148 | ||
149 | int ev_listen(ev_source *ev, | |
150 | int fd, | |
151 | ev_listen_callback *callback, | |
e8c92ba7 RK |
152 | void *u, |
153 | const char *what); | |
460b9539 | 154 | /* register a socket listener callback. @bind@ and @listen@ should |
155 | * already have been called. */ | |
156 | ||
157 | int ev_listen_cancel(ev_source *ev, | |
158 | int fd); | |
159 | /* cancel a socket listener callback */ | |
160 | ||
161 | /* buffered writer ************************************************************/ | |
162 | ||
163 | typedef struct ev_writer ev_writer; | |
164 | ||
75d64210 RK |
165 | /** @brief Error callback for @ref ev_reader and @ref ev_writer |
166 | * @param ev Event loop | |
167 | * @param errno_value Errno value (might be 0) | |
168 | * @param u As passed to ev_writer_new() or ev_reader_new() | |
169 | * @return 0 on success, non-0 on error | |
170 | * | |
171 | * This is called for a writer in the following situations: | |
172 | * - on error, with @p errno_value != 0 | |
173 | * - when all buffered data has been written, with @p errno_value = 0 | |
174 | * - after called ev_writer_cancel(), with @p errno_value = 0 | |
175 | * | |
176 | * It is called for a reader only on error, with @p errno_value != 0. | |
177 | */ | |
460b9539 | 178 | typedef int ev_error_callback(ev_source *ev, |
460b9539 | 179 | int errno_value, |
180 | void *u); | |
460b9539 | 181 | |
182 | ev_writer *ev_writer_new(ev_source *ev, | |
183 | int fd, | |
184 | ev_error_callback *callback, | |
e8c92ba7 RK |
185 | void *u, |
186 | const char *what); | |
460b9539 | 187 | /* create a new buffered writer, writing to @fd@. Calls @error@ if an |
188 | * error occurs. */ | |
189 | ||
cb9a695c RK |
190 | int ev_writer_time_bound(ev_writer *ev, |
191 | int new_time_bound); | |
192 | int ev_writer_space_bound(ev_writer *ev, | |
193 | int new_space_bound); | |
194 | ||
460b9539 | 195 | int ev_writer_close(ev_writer *w); |
196 | /* close a writer (i.e. promise not to write to it any more) */ | |
197 | ||
198 | int ev_writer_cancel(ev_writer *w); | |
199 | /* cancel a writer */ | |
200 | ||
201 | int ev_writer_flush(ev_writer *w); | |
202 | /* attempt to flush the buffer */ | |
203 | ||
204 | struct sink *ev_writer_sink(ev_writer *w) attribute((const)); | |
205 | /* return a sink for the writer - use this to actually write to it */ | |
206 | ||
207 | /* buffered reader ************************************************************/ | |
208 | ||
209 | typedef struct ev_reader ev_reader; | |
210 | ||
75d64210 RK |
211 | /** @brief Called when data is available to read |
212 | * @param ev Event loop | |
213 | * @param reader Reader | |
214 | * @param fd File descriptor we read from | |
215 | * @param ptr Pointer to first byte | |
216 | * @param bytes Number of bytes available | |
217 | * @param eof True if EOF has been detected | |
218 | * @param u As passed to ev_reader_new() | |
219 | * @return 0 on succes, non-0 on error | |
220 | * | |
221 | * This callback should call ev_reader_consume() to indicate how many bytes you | |
222 | * actually used. If you do not call it then it is assumed no bytes were | |
223 | * consumed. | |
224 | * | |
225 | * If having consumed some number of bytes it is not possible to do any further | |
226 | * processing until more data is available then the callback can just return. | |
227 | * Note that this is not allowed if @p eof was set. | |
228 | * | |
229 | * If on the other hand it would be possible to do more processing immediately | |
230 | * with the bytes available, but this is undesirable for some other reason, | |
231 | * then ev_reader_incomplete() should be called. This will arrange a further | |
232 | * callback in the very near future even if no more bytes are read. | |
233 | */ | |
460b9539 | 234 | typedef int ev_reader_callback(ev_source *ev, |
235 | ev_reader *reader, | |
460b9539 | 236 | void *ptr, |
237 | size_t bytes, | |
238 | int eof, | |
239 | void *u); | |
460b9539 | 240 | |
241 | ev_reader *ev_reader_new(ev_source *ev, | |
242 | int fd, | |
243 | ev_reader_callback *callback, | |
244 | ev_error_callback *error_callback, | |
e8c92ba7 RK |
245 | void *u, |
246 | const char *what); | |
460b9539 | 247 | /* register a new reader. @callback@ will be called whenever data is |
248 | * available. */ | |
249 | ||
250 | void ev_reader_buffer(ev_reader *r, size_t nbytes); | |
75d64210 | 251 | /* specify a buffer size */ |
460b9539 | 252 | |
75d64210 RK |
253 | void ev_reader_consume(ev_reader *r |
254 | , size_t nbytes); | |
460b9539 | 255 | /* consume @nbytes@ bytes. */ |
256 | ||
257 | int ev_reader_cancel(ev_reader *r); | |
258 | /* cancel a reader */ | |
259 | ||
260 | int ev_reader_disable(ev_reader *r); | |
261 | /* disable reading */ | |
262 | ||
263 | int ev_reader_incomplete(ev_reader *r); | |
264 | /* callback didn't fully process buffer, but would like another | |
265 | * callback (used where processing more would block too long) */ | |
266 | ||
267 | int ev_reader_enable(ev_reader *r); | |
268 | /* enable reading. If there is unconsumed data then you get a | |
269 | * callback next time round the event loop even if nothing new has | |
270 | * been read. | |
271 | * | |
272 | * The idea is in your read callback you come across a line (or | |
273 | * whatever) that can't be processed immediately. So you set up | |
274 | * processing and disable reading. Later when you finish processing | |
275 | * you re-enable. You'll automatically get another callback pretty | |
276 | * much direct from the event loop (not from inside ev_reader_enable) | |
277 | * so you can handle the next line (or whatever) if the whole thing | |
278 | * has in fact already arrived. | |
279 | */ | |
280 | ||
75d64210 RK |
281 | int ev_tie(ev_reader *r, ev_writer *w); |
282 | ||
460b9539 | 283 | #endif /* EVENT_H */ |
284 | ||
285 | /* | |
286 | Local Variables: | |
287 | c-basic-offset:2 | |
288 | comment-column:40 | |
289 | fill-column:79 | |
290 | End: | |
291 | */ |