ccan/io: rewrite.
[ccan] / ccan / io / test / run-15-timeout.c
1 #include <ccan/io/io.h>
2 /* Include the C files directly. */
3 #include <ccan/io/poll.c>
4 #include <ccan/io/io.c>
5 #include <ccan/tap/tap.h>
6 #include <sys/wait.h>
7 #include <stdio.h>
8 #include <unistd.h>
9
10 #if 0
11 #ifndef PORT
12 #define PORT "65015"
13 #endif
14
15 struct data {
16         int state;
17         int timeout_usec;
18         bool timed_out;
19         char buf[4];
20 };
21
22
23 static struct io_plan no_timeout(struct io_conn *conn, struct data *d)
24 {
25         ok1(d->state == 1);
26         d->state++;
27         return io_close();
28 }
29
30 static struct io_plan timeout(struct io_conn *conn, struct data *d)
31 {
32         ok1(d->state == 1);
33         d->state++;
34         d->timed_out = true;
35         return io_close();
36 }
37
38 static void finish_ok(struct io_conn *conn, struct data *d)
39 {
40         ok1(d->state == 2);
41         d->state++;
42         io_break(d);
43 }
44
45 static void init_conn(int fd, struct data *d)
46 {
47         struct io_conn *conn;
48
49         ok1(d->state == 0);
50         d->state++;
51
52         conn = io_new_conn(fd, io_read(d->buf, sizeof(d->buf), no_timeout, d));
53         io_set_finish(conn, finish_ok, d);
54         io_timeout(conn, time_from_usec(d->timeout_usec), timeout, d);
55 }
56
57 static int make_listen_fd(const char *port, struct addrinfo **info)
58 {
59         int fd, on = 1;
60         struct addrinfo *addrinfo, hints;
61
62         memset(&hints, 0, sizeof(hints));
63         hints.ai_family = AF_UNSPEC;
64         hints.ai_socktype = SOCK_STREAM;
65         hints.ai_flags = AI_PASSIVE;
66         hints.ai_protocol = 0;
67
68         if (getaddrinfo(NULL, port, &hints, &addrinfo) != 0)
69                 return -1;
70
71         fd = socket(addrinfo->ai_family, addrinfo->ai_socktype,
72                     addrinfo->ai_protocol);
73         if (fd < 0)
74                 return -1;
75
76         setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
77         if (bind(fd, addrinfo->ai_addr, addrinfo->ai_addrlen) != 0) {
78                 close(fd);
79                 return -1;
80         }
81         if (listen(fd, 1) != 0) {
82                 close(fd);
83                 return -1;
84         }
85         *info = addrinfo;
86         return fd;
87 }
88
89 int main(void)
90 {
91         struct data *d = malloc(sizeof(*d));
92         struct addrinfo *addrinfo;
93         struct io_listener *l;
94         int fd, status;
95
96         /* This is how many tests you plan to run */
97         plan_tests(20);
98         d->state = 0;
99         d->timed_out = false;
100         d->timeout_usec = 100000;
101         fd = make_listen_fd(PORT, &addrinfo);
102         ok1(fd >= 0);
103         l = io_new_listener(fd, init_conn, d);
104         ok1(l);
105         fflush(stdout);
106
107         if (!fork()) {
108                 int i;
109
110                 io_close_listener(l);
111                 fd = socket(addrinfo->ai_family, addrinfo->ai_socktype,
112                             addrinfo->ai_protocol);
113                 if (fd < 0)
114                         exit(1);
115                 if (connect(fd, addrinfo->ai_addr, addrinfo->ai_addrlen) != 0)
116                         exit(2);
117                 signal(SIGPIPE, SIG_IGN);
118                 usleep(500000);
119                 for (i = 0; i < strlen("hellothere"); i++) {
120                         if (write(fd, "hellothere" + i, 1) != 1)
121                                 break;
122                 }
123                 close(fd);
124                 freeaddrinfo(addrinfo);
125                 free(d);
126                 exit(i);
127         }
128         ok1(io_loop() == d);
129         ok1(d->state == 3);
130         ok1(d->timed_out == true);
131         ok1(wait(&status));
132         ok1(WIFEXITED(status));
133         ok1(WEXITSTATUS(status) < sizeof(d->buf));
134
135         /* This one shouldn't time out. */
136         d->state = 0;
137         d->timed_out = false;
138         d->timeout_usec = 500000;
139         fflush(stdout);
140
141         if (!fork()) {
142                 int i;
143
144                 io_close_listener(l);
145                 fd = socket(addrinfo->ai_family, addrinfo->ai_socktype,
146                             addrinfo->ai_protocol);
147                 if (fd < 0)
148                         exit(1);
149                 if (connect(fd, addrinfo->ai_addr, addrinfo->ai_addrlen) != 0)
150                         exit(2);
151                 signal(SIGPIPE, SIG_IGN);
152                 usleep(100000);
153                 for (i = 0; i < strlen("hellothere"); i++) {
154                         if (write(fd, "hellothere" + i, 1) != 1)
155                                 break;
156                 }
157                 close(fd);
158                 freeaddrinfo(addrinfo);
159                 free(d);
160                 exit(i);
161         }
162         ok1(io_loop() == d);
163         ok1(d->state == 3);
164         ok1(d->timed_out == false);
165         ok1(wait(&status));
166         ok1(WIFEXITED(status));
167         ok1(WEXITSTATUS(status) >= sizeof(d->buf));
168
169         io_close_listener(l);
170         freeaddrinfo(addrinfo);
171         free(d);
172
173         /* This exits depending on whether all tests passed */
174         return exit_status();
175 }
176 #else
177 int main(void)
178 {
179         return 0;
180 }
181 #endif