ccan/io: new module.
[ccan] / ccan / io / io.c
1 /* Licensed under BSD-MIT - see LICENSE file for details */
2 #include "io.h"
3 #include "backend.h"
4 #include <sys/types.h>
5 #include <sys/socket.h>
6 #include <netdb.h>
7 #include <string.h>
8 #include <errno.h>
9 #include <stdlib.h>
10 #include <assert.h>
11
12 void *io_loop_return;
13
14 struct io_listener *io_new_listener_(int fd,
15                                      struct io_op *(*start)(struct io_conn *,
16                                                             void *arg),
17                                      void (*finish)(struct io_conn *, void *),
18                                      void *arg)
19 {
20         struct io_listener *l = malloc(sizeof(*l));
21
22         if (!l)
23                 return NULL;
24
25         l->fd.listener = true;
26         l->fd.fd = fd;
27         l->fd.next = start;
28         l->fd.finish = finish;
29         l->fd.finish_arg = l->fd.next_arg = arg;
30         if (!add_listener(l)) {
31                 free(l);
32                 return NULL;
33         }
34         return l;
35 }
36
37 void io_close_listener(struct io_listener *l)
38 {
39         close(l->fd.fd);
40         del_listener(l);
41         free(l);
42 }
43
44 struct io_conn *io_new_conn_(int fd,
45                              struct io_op *(*start)(struct io_conn *, void *),
46                              void (*finish)(struct io_conn *, void *),
47                              void *arg)
48 {
49         struct io_conn *conn = malloc(sizeof(*conn));
50
51         if (!conn)
52                 return NULL;
53
54         conn->fd.listener = false;
55         conn->fd.fd = fd;
56         conn->fd.next = start;
57         conn->fd.finish = finish;
58         conn->fd.finish_arg = conn->fd.next_arg = arg;
59         conn->state = NEXT;
60         if (!add_conn(conn)) {
61                 free(conn);
62                 return NULL;
63         }
64         return conn;
65 }
66
67 /* Convenient token which only we can produce. */
68 static inline struct io_next *to_ionext(struct io_conn *conn)
69 {
70         return (struct io_next *)conn;
71 }
72
73 static inline struct io_op *to_ioop(enum io_state state)
74 {
75         return (struct io_op *)(long)state;
76 }
77
78 static inline struct io_conn *from_ionext(struct io_next *next)
79 {
80         return (struct io_conn *)next;
81 }
82
83 struct io_next *io_next_(struct io_conn *conn,
84                          struct io_op *(*next)(struct io_conn *, void *),
85                          void *arg)
86 {
87         conn->fd.next = next;
88         conn->fd.next_arg = arg;
89
90         return to_ionext(conn);
91 }
92
93 /* Queue some data to be written. */
94 struct io_op *io_write(const void *data, size_t len, struct io_next *next)
95 {
96         struct io_conn *conn = from_ionext(next);
97         conn->u.write.buf = data;
98         conn->u.write.len = len;
99         return to_ioop(WRITE);
100 }
101
102 /* Queue a request to read into a buffer. */
103 struct io_op *io_read(void *data, size_t len, struct io_next *next)
104 {
105         struct io_conn *conn = from_ionext(next);
106         conn->u.read.buf = data;
107         conn->u.read.len = len;
108         return to_ioop(READ);
109 }
110
111 /* Queue a partial request to read into a buffer. */
112 struct io_op *io_read_partial(void *data, size_t *len, struct io_next *next)
113 {
114         struct io_conn *conn = from_ionext(next);
115         conn->u.readpart.buf = data;
116         conn->u.readpart.lenp = len;
117         return to_ioop(READPART);
118 }
119
120 /* Queue a partial write request. */
121 struct io_op *io_write_partial(const void *data, size_t *len, struct io_next *next)
122 {
123         struct io_conn *conn = from_ionext(next);
124         conn->u.writepart.buf = data;
125         conn->u.writepart.lenp = len;
126         return to_ioop(WRITEPART);
127 }
128
129 struct io_op *io_idle(struct io_conn *conn)
130 {
131         return to_ioop(IDLE);
132 }
133
134 void io_wake_(struct io_conn *conn,
135               struct io_op *(*next)(struct io_conn *, void *), void *arg)
136
137 {
138         /* It might have finished, but we haven't called its finish() yet. */
139         if (conn->state == FINISHED)
140                 return;
141         assert(conn->state == IDLE);
142         conn->fd.next = next;
143         conn->fd.next_arg = arg;
144         backend_set_state(conn, to_ioop(NEXT));
145 }
146
147 static struct io_op *do_next(struct io_conn *conn)
148 {
149         return conn->fd.next(conn, conn->fd.next_arg);
150 }
151
152 struct io_op *do_writeable(struct io_conn *conn)
153 {
154         ssize_t ret;
155         bool finished;
156
157         switch (conn->state) {
158         case WRITE:
159                 ret = write(conn->fd.fd, conn->u.write.buf, conn->u.write.len);
160                 if (ret < 0)
161                         return io_close(conn, NULL);
162                 conn->u.write.buf += ret;
163                 conn->u.write.len -= ret;
164                 finished = (conn->u.write.len == 0);
165                 break;
166         case WRITEPART:
167                 ret = write(conn->fd.fd, conn->u.writepart.buf,
168                             *conn->u.writepart.lenp);
169                 if (ret < 0)
170                         return io_close(conn, NULL);
171                 *conn->u.writepart.lenp = ret;
172                 finished = true;
173                 break;
174         default:
175                 /* Shouldn't happen. */
176                 abort();
177         }
178
179         if (finished)
180                 return do_next(conn);
181         return to_ioop(conn->state);
182 }
183
184 struct io_op *do_readable(struct io_conn *conn)
185 {
186         ssize_t ret;
187         bool finished;
188
189         switch (conn->state) {
190         case READ:
191                 ret = read(conn->fd.fd, conn->u.read.buf, conn->u.read.len);
192                 if (ret <= 0)
193                         return io_close(conn, NULL);
194                 conn->u.read.buf += ret;
195                 conn->u.read.len -= ret;
196                 finished = (conn->u.read.len == 0);
197                 break;
198         case READPART:
199                 ret = read(conn->fd.fd, conn->u.readpart.buf,
200                             *conn->u.readpart.lenp);
201                 if (ret <= 0)
202                         return io_close(conn, NULL);
203                 *conn->u.readpart.lenp = ret;
204                 finished = true;
205                 break;
206         default:
207                 /* Shouldn't happen. */
208                 abort();
209         }
210
211         if (finished)
212                 return do_next(conn);
213         return to_ioop(conn->state);
214 }
215
216 /* Useful next functions. */
217 /* Close the connection, we're done. */
218 struct io_op *io_close(struct io_conn *conn, void *arg)
219 {
220         return to_ioop(FINISHED);
221 }
222
223 /* Exit the loop, returning this (non-NULL) arg. */
224 struct io_op *io_break(void *arg, struct io_next *next)
225 {
226         io_loop_return = arg;
227
228         return to_ioop(NEXT);
229 }