io: don't close if already closing in io_close_other.

[ccan] / ccan / io / io.c

diff --git a/ccan/io/io.c b/ccan/io/io.c
index faf8b87bfd649b7244e8ee01087651d1039dbbf5..4c73b62455693f6ae5c633c910921583cd3a5089 100644 (file)
--- a/ccan/io/io.c
+++ b/ccan/io/io.c
@@ -8,7 +8,6 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <assert.h>
-#include <poll.h>
 #include <unistd.h>
 #include <fcntl.h>
 
@@ -25,8 +24,6 @@ bool io_plan_nodebug;
 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)
 {
@@ -37,12 +34,9 @@ struct io_plan io_debug(struct io_plan plan)
                return plan;
        }
 
-       if (!current || !doing_debug_on(current)) {
-               if (!io_debug_wakeup)
-                       return plan;
-       }
+       if (!current || !doing_debug_on(current))
+               return plan;
 
-       io_debug_wakeup = false;
        current->plan = plan;
        backend_plan_changed(current);
 
@@ -69,7 +63,7 @@ struct io_plan io_debug(struct io_plan plan)
 
        /* Return a do-nothing plan, so backend_plan_changed in
         * io_ready doesn't do anything (it's already been called). */
-       return io_idle_();
+       return io_wait_(NULL, (void *)1, NULL);
 }
 
 int io_debug_io(int ret)
@@ -108,22 +102,12 @@ int io_debug_io(int ret)
        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)
 {
 }
@@ -232,6 +216,26 @@ bool io_timeout_(struct io_conn *conn, struct timespec ts,
        return true;
 }
 
+/* Always done: call the next thing. */
+static int do_always(int fd, struct io_plan *plan)
+{
+       return 1;
+}
+
+struct io_plan io_always_(struct io_plan (*cb)(struct io_conn *, void *),
+                         void *arg)
+{
+       struct io_plan plan;
+
+       assert(cb);
+       plan.io = do_always;
+       plan.next = cb;
+       plan.next_arg = arg;
+       plan.pollflag = POLLALWAYS;
+
+       return plan;
+}
+
 /* Returns true if we're finished. */
 static int do_write(int fd, struct io_plan *plan)
 {
@@ -252,6 +256,10 @@ struct io_plan io_write_(const void *data, size_t len,
        struct io_plan plan;
 
        assert(cb);
+
+       if (len == 0)
+               return io_always_(cb, arg);
+
        plan.u1.const_vp = data;
        plan.u2.s = len;
        plan.io = do_write;
@@ -281,11 +289,16 @@ struct io_plan io_read_(void *data, size_t len,
        struct io_plan plan;
 
        assert(cb);
+
+       if (len == 0)
+               return io_always_(cb, arg);
+
        plan.u1.cp = data;
        plan.u2.s = len;
        plan.io = do_read;
        plan.next = cb;
        plan.next_arg = arg;
+
        plan.pollflag = POLLIN;
 
        return plan;
@@ -309,6 +322,10 @@ struct io_plan io_read_partial_(void *data, size_t *len,
        struct io_plan plan;
 
        assert(cb);
+
+       if (*len == 0)
+               return io_always_(cb, arg);
+
        plan.u1.cp = data;
        plan.u2.vp = len;
        plan.io = do_read_partial;
@@ -337,6 +354,10 @@ struct io_plan io_write_partial_(const void *data, size_t *len,
        struct io_plan plan;
 
        assert(cb);
+
+       if (*len == 0)
+               return io_always_(cb, arg);
+
        plan.u1.const_vp = data;
        plan.u2.vp = len;
        plan.io = do_write_partial;
@@ -400,37 +421,26 @@ struct io_plan io_connect_(int fd, const struct addrinfo *addr,
        return plan;
 }
 
-struct io_plan io_idle_(void)
+struct io_plan io_wait_(const void *wait,
+                       struct io_plan (*cb)(struct io_conn *, void*),
+                       void *arg)
 {
        struct io_plan plan;
 
+       assert(cb);
        plan.pollflag = 0;
        plan.io = NULL;
-       /* Never called (overridden by io_wake), but NULL means closing */
-       plan.next = (void *)io_idle_;
+       plan.next = cb;
+       plan.next_arg = arg;
 
-       return plan;
-}
+       plan.u1.const_vp = wait;
 
-bool io_is_idle(const struct io_conn *conn)
-{
-       return conn->plan.io == NULL;
+       return plan;
 }
 
-void io_wake_(struct io_conn *conn, struct io_plan plan)
-
+void io_wake(const void *wait)
 {
-       io_plan_debug_again();
-
-       /* 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);
-
-       debug_io_wake(conn);
+       backend_wait_changed(wait);
 }
 
 void io_ready(struct io_conn *conn)
@@ -480,8 +490,11 @@ struct io_plan io_close_cb(struct io_conn *conn, void *arg)
 
 void io_close_other(struct io_conn *conn)
 {
-       conn->plan = io_close_();
-       backend_plan_changed(conn);
+       /* Don't close if already closing! */
+       if (conn->plan.next) {
+               conn->plan = io_close_();
+               backend_plan_changed(conn);
+       }
 }
 
 /* Exit the loop, returning this (non-NULL) arg. */
@@ -495,6 +508,16 @@ struct io_plan io_break_(void *ret, struct io_plan plan)
        return plan;
 }
 
+static struct io_plan io_never_called(struct io_conn *conn, void *arg)
+{
+       abort();
+}
+
+struct io_plan io_never(void)
+{
+       return io_always_(io_never_called, NULL);
+}
+
 int io_conn_fd(const struct io_conn *conn)
 {
        return conn->fd.fd;