X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Fio%2Fio.h;h=1664df65f26e353120762f1ab89abc65ee01f1c9;hb=9b3f4ef6eec6a5981dcaa62f45da49b8f4f95388;hp=9316dd180a9895adc2f60fdb6cdaeff6d77deb4a;hpb=aae40e493625a07f4ac95476664447546b28661a;p=ccan

diff --git a/ccan/io/io.h b/ccan/io/io.h
index 9316dd18..1664df65 100644
--- a/ccan/io/io.h
+++ b/ccan/io/io.h
@@ -47,7 +47,8 @@ struct io_conn;
  *	int fd[2];
  *	struct io_conn *conn;
  *
- *	pipe(fd);
+ *	if (pipe(fd) != 0)
+ *		exit(1);
  *	conn = io_new_conn(NULL, fd[0], conn_init, (const char *)"hi!");
  *	if (!conn)
  *		exit(1);
@@ -108,7 +109,8 @@ void io_set_finish_(struct io_conn *conn,
  * @arg: the argument to @init.
  *
  * When @fd becomes readable, we accept(), create a new connection,
- * (tal'ocated off @ctx) and pass that to init().
+ * (tal'ocated off @ctx) and pass that to init().  Note that if there is
+ * an error on this file descriptor, it will be freed.
  *
  * Returns NULL on error (and sets errno).
  *
@@ -453,11 +455,8 @@ struct io_plan *io_connect_(struct io_conn *conn, const struct addrinfo *addr,
  *			 io_write(conn, b->out, sizeof(b->out), io_close_cb,b));
  * }
  */
-#define io_duplex(conn, in_plan, out_plan) \
-	(io_duplex_prepare(conn), io_duplex_(in_plan, out_plan))
-
-struct io_plan *io_duplex_(struct io_plan *in_plan, struct io_plan *out_plan);
-void io_duplex_prepare(struct io_conn *conn);
+struct io_plan *io_duplex(struct io_conn *conn,
+			  struct io_plan *in_plan, struct io_plan *out_plan);
 
 /**
  * io_halfclose - close half of an io_duplex connection.
@@ -597,14 +596,16 @@ struct io_plan *io_never(struct io_conn *conn, void *unused);
 /* FIXME: io_recvfrom/io_sendto */
 
 /**
- * io_close - plan to close a connection.
+ * io_close - close a connection.
  * @conn: the connection to close.
  *
- * On return to io_loop, the connection will be closed.  It doesn't have
- * to be the current connection and it doesn't need to be idle.  No more
- * IO or callbacks will occur.
+ * The connection is immediately freed: it doesn't have to be the
+ * current connection and it doesn't need to be idle.  No more IO or
+ * callbacks will occur, but if a function was added by io_set_finish()
+ * it will be called with the current errno preserved.
  *
- * You can close a connection twice without harmful effects.
+ * This is equivalent to tal_free(io_conn), except it returns an io_plan
+ * for use in an io callback.
  *
  * Example:
  * static struct io_plan *close_on_timeout(struct io_conn *conn, const char *msg)
@@ -619,14 +620,34 @@ struct io_plan *io_close(struct io_conn *conn);
  * io_close_cb - helper callback to close a connection.
  * @conn: the connection.
  *
- * This schedules a connection to be closed; designed to be used as
- * a callback function.
+ * This is closes a connection; designed to be used as a callback
+ * function.
  *
  * Example:
  *	#define close_on_timeout io_close_cb
  */
 struct io_plan *io_close_cb(struct io_conn *, void *unused);
 
+/**
+ * io_close_taken_fd - close a connection, but remove the filedescriptor first.
+ * @conn: the connection to take the file descriptor from and close.
+ *
+ * io_close closes the file descriptor underlying the io_conn; this version does
+ * not.  Presumably you have used io_conn_fd() on it beforehand and will take
+ * care of the fd yourself.
+ *
+ * Note that this also turns off O_NONBLOCK on the fd.
+ *
+ * Example:
+ * static struct io_plan *steal_fd(struct io_conn *conn, int *fd)
+ * {
+ *	*fd = io_conn_fd(conn);
+ *	printf("stealing fd %i and closing\n", *fd);
+ *	return io_close_taken_fd(conn);
+ * }
+ */
+struct io_plan *io_close_taken_fd(struct io_conn *conn);
+
 /**
  * io_loop - process fds until all closed on io_break.
  * @timers - timers which are waiting to go off (or NULL for none)
@@ -645,7 +666,10 @@ void *io_loop(struct timers *timers, struct timer **expired);
  * io_conn_fd - get the fd from a connection.
  * @conn: the connection.
  *
- * Sometimes useful, eg for getsockname().
+ * Sometimes useful, eg for getsockname().  Note that the fd is O_NONBLOCK.
+ *
+ * See Also:
+ *	io_close_taken_fd
  */
 int io_conn_fd(const struct io_conn *conn);
 
@@ -653,43 +677,10 @@ int io_conn_fd(const struct io_conn *conn);
  * io_time_override - override the normal call for time.
  * @nowfn: the function to call.
  *
- * io usually uses time_now() internally, but this forces it
+ * io usually uses time_mono() internally, but this forces it
  * to use your function (eg. for debugging).  Returns the old
  * one.
  */
-struct timeabs (*io_time_override(struct timeabs (*now)(void)))(void);
-
-/**
- * io_set_debug - set synchronous mode on a connection.
- * @conn: the connection.
- * @debug: whether to enable or disable debug.
- *
- * Once @debug is true on a connection, all I/O is done synchronously
- * as soon as it is set, until it is unset or @conn is closed.  This
- * makes it easy to debug what's happening with a connection, but note
- * that other connections are starved while this is being done.
- *
- * See also: io_debug_complete()
- *
- * Example:
- * // Dumb init function to set debug and tell conn to close.
- * static struct io_plan *conn_init(struct io_conn *conn, const char *msg)
- * {
- *	io_set_debug(conn, true);
- *	return io_close(conn);
- * }
- */
-void io_set_debug(struct io_conn *conn, bool debug);
+struct timemono (*io_time_override(struct timemono (*now)(void)))(void);
 
-/**
- * io_debug_complete - empty function called when conn is closing/waiting.
- * @conn: the connection.
- *
- * This is for putting a breakpoint onto, when debugging.  It is called
- * when a conn with io_set_debug() true can no longer be synchronous:
- * 1) It is io_close()'d
- * 2) It enters io_wait() (sychronous debug will resume after io_wake())
- * 3) io_break() is called (sychronous debug will resume after io_loop())
- */
-void io_debug_complete(struct io_conn *conn);
 #endif /* CCAN_IO_H */