]> git.ozlabs.org Git - ccan/blobdiff - ccan/io/io.c
io: always make fds O_NONBLOCK.
[ccan] / ccan / io / io.c
index a58b3f01a71f7526dba3f4e69fb987d8ebaea703..0e716fced062c594d42955603e3fcfd2af67d3bb 100644 (file)
 #include <errno.h>
 #include <stdlib.h>
 #include <assert.h>
-#include <poll.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <ccan/container_of/container_of.h>
 
 void *io_loop_return;
 
-struct io_alloc io_alloc = {
-       malloc, realloc, free
-};
-
-#ifdef DEBUG
-/* Set to skip the next plan. */
-bool io_plan_nodebug;
-/* The current connection to apply plan to. */
-struct io_conn *current;
-/* User-defined function to select which connection(s) to debug. */
-bool (*io_debug_conn)(struct io_conn *conn);
-/* Set when we wake up an connection we are debugging. */
-bool io_debug_wakeup;
-
-struct io_plan io_debug(struct io_plan plan)
-{
-       struct io_conn *ready = NULL;
-
-       if (io_plan_nodebug) {
-               io_plan_nodebug = false;
-               return plan;
-       }
-
-       if (!current || !doing_debug_on(current)) {
-               if (!io_debug_wakeup)
-                       return plan;
-       }
-
-       io_debug_wakeup = false;
-       current->plan = plan;
-       backend_plan_changed(current);
-
-       /* Call back into the loop immediately. */
-       io_loop_return = do_io_loop(&ready);
-
-       if (ready) {
-               set_current(ready);
-               if (!ready->plan.next) {
-                       /* Call finish function immediately. */
-                       if (ready->finish) {
-                               errno = ready->plan.u1.s;
-                               ready->finish(ready, ready->finish_arg);
-                               ready->finish = NULL;
-                       }
-                       backend_del_conn(ready);
-               } else {
-                       /* Calls back in itself, via io_debug_io(). */
-                       if (ready->plan.io(ready->fd.fd, &ready->plan) != 2)
-                               abort();
-               }
-               set_current(NULL);
-       }
-
-       /* Return a do-nothing plan, so backend_plan_changed in
-        * io_ready doesn't do anything (it's already been called). */
-       return io_idle_();
-}
-
-int io_debug_io(int ret)
-{
-       /* Cache it for debugging; current changes. */
-       struct io_conn *conn = current;
-       int saved_errno = errno;
-
-       if (!doing_debug_on(conn))
-               return ret;
-
-       /* These will all go linearly through the io_debug() path above. */
-       switch (ret) {
-       case -1:
-               /* This will call io_debug above. */
-               errno = saved_errno;
-               io_close();
-               break;
-       case 0: /* Keep going with plan. */
-               io_debug(conn->plan);
-               break;
-       case 1: /* Done: get next plan. */
-               if (timeout_active(conn))
-                       backend_del_timeout(conn);
-               /* In case they call io_duplex, clear our poll flags so
-                * both sides don't seem to be both doing read or write
-                * (See assert(!mask || pfd->events != mask) in poll.c) */
-               conn->plan.pollflag = 0;
-               conn->plan.next(conn, conn->plan.next_arg);
-               break;
-       default:
-               abort();
-       }
-
-       /* Normally-invalid value, used for sanity check. */
-       return 2;
-}
-
-static void debug_io_wake(struct io_conn *conn)
-{
-       /* We want linear if we wake a debugged connection, too. */
-       if (io_debug_conn && io_debug_conn(conn))
-               io_debug_wakeup = true;
-}
-
-/* Counterpart to io_plan_no_debug(), called in macros in io.h */
-static void io_plan_debug_again(void)
-{
-       io_plan_nodebug = false;
-}
-#else
-static void debug_io_wake(struct io_conn *conn)
-{
-}
-static void io_plan_debug_again(void)
-{
-}
-#endif
-
-struct io_listener *io_new_listener_(int fd,
-                                    void (*init)(int fd, void *arg),
+struct io_listener *io_new_listener_(const tal_t *ctx, int fd,
+                                    struct io_plan *(*init)(struct io_conn *,
+                                                            void *),
                                     void *arg)
 {
-       struct io_listener *l = io_alloc.alloc(sizeof(*l));
-
+       struct io_listener *l = tal(ctx, struct io_listener);
        if (!l)
                return NULL;
 
@@ -142,10 +27,9 @@ struct io_listener *io_new_listener_(int fd,
        l->fd.fd = fd;
        l->init = init;
        l->arg = arg;
-       if (!add_listener(l)) {
-               io_alloc.free(l);
-               return NULL;
-       }
+       l->ctx = ctx;
+       if (!add_listener(l))
+               return tal_free(l);
        return l;
 }
 
@@ -153,29 +37,77 @@ void io_close_listener(struct io_listener *l)
 {
        close(l->fd.fd);
        del_listener(l);
-       io_alloc.free(l);
+       tal_free(l);
+}
+
+static struct io_plan *io_never_called(struct io_conn *conn, void *arg)
+{
+       abort();
 }
 
-struct io_conn *io_new_conn_(int fd, struct io_plan plan)
+static void next_plan(struct io_conn *conn, struct io_plan *plan)
 {
-       struct io_conn *conn = io_alloc.alloc(sizeof(*conn));
+       struct io_plan *(*next)(struct io_conn *, void *arg);
 
-       io_plan_debug_again();
+       next = plan->next;
+
+       plan->status = IO_UNSET;
+       plan->io = NULL;
+       plan->next = io_never_called;
+
+       plan = next(conn, plan->next_arg);
+
+       /* It should have set a plan inside this conn (or duplex) */
+       assert(plan == &conn->plan[IO_IN]
+              || plan == &conn->plan[IO_OUT]
+              || plan == &conn->plan[2]);
+       assert(conn->plan[IO_IN].status != IO_UNSET
+              || conn->plan[IO_OUT].status != IO_UNSET);
+
+       backend_new_plan(conn);
+}
+
+static void set_blocking(int fd, bool block)
+{
+       int flags = fcntl(fd, F_GETFL);
+
+       if (block)
+               flags &= ~O_NONBLOCK;
+       else
+               flags |= O_NONBLOCK;
+
+       fcntl(fd, F_SETFL, flags);
+}
+
+struct io_conn *io_new_conn_(const tal_t *ctx, int fd,
+                            struct io_plan *(*init)(struct io_conn *, void *),
+                            void *arg)
+{
+       struct io_conn *conn = tal(ctx, struct io_conn);
 
        if (!conn)
                return NULL;
 
        conn->fd.listener = false;
        conn->fd.fd = fd;
-       conn->plan = plan;
        conn->finish = NULL;
        conn->finish_arg = NULL;
-       conn->duplex = NULL;
-       conn->timeout = NULL;
-       if (!add_conn(conn)) {
-               io_alloc.free(conn);
-               return NULL;
-       }
+       conn->list = NULL;
+       conn->debug = false;
+
+       if (!add_conn(conn))
+               return tal_free(conn);
+
+       /* Keep our I/O async. */
+       set_blocking(fd, false);
+
+       /* We start with out doing nothing, and in doing our init. */
+       conn->plan[IO_OUT].status = IO_UNSET;
+
+       conn->plan[IO_IN].next = init;
+       conn->plan[IO_IN].next_arg = arg;
+       next_plan(conn, &conn->plan[IO_IN]);
+
        return conn;
 }
 
@@ -187,172 +119,167 @@ void io_set_finish_(struct io_conn *conn,
        conn->finish_arg = arg;
 }
 
-struct io_conn *io_duplex_(struct io_conn *old, struct io_plan plan)
+struct io_plan_arg *io_plan_arg(struct io_conn *conn, enum io_direction dir)
 {
-       struct io_conn *conn;
-
-       io_plan_debug_again();
+       assert(conn->plan[dir].status == IO_UNSET);
 
-       assert(!old->duplex);
+       conn->plan[dir].status = IO_POLLING;
+       return &conn->plan[dir].arg;
+}
 
-       conn = io_alloc.alloc(sizeof(*conn));
-       if (!conn)
-               return NULL;
+static struct io_plan *set_always(struct io_conn *conn,
+                                 enum io_direction dir,
+                                 struct io_plan *(*next)(struct io_conn *,
+                                                         void *),
+                                 void *arg)
+{
+       struct io_plan *plan = &conn->plan[dir];
 
-       conn->fd.listener = false;
-       conn->fd.fd = old->fd.fd;
-       conn->plan = plan;
-       conn->duplex = old;
-       conn->finish = NULL;
-       conn->finish_arg = NULL;
-       conn->timeout = NULL;
-       if (!add_duplex(conn)) {
-               io_alloc.free(conn);
-               return NULL;
-       }
-       old->duplex = conn;
-       return conn;
+       plan->status = IO_ALWAYS;
+       backend_new_always(conn);
+       return io_set_plan(conn, dir, NULL, next, arg);
 }
 
-bool io_timeout_(struct io_conn *conn, struct timespec ts,
-                struct io_plan (*cb)(struct io_conn *, void *), void *arg)
+static struct io_plan *io_always_dir(struct io_conn *conn,
+                                    enum io_direction dir,
+                                    struct io_plan *(*next)(struct io_conn *,
+                                                            void *),
+                                    void *arg)
 {
-       assert(cb);
+       return set_always(conn, dir, next, arg);
+}
 
-       if (!conn->timeout) {
-               conn->timeout = io_alloc.alloc(sizeof(*conn->timeout));
-               if (!conn->timeout)
-                       return false;
-       } else
-               assert(!timeout_active(conn));
+struct io_plan *io_always_(struct io_conn *conn,
+                          struct io_plan *(*next)(struct io_conn *, void *),
+                          void *arg)
+{
+       return io_always_dir(conn, IO_IN, next, arg);
+}
 
-       conn->timeout->next = cb;
-       conn->timeout->next_arg = arg;
-       backend_add_timeout(conn, ts);
-       return true;
+struct io_plan *io_out_always_(struct io_conn *conn,
+                              struct io_plan *(*next)(struct io_conn *,
+                                                      void *),
+                              void *arg)
+{
+       return io_always_dir(conn, IO_OUT, next, arg);
 }
 
-/* Returns true if we're finished. */
-static int do_write(int fd, struct io_plan *plan)
+static int do_write(int fd, struct io_plan_arg *arg)
 {
-       ssize_t ret = write(fd, plan->u1.cp, plan->u2.s);
+       ssize_t ret = write(fd, arg->u1.cp, arg->u2.s);
        if (ret < 0)
-               return io_debug_io(-1);
+               return -1;
 
-       plan->u1.cp += ret;
-       plan->u2.s -= ret;
-       return io_debug_io(plan->u2.s == 0);
+       arg->u1.cp += ret;
+       arg->u2.s -= ret;
+       return arg->u2.s == 0;
 }
 
 /* Queue some data to be written. */
-struct io_plan io_write_(const void *data, size_t len,
-                        struct io_plan (*cb)(struct io_conn *, void *),
-                        void *arg)
+struct io_plan *io_write_(struct io_conn *conn, const void *data, size_t len,
+                         struct io_plan *(*next)(struct io_conn *, void *),
+                         void *next_arg)
 {
-       struct io_plan plan;
+       struct io_plan_arg *arg = io_plan_arg(conn, IO_OUT);
 
-       assert(cb);
-       plan.u1.const_vp = data;
-       plan.u2.s = len;
-       plan.io = do_write;
-       plan.next = cb;
-       plan.next_arg = arg;
-       plan.pollflag = POLLOUT;
+       if (len == 0)
+               return set_always(conn, IO_OUT, next, next_arg);
 
-       return plan;
+       arg->u1.const_vp = data;
+       arg->u2.s = len;
+
+       return io_set_plan(conn, IO_OUT, do_write, next, next_arg);
 }
 
-static int do_read(int fd, struct io_plan *plan)
+static int do_read(int fd, struct io_plan_arg *arg)
 {
-       ssize_t ret = read(fd, plan->u1.cp, plan->u2.s);
+       ssize_t ret = read(fd, arg->u1.cp, arg->u2.s);
        if (ret <= 0)
-               return io_debug_io(-1);
+               return -1;
 
-       plan->u1.cp += ret;
-       plan->u2.s -= ret;
-       return io_debug_io(plan->u2.s == 0);
+       arg->u1.cp += ret;
+       arg->u2.s -= ret;
+       return arg->u2.s == 0;
 }
 
 /* Queue a request to read into a buffer. */
-struct io_plan io_read_(void *data, size_t len,
-                       struct io_plan (*cb)(struct io_conn *, void *),
-                       void *arg)
+struct io_plan *io_read_(struct io_conn *conn,
+                        void *data, size_t len,
+                        struct io_plan *(*next)(struct io_conn *, void *),
+                        void *next_arg)
 {
-       struct io_plan plan;
+       struct io_plan_arg *arg = io_plan_arg(conn, IO_IN);
 
-       assert(cb);
-       plan.u1.cp = data;
-       plan.u2.s = len;
-       plan.io = do_read;
-       plan.next = cb;
-       plan.next_arg = arg;
-       plan.pollflag = POLLIN;
+       if (len == 0)
+               return set_always(conn, IO_IN, next, next_arg);
 
-       return plan;
+       arg->u1.cp = data;
+       arg->u2.s = len;
+
+       return io_set_plan(conn, IO_IN, do_read, next, next_arg);
 }
 
-static int do_read_partial(int fd, struct io_plan *plan)
+static int do_read_partial(int fd, struct io_plan_arg *arg)
 {
-       ssize_t ret = read(fd, plan->u1.cp, *(size_t *)plan->u2.vp);
+       ssize_t ret = read(fd, arg->u1.cp, *(size_t *)arg->u2.vp);
        if (ret <= 0)
-               return io_debug_io(-1);
+               return -1;
 
-       *(size_t *)plan->u2.vp = ret;
-       return io_debug_io(1);
+       *(size_t *)arg->u2.vp = ret;
+       return 1;
 }
 
 /* Queue a partial request to read into a buffer. */
-struct io_plan io_read_partial_(void *data, size_t *len,
-                               struct io_plan (*cb)(struct io_conn *, void *),
-                               void *arg)
+struct io_plan *io_read_partial_(struct io_conn *conn,
+                                void *data, size_t maxlen, size_t *len,
+                                struct io_plan *(*next)(struct io_conn *,
+                                                        void *),
+                                void *next_arg)
 {
-       struct io_plan plan;
+       struct io_plan_arg *arg = io_plan_arg(conn, IO_IN);
 
-       assert(cb);
-       plan.u1.cp = data;
-       plan.u2.vp = len;
-       plan.io = do_read_partial;
-       plan.next = cb;
-       plan.next_arg = arg;
-       plan.pollflag = POLLIN;
+       if (maxlen == 0)
+               return set_always(conn, IO_IN, next, next_arg);
 
-       return plan;
+       arg->u1.cp = data;
+       /* We store the max len in here temporarily. */
+       *len = maxlen;
+       arg->u2.vp = len;
+
+       return io_set_plan(conn, IO_IN, do_read_partial, next, next_arg);
 }
 
-static int do_write_partial(int fd, struct io_plan *plan)
+static int do_write_partial(int fd, struct io_plan_arg *arg)
 {
-       ssize_t ret = write(fd, plan->u1.cp, *(size_t *)plan->u2.vp);
+       ssize_t ret = write(fd, arg->u1.cp, *(size_t *)arg->u2.vp);
        if (ret < 0)
-               return io_debug_io(-1);
+               return -1;
 
-       *(size_t *)plan->u2.vp = ret;
-       return io_debug_io(1);
+       *(size_t *)arg->u2.vp = ret;
+       return 1;
 }
 
 /* Queue a partial write request. */
-struct io_plan io_write_partial_(const void *data, size_t *len,
-                                struct io_plan (*cb)(struct io_conn*, void *),
-                                void *arg)
+struct io_plan *io_write_partial_(struct io_conn *conn,
+                                 const void *data, size_t maxlen, size_t *len,
+                                 struct io_plan *(*next)(struct io_conn *,
+                                                         void*),
+                                 void *next_arg)
 {
-       struct io_plan plan;
+       struct io_plan_arg *arg = io_plan_arg(conn, IO_OUT);
 
-       assert(cb);
-       plan.u1.const_vp = data;
-       plan.u2.vp = len;
-       plan.io = do_write_partial;
-       plan.next = cb;
-       plan.next_arg = arg;
-       plan.pollflag = POLLOUT;
+       if (maxlen == 0)
+               return set_always(conn, IO_OUT, next, next_arg);
 
-       return plan;
-}
+       arg->u1.const_vp = data;
+       /* We store the max len in here temporarily. */
+       *len = maxlen;
+       arg->u2.vp = len;
 
-static int already_connected(int fd, struct io_plan *plan)
-{
-       return io_debug_io(1);
+       return io_set_plan(conn, IO_OUT, do_write_partial, next, next_arg);
 }
 
-static int do_connect(int fd, struct io_plan *plan)
+static int do_connect(int fd, struct io_plan_arg *arg)
 {
        int err, ret;
        socklen_t len = sizeof(err);
@@ -363,126 +290,151 @@ static int do_connect(int fd, struct io_plan *plan)
                return -1;
 
        if (err == 0) {
-               /* Restore blocking if it was initially. */
-               fcntl(fd, F_SETFD, plan->u1.s);
                return 1;
-       }
-       return 0;
+       } else if (err == EINPROGRESS)
+               return 0;
+
+       errno = err;
+       return -1;
 }
 
-struct io_plan io_connect_(int fd, const struct addrinfo *addr,
-                          struct io_plan (*cb)(struct io_conn*, void *),
-                          void *arg)
+struct io_plan *io_connect_(struct io_conn *conn, const struct addrinfo *addr,
+                           struct io_plan *(*next)(struct io_conn *, void *),
+                           void *next_arg)
 {
-       struct io_plan plan;
+       int fd = io_conn_fd(conn);
 
-       assert(cb);
+       /* We don't actually need the arg, but we need it polling. */
+       io_plan_arg(conn, IO_OUT);
 
-       plan.next = cb;
-       plan.next_arg = arg;
-
-       /* Save old flags, set nonblock if not already. */
-       plan.u1.s = fcntl(fd, F_GETFD);
-       fcntl(fd, F_SETFD, plan.u1.s | O_NONBLOCK);
+       /* Note that io_new_conn() will make fd O_NONBLOCK */
 
        /* Immediate connect can happen. */
-       if (connect(fd, addr->ai_addr, addr->ai_addrlen) == 0) {
-               /* Dummy will be called immediately. */
-               plan.pollflag = POLLOUT;
-               plan.io = already_connected;
-       } else {
-               if (errno != EINPROGRESS)
-                       return io_close_();
-
-               plan.pollflag = POLLIN;
-               plan.io = do_connect;
-       }
-       return plan;
+       if (connect(fd, addr->ai_addr, addr->ai_addrlen) == 0)
+               return set_always(conn, IO_OUT, next, next_arg);
+
+       if (errno != EINPROGRESS)
+               return io_close(conn);
+
+       return io_set_plan(conn, IO_OUT, do_connect, next, next_arg);
 }
 
-struct io_plan io_idle_(void)
+static struct io_plan *io_wait_dir(struct io_conn *conn,
+                                  const void *wait,
+                                  enum io_direction dir,
+                                  struct io_plan *(*next)(struct io_conn *,
+                                                          void *),
+                                  void *next_arg)
 {
-       struct io_plan plan;
+       struct io_plan_arg *arg = io_plan_arg(conn, dir);
+       arg->u1.const_vp = wait;
 
-       plan.pollflag = 0;
-       plan.io = NULL;
-       /* Never called (overridden by io_wake), but NULL means closing */
-       plan.next = (void *)io_idle_;
+       conn->plan[dir].status = IO_WAITING;
 
-       return plan;
+       return io_set_plan(conn, dir, NULL, next, next_arg);
+}
+
+struct io_plan *io_wait_(struct io_conn *conn,
+                        const void *wait,
+                        struct io_plan *(*next)(struct io_conn *, void *),
+                        void *next_arg)
+{
+       return io_wait_dir(conn, wait, IO_IN, next, next_arg);
+}
+
+struct io_plan *io_out_wait_(struct io_conn *conn,
+                            const void *wait,
+                            struct io_plan *(*next)(struct io_conn *, void *),
+                            void *next_arg)
+{
+       return io_wait_dir(conn, wait, IO_OUT, next, next_arg);
 }
 
-bool io_is_idle(const struct io_conn *conn)
+void io_wake(const void *wait)
 {
-       return conn->plan.io == NULL;
+       backend_wake(wait);
 }
 
-void io_wake_(struct io_conn *conn, struct io_plan plan)
+static int do_plan(struct io_conn *conn, struct io_plan *plan)
+{
+       /* Someone else might have called io_close() on us. */
+       if (plan->status == IO_CLOSING)
+               return -1;
+
+       /* We shouldn't have polled for this event if this wasn't true! */
+       assert(plan->status == IO_POLLING);
 
+       switch (plan->io(conn->fd.fd, &plan->arg)) {
+       case -1:
+               io_close(conn);
+               return -1;
+       case 0:
+               return 0;
+       case 1:
+               next_plan(conn, plan);
+               return 1;
+       default:
+               /* IO should only return -1, 0 or 1 */
+               abort();
+       }
+}
+
+void io_ready(struct io_conn *conn, int pollflags)
 {
-       io_plan_debug_again();
+       if (pollflags & POLLIN)
+               do_plan(conn, &conn->plan[IO_IN]);
 
-       /* It might be closing, but we haven't called its finish() yet. */
-       if (!conn->plan.next)
-               return;
-       /* It was idle, right? */
-       assert(!conn->plan.io);
-       conn->plan = plan;
-       backend_plan_changed(conn);
+       if (pollflags & POLLOUT)
+               do_plan(conn, &conn->plan[IO_OUT]);
+}
+
+void io_do_always(struct io_conn *conn)
+{
+       if (conn->plan[IO_IN].status == IO_ALWAYS)
+               next_plan(conn, &conn->plan[IO_IN]);
 
-       debug_io_wake(conn);
+       if (conn->plan[IO_OUT].status == IO_ALWAYS)
+               next_plan(conn, &conn->plan[IO_OUT]);
 }
 
-void io_ready(struct io_conn *conn)
+void io_do_wakeup(struct io_conn *conn, enum io_direction dir)
 {
-       set_current(conn);
-       switch (conn->plan.io(conn->fd.fd, &conn->plan)) {
-       case -1: /* Failure means a new plan: close up. */
-               conn->plan = io_close();
-               backend_plan_changed(conn);
-               break;
-       case 0: /* Keep going with plan. */
-               break;
-       case 1: /* Done: get next plan. */
-               if (timeout_active(conn))
-                       backend_del_timeout(conn);
-               /* In case they call io_duplex, clear our poll flags so
-                * both sides don't seem to be both doing read or write
-                * (See assert(!mask || pfd->events != mask) in poll.c) */
-               conn->plan.pollflag = 0;
-               conn->plan = conn->plan.next(conn, conn->plan.next_arg);
-               backend_plan_changed(conn);
-       }
-       set_current(NULL);
+       struct io_plan *plan = &conn->plan[dir];
+
+       assert(plan->status == IO_WAITING);
+
+       set_always(conn, dir, plan->next, plan->next_arg);
 }
 
 /* Close the connection, we're done. */
-struct io_plan io_close_(void)
+struct io_plan *io_close(struct io_conn *conn)
 {
-       struct io_plan plan;
+       /* Already closing?  Don't close twice. */
+       if (conn->plan[IO_IN].status == IO_CLOSING)
+               return &conn->plan[IO_IN];
 
-       plan.pollflag = 0;
-       /* This means we're closing. */
-       plan.next = NULL;
-       plan.u1.s = errno;
+       conn->plan[IO_IN].status = conn->plan[IO_OUT].status = IO_CLOSING;
+       conn->plan[IO_IN].arg.u1.s = errno;
+       backend_new_closing(conn);
 
-       return plan;
+       return io_set_plan(conn, IO_IN, NULL, NULL, NULL);
 }
 
-struct io_plan io_close_cb(struct io_conn *conn, void *arg)
+struct io_plan *io_close_cb(struct io_conn *conn, void *next_arg)
 {
-       return io_close();
+       return io_close(conn);
 }
 
 /* Exit the loop, returning this (non-NULL) arg. */
-struct io_plan io_break_(void *ret, struct io_plan plan)
+void io_break(const void *ret)
 {
-       io_plan_debug_again();
-
        assert(ret);
-       io_loop_return = ret;
+       io_loop_return = (void *)ret;
+}
 
-       return plan;
+struct io_plan *io_never(struct io_conn *conn, void *unused)
+{
+       return io_always(conn, io_never_called, NULL);
 }
 
 int io_conn_fd(const struct io_conn *conn)
@@ -490,11 +442,104 @@ int io_conn_fd(const struct io_conn *conn)
        return conn->fd.fd;
 }
 
-void io_set_alloc(void *(*allocfn)(size_t size),
-                 void *(*reallocfn)(void *ptr, size_t size),
-                 void (*freefn)(void *ptr))
+void io_duplex_prepare(struct io_conn *conn)
+{
+       assert(conn->plan[IO_IN].status == IO_UNSET);
+       assert(conn->plan[IO_OUT].status == IO_UNSET);
+
+       /* We can't sync debug until we've set both: io_wait() and io_always
+        * can't handle it. */
+       conn->debug_saved = conn->debug;
+       io_set_debug(conn, false);
+}
+
+struct io_plan *io_duplex_(struct io_plan *in_plan, struct io_plan *out_plan)
+{
+       struct io_conn *conn;
+
+       /* in_plan must be conn->plan[IO_IN], out_plan must be [IO_OUT] */
+       assert(out_plan == in_plan + 1);
+
+       /* Restore debug. */
+       conn = container_of(in_plan, struct io_conn, plan[IO_IN]);
+       io_set_debug(conn, conn->debug_saved);
+
+       /* Now set the plans again, to invoke sync debug. */
+       io_set_plan(conn, IO_OUT,
+                   out_plan->io, out_plan->next, out_plan->next_arg);
+       io_set_plan(conn, IO_IN,
+                   in_plan->io, in_plan->next, in_plan->next_arg);
+
+       return out_plan + 1;
+}
+
+struct io_plan *io_halfclose(struct io_conn *conn)
+{
+       /* Already closing?  Don't close twice. */
+       if (conn->plan[IO_IN].status == IO_CLOSING)
+               return &conn->plan[IO_IN];
+
+       /* Both unset?  OK. */
+       if (conn->plan[IO_IN].status == IO_UNSET
+           && conn->plan[IO_OUT].status == IO_UNSET)
+               return io_close(conn);
+
+       /* We leave this unset then. */
+       if (conn->plan[IO_IN].status == IO_UNSET)
+               return &conn->plan[IO_IN];
+       else
+               return &conn->plan[IO_OUT];
+}
+
+struct io_plan *io_set_plan(struct io_conn *conn, enum io_direction dir,
+                           int (*io)(int fd, struct io_plan_arg *arg),
+                           struct io_plan *(*next)(struct io_conn *, void *),
+                           void *next_arg)
+{
+       struct io_plan *plan = &conn->plan[dir];
+
+       plan->io = io;
+       plan->next = next;
+       plan->next_arg = next_arg;
+       assert(plan->status == IO_CLOSING || next != NULL);
+
+       if (!conn->debug)
+               return plan;
+
+       if (io_loop_return) {
+               io_debug_complete(conn);
+               return plan;
+       }
+
+       switch (plan->status) {
+       case IO_POLLING:
+               while (do_plan(conn, plan) == 0);
+               break;
+       /* Shouldn't happen, since you said you did plan! */
+       case IO_UNSET:
+               abort();
+       case IO_ALWAYS:
+               /* If other one is ALWAYS, leave in list! */
+               if (conn->plan[!dir].status != IO_ALWAYS)
+                       remove_from_always(conn);
+               next_plan(conn, plan);
+               break;
+       case IO_WAITING:
+       case IO_CLOSING:
+               io_debug_complete(conn);
+       }
+
+       return plan;
+}
+
+void io_set_debug(struct io_conn *conn, bool debug)
+{
+       conn->debug = debug;
+
+       /* Debugging means fds must block. */
+       set_blocking(io_conn_fd(conn), debug);
+}
+
+void io_debug_complete(struct io_conn *conn)
 {
-       io_alloc.alloc = allocfn;
-       io_alloc.realloc = reallocfn;
-       io_alloc.free = freefn;
 }