io: io_always, and zero-length operations support.

[ccan] / ccan / io / io.c

diff --git a/ccan/io/io.c b/ccan/io/io.c
index 34b7cb0ce7ca6e739246a33b3a457aafb3e5a5b8..734cb3939636acbf0922362915c5c804bcc2cb97 100644 (file)
--- a/ccan/io/io.c
+++ b/ccan/io/io.c
@@ -8,12 +8,15 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <assert.h>
-#include <poll.h>
 #include <unistd.h>
 #include <fcntl.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;
@@ -90,6 +93,10 @@ int io_debug_io(int ret)
        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:
@@ -125,7 +132,7 @@ struct io_listener *io_new_listener_(int fd,
                                     void (*init)(int fd, void *arg),
                                     void *arg)
 {
-       struct io_listener *l = malloc(sizeof(*l));
+       struct io_listener *l = io_alloc.alloc(sizeof(*l));
 
        if (!l)
                return NULL;
@@ -135,7 +142,7 @@ struct io_listener *io_new_listener_(int fd,
        l->init = init;
        l->arg = arg;
        if (!add_listener(l)) {
-               free(l);
+               io_alloc.free(l);
                return NULL;
        }
        return l;
@@ -145,12 +152,12 @@ void io_close_listener(struct io_listener *l)
 {
        close(l->fd.fd);
        del_listener(l);
-       free(l);
+       io_alloc.free(l);
 }
 
 struct io_conn *io_new_conn_(int fd, struct io_plan plan)
 {
-       struct io_conn *conn = malloc(sizeof(*conn));
+       struct io_conn *conn = io_alloc.alloc(sizeof(*conn));
 
        io_plan_debug_again();
 
@@ -165,7 +172,7 @@ struct io_conn *io_new_conn_(int fd, struct io_plan plan)
        conn->duplex = NULL;
        conn->timeout = NULL;
        if (!add_conn(conn)) {
-               free(conn);
+               io_alloc.free(conn);
                return NULL;
        }
        return conn;
@@ -187,7 +194,7 @@ struct io_conn *io_duplex_(struct io_conn *old, struct io_plan plan)
 
        assert(!old->duplex);
 
-       conn = malloc(sizeof(*conn));
+       conn = io_alloc.alloc(sizeof(*conn));
        if (!conn)
                return NULL;
 
@@ -199,7 +206,7 @@ struct io_conn *io_duplex_(struct io_conn *old, struct io_plan plan)
        conn->finish_arg = NULL;
        conn->timeout = NULL;
        if (!add_duplex(conn)) {
-               free(conn);
+               io_alloc.free(conn);
                return NULL;
        }
        old->duplex = conn;
@@ -212,7 +219,7 @@ bool io_timeout_(struct io_conn *conn, struct timespec ts,
        assert(cb);
 
        if (!conn->timeout) {
-               conn->timeout = malloc(sizeof(*conn->timeout));
+               conn->timeout = io_alloc.alloc(sizeof(*conn->timeout));
                if (!conn->timeout)
                        return false;
        } else
@@ -224,6 +231,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)
 {
@@ -244,6 +271,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;
@@ -273,11 +304,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;
@@ -301,6 +337,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;
@@ -329,6 +369,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;
@@ -404,6 +448,11 @@ struct io_plan io_idle_(void)
        return plan;
 }
 
+bool io_is_idle(const struct io_conn *conn)
+{
+       return conn->plan.io == NULL;
+}
+
 void io_wake_(struct io_conn *conn, struct io_plan plan)
 
 {
@@ -422,6 +471,10 @@ void io_wake_(struct io_conn *conn, struct io_plan plan)
 
 void io_ready(struct io_conn *conn)
 {
+       /* Beware io_close_other! */
+       if (!conn->plan.next)
+               return;
+
        set_current(conn);
        switch (conn->plan.io(conn->fd.fd, &conn->plan)) {
        case -1: /* Failure means a new plan: close up. */
@@ -433,6 +486,10 @@ void io_ready(struct io_conn *conn)
        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);
        }
@@ -457,6 +514,12 @@ struct io_plan io_close_cb(struct io_conn *conn, void *arg)
        return io_close();
 }
 
+void io_close_other(struct io_conn *conn)
+{
+       conn->plan = io_close_();
+       backend_plan_changed(conn);
+}
+
 /* Exit the loop, returning this (non-NULL) arg. */
 struct io_plan io_break_(void *ret, struct io_plan plan)
 {
@@ -467,3 +530,17 @@ struct io_plan io_break_(void *ret, struct io_plan plan)
 
        return plan;
 }
+
+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))
+{
+       io_alloc.alloc = allocfn;
+       io_alloc.realloc = reallocfn;
+       io_alloc.free = freefn;
+}