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