ccan/io: remove IO_IDLE state.

[ccan] / ccan / io / io.c

diff --git a/ccan/io/io.c b/ccan/io/io.c
index fe9fed4fc2350fef5ea28a46f6a0c162f1c2078e..ef79e410217a8b76a4751112d8f0ac2e1c992475 100644 (file)
--- a/ccan/io/io.c
+++ b/ccan/io/io.c
@@ -13,9 +13,7 @@
 void *io_loop_return;
 
 struct io_listener *io_new_listener_(int fd,
-                                    struct io_plan (*start)(struct io_conn *,
-                                                            void *arg),
-                                    void (*finish)(struct io_conn *, void *),
+                                    void (*init)(int fd, void *arg),
                                     void *arg)
 {
        struct io_listener *l = malloc(sizeof(*l));
@@ -25,9 +23,8 @@ struct io_listener *io_new_listener_(int fd,
 
        l->fd.listener = true;
        l->fd.fd = fd;
-       l->next = start;
-       l->finish = finish;
-       l->conn_arg = arg;
+       l->init = init;
+       l->arg = arg;
        if (!add_listener(l)) {
                free(l);
                return NULL;
@@ -43,7 +40,7 @@ void io_close_listener(struct io_listener *l)
 }
 
 struct io_conn *io_new_conn_(int fd,
-                            struct io_plan (*start)(struct io_conn *, void *),
+                            struct io_plan plan,
                             void (*finish)(struct io_conn *, void *),
                             void *arg)
 {
@@ -54,11 +51,9 @@ struct io_conn *io_new_conn_(int fd,
 
        conn->fd.listener = false;
        conn->fd.fd = fd;
-       conn->plan.next = start;
+       conn->plan = plan;
        conn->finish = finish;
-       conn->finish_arg = conn->plan.next_arg = arg;
-       conn->plan.pollflag = 0;
-       conn->plan.state = IO_NEXT;
+       conn->finish_arg = arg;
        conn->duplex = NULL;
        conn->timeout = NULL;
        if (!add_conn(conn)) {
@@ -69,9 +64,9 @@ struct io_conn *io_new_conn_(int fd,
 }
 
 struct io_conn *io_duplex_(struct io_conn *old,
-                            struct io_plan (*start)(struct io_conn *, void *),
-                            void (*finish)(struct io_conn *, void *),
-                            void *arg)
+                          struct io_plan plan,
+                          void (*finish)(struct io_conn *, void *),
+                          void *arg)
 {
        struct io_conn *conn;
 
@@ -83,12 +78,10 @@ struct io_conn *io_duplex_(struct io_conn *old,
 
        conn->fd.listener = false;
        conn->fd.fd = old->fd.fd;
-       conn->plan.next = start;
-       conn->finish = finish;
-       conn->finish_arg = conn->plan.next_arg = arg;
-       conn->plan.pollflag = 0;
-       conn->plan.state = IO_NEXT;
+       conn->plan = plan;
        conn->duplex = old;
+       conn->finish = finish;
+       conn->finish_arg = arg;
        conn->timeout = NULL;
        if (!add_duplex(conn)) {
                free(conn);
@@ -129,7 +122,7 @@ static enum io_result do_write(struct io_conn *conn)
 }
 
 /* Queue some data to be written. */
-struct io_plan io_write_(struct io_conn *conn, const void *data, size_t len,
+struct io_plan io_write_(const void *data, size_t len,
                         struct io_plan (*cb)(struct io_conn *, void *),
                         void *arg)
 {
@@ -160,7 +153,7 @@ static enum io_result do_read(struct io_conn *conn)
 }
 
 /* Queue a request to read into a buffer. */
-struct io_plan io_read_(struct io_conn *conn, void *data, size_t len,
+struct io_plan io_read_(void *data, size_t len,
                        struct io_plan (*cb)(struct io_conn *, void *),
                        void *arg)
 {
@@ -187,7 +180,7 @@ static enum io_result do_read_partial(struct io_conn *conn)
 }
 
 /* Queue a partial request to read into a buffer. */
-struct io_plan io_read_partial_(struct io_conn *conn, void *data, size_t *len,
+struct io_plan io_read_partial_(void *data, size_t *len,
                                struct io_plan (*cb)(struct io_conn *, void *),
                                void *arg)
 {
@@ -215,8 +208,7 @@ static enum io_result do_write_partial(struct io_conn *conn)
 }
 
 /* Queue a partial write request. */
-struct io_plan io_write_partial_(struct io_conn *conn,
-                                const void *data, size_t *len,
+struct io_plan io_write_partial_(const void *data, size_t *len,
                                 struct io_plan (*cb)(struct io_conn*, void *),
                                 void *arg)
 {
@@ -233,28 +225,25 @@ struct io_plan io_write_partial_(struct io_conn *conn,
        return plan;
 }
 
-struct io_plan io_idle(struct io_conn *conn)
+struct io_plan io_idle(void)
 {
        struct io_plan plan;
 
        plan.pollflag = 0;
-       plan.state = IO_IDLE;
+       plan.state = IO_IO;
+       plan.io = NULL;
 
        return plan;
 }
 
-void io_wake_(struct io_conn *conn,
-             struct io_plan (*fn)(struct io_conn *, void *), void *arg)
+void io_wake(struct io_conn *conn, struct io_plan plan)
 
 {
        /* It might have finished, but we haven't called its finish() yet. */
        if (conn->plan.state == IO_FINISHED)
                return;
-       assert(conn->plan.state == IO_IDLE);
-       conn->plan.next = fn;
-       conn->plan.next_arg = arg;
-       conn->plan.pollflag = 0;
-       conn->plan.state = IO_NEXT;
+       assert(!conn->plan.io);
+       conn->plan = plan;
        backend_wakeup(conn);
 }
 
@@ -293,18 +282,9 @@ struct io_plan io_close(struct io_conn *conn, void *arg)
 }
 
 /* Exit the loop, returning this (non-NULL) arg. */
-struct io_plan io_break_(struct io_conn *conn, void *ret,
-                        struct io_plan (*fn)(struct io_conn *, void *),
-                        void *arg)
+struct io_plan io_break(void *ret, struct io_plan plan)
 {
-       struct io_plan plan;
-
        io_loop_return = ret;
 
-       plan.state = IO_NEXT;
-       plan.pollflag = 0;
-       plan.next = fn;
-       plan.next_arg = arg;
-
        return plan;
 }