2 * This file is part of DisOrder.
3 * Copyright (C) 2004, 2007 Richard Kettlewell
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
24 typedef struct ev_source ev_source;
29 ev_source *ev_new(void);
30 /* create a new event loop */
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
37 /* file descriptors ***********************************************************/
47 typedef int ev_fd_callback(ev_source *ev, int fd, void *u);
48 /* signature for fd callback functions */
50 int ev_fd(ev_source *ev,
53 ev_fd_callback *callback,
56 /* register a callback on a file descriptor */
58 int ev_fd_cancel(ev_source *ev,
61 /* cancel a callback on a file descriptor */
63 int ev_fd_disable(ev_source *ev,
66 /* temporarily disable callbacks on a file descriptor */
68 int ev_fd_enable(ev_source *ev,
71 /* re-enable callbacks on a file descriptor */
73 /* timeouts *******************************************************************/
75 typedef int ev_timeout_callback(ev_source *ev,
76 const struct timeval *now,
78 /* signature for timeout callback functions */
80 typedef void *ev_timeout_handle;
82 int ev_timeout(ev_source *ev,
83 ev_timeout_handle *handlep,
84 const struct timeval *when,
85 ev_timeout_callback *callback,
87 /* register a timeout callback. If @handlep@ is not a null pointer then a
88 * handle suitable for ev_timeout_cancel() below is returned through it. */
90 int ev_timeout_cancel(ev_source *ev,
91 ev_timeout_handle handle);
92 /* cancel a timeout callback */
94 /* signals ********************************************************************/
96 typedef int ev_signal_callback(ev_source *ev,
99 /* signature for signal callback functions */
101 int ev_signal(ev_source *ev,
103 ev_signal_callback *callback,
105 /* register a signal callback */
107 int ev_signal_cancel(ev_source *ev,
109 /* cancel a signal callback */
111 void ev_signal_atfork(ev_source *ev);
112 /* unhandle and unblock handled signals - call after calling fork and
113 * then setting @exitfn@ */
115 /* child processes ************************************************************/
117 typedef int ev_child_callback(ev_source *ev,
120 const struct rusage *rusage,
122 /* signature for child wait callbacks */
124 int ev_child_setup(ev_source *ev);
125 /* must be called exactly once before @ev_child@ */
127 int ev_child(ev_source *ev,
130 ev_child_callback *callback,
132 /* register a child callback. @options@ must be 0 or WUNTRACED. */
134 int ev_child_cancel(ev_source *ev,
136 /* cancel a child callback. */
138 /* socket listeners ***********************************************************/
140 typedef int ev_listen_callback(ev_source *ev,
142 const struct sockaddr *remote,
145 /* callback when a connection arrives. */
147 int ev_listen(ev_source *ev,
149 ev_listen_callback *callback,
152 /* register a socket listener callback. @bind@ and @listen@ should
153 * already have been called. */
155 int ev_listen_cancel(ev_source *ev,
157 /* cancel a socket listener callback */
159 /* buffered writer ************************************************************/
161 typedef struct ev_writer ev_writer;
163 typedef int ev_error_callback(ev_source *ev,
167 /* called when an error occurs on a writer. Called with @errno_value@
168 * of 0 when finished. */
170 ev_writer *ev_writer_new(ev_source *ev,
172 ev_error_callback *callback,
175 /* create a new buffered writer, writing to @fd@. Calls @error@ if an
178 int ev_writer_close(ev_writer *w);
179 /* close a writer (i.e. promise not to write to it any more) */
181 int ev_writer_cancel(ev_writer *w);
182 /* cancel a writer */
184 int ev_writer_flush(ev_writer *w);
185 /* attempt to flush the buffer */
187 struct sink *ev_writer_sink(ev_writer *w) attribute((const));
188 /* return a sink for the writer - use this to actually write to it */
190 /* buffered reader ************************************************************/
192 typedef struct ev_reader ev_reader;
194 typedef int ev_reader_callback(ev_source *ev,
201 /* Called when data is read or an error occurs. @ptr@ and @bytes@
202 * indicate the amount of data available. @eof@ will be 1 at eof. */
204 ev_reader *ev_reader_new(ev_source *ev,
206 ev_reader_callback *callback,
207 ev_error_callback *error_callback,
210 /* register a new reader. @callback@ will be called whenever data is
213 void ev_reader_buffer(ev_reader *r, size_t nbytes);
214 /* specify a buffer size *case */
216 void ev_reader_consume(ev_reader *r, size_t nbytes);
217 /* consume @nbytes@ bytes. */
219 int ev_reader_cancel(ev_reader *r);
220 /* cancel a reader */
222 int ev_reader_disable(ev_reader *r);
223 /* disable reading */
225 int ev_reader_incomplete(ev_reader *r);
226 /* callback didn't fully process buffer, but would like another
227 * callback (used where processing more would block too long) */
229 int ev_reader_enable(ev_reader *r);
230 /* enable reading. If there is unconsumed data then you get a
231 * callback next time round the event loop even if nothing new has
234 * The idea is in your read callback you come across a line (or
235 * whatever) that can't be processed immediately. So you set up
236 * processing and disable reading. Later when you finish processing
237 * you re-enable. You'll automatically get another callback pretty
238 * much direct from the event loop (not from inside ev_reader_enable)
239 * so you can handle the next line (or whatever) if the whole thing
240 * has in fact already arrived.