1 /* Test of select() substitute.
2 Copyright (C) 2008-2022 Free Software Foundation, Inc.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* Written by Paolo Bonzini, 2008. */
18
19 #include <stdio.h>
20 #include <string.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
23 #include <arpa/inet.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <stdlib.h>
27 #include <stdbool.h>
28 #include <sys/ioctl.h>
29 #include <errno.h>
30
31 #include "macros.h"
32
33 #if defined _WIN32 && ! defined __CYGWIN__
34 # define WINDOWS_NATIVE
35 #endif
36
37 #ifdef HAVE_SYS_WAIT_H
38 # include <sys/wait.h>
39 #endif
40
41 #define TEST_PORT 12345
42
43
44 typedef int (*select_fn) (int, fd_set *, fd_set *, fd_set *, struct timeval *);
45
46
47 /* Minimal testing infrastructure. */
48
49 static int failures;
50
51 static void
52 failed (const char *reason)
53 {
54 if (++failures > 1)
55 printf (" ");
56 printf ("failed (%s)\n", reason);
57 }
58
59 static int
60 test (void (*fn) (select_fn), select_fn my_select, const char *msg)
61 {
62 failures = 0;
63 printf ("%s... ", msg);
64 fflush (stdout);
65 fn (my_select);
66
67 if (!failures)
68 printf ("passed\n");
69
70 return failures;
71 }
72
73
74 /* Funny socket code. */
75
76 static int
77 open_server_socket (void)
78 {
79 int s, x;
80 struct sockaddr_in ia;
81
82 s = socket (AF_INET, SOCK_STREAM, 0);
83
84 x = 1;
85 setsockopt (s, SOL_SOCKET, SO_REUSEPORT, &x, sizeof (x));
86
87 memset (&ia, 0, sizeof (ia));
88 ia.sin_family = AF_INET;
89 inet_pton (AF_INET, "127.0.0.1", &ia.sin_addr);
90 ia.sin_port = htons (TEST_PORT);
91 if (bind (s, (struct sockaddr *) &ia, sizeof (ia)) < 0)
92 {
93 perror ("bind");
94 exit (77);
95 }
96
97 if (listen (s, 1) < 0)
98 {
99 perror ("listen");
100 exit (77);
101 }
102
103 return s;
104 }
105
106 static int
107 connect_to_socket (bool blocking)
108 {
109 int s;
110 struct sockaddr_in ia;
111
112 s = socket (AF_INET, SOCK_STREAM, 0);
113
114 memset (&ia, 0, sizeof (ia));
115 ia.sin_family = AF_INET;
116 inet_pton (AF_INET, "127.0.0.1", &ia.sin_addr);
117 ia.sin_port = htons (TEST_PORT);
118
119 if (!blocking)
120 {
121 #ifdef WINDOWS_NATIVE
122 unsigned long iMode = 1;
123 ioctl (s, FIONBIO, (char *) &iMode);
124
125 #elif defined F_GETFL
126 int oldflags = fcntl (s, F_GETFL, NULL);
127
128 if (!(oldflags & O_NONBLOCK))
129 fcntl (s, F_SETFL, oldflags | O_NONBLOCK);
130 #endif
131 }
132
133 if (connect (s, (struct sockaddr *) &ia, sizeof (ia)) < 0
134 && (blocking || errno != EINPROGRESS))
135 {
136 perror ("connect");
137 exit (77);
138 }
139
140 return s;
141 }
142
143
144 /* A slightly more convenient interface to select(2).
145 Waits until a specific event occurs on a file descriptor FD.
146 EV is a bit mask of events to look for:
147 SEL_IN - input can be polled without blocking,
148 SEL_OUT - output can be provided without blocking,
149 SEL_EXC - an exception occurred,
150 A maximum wait time is specified by TIMEOUT.
151 *TIMEOUT = { 0, 0 } means to return immediately,
152 TIMEOUT = NULL means to wait indefinitely. */
153
154 enum { SEL_IN = 1, SEL_OUT = 2, SEL_EXC = 4 };
155
156 static int
157 do_select (int fd, int ev, struct timeval *timeout, select_fn my_select)
158 {
159 fd_set rfds, wfds, xfds;
160 int r, rev;
161
162 FD_ZERO (&rfds);
163 FD_ZERO (&wfds);
164 FD_ZERO (&xfds);
165 if (ev & SEL_IN)
166 FD_SET (fd, &rfds);
167 if (ev & SEL_OUT)
168 FD_SET (fd, &wfds);
169 if (ev & SEL_EXC)
170 FD_SET (fd, &xfds);
171 r = my_select (fd + 1, &rfds, &wfds, &xfds, timeout);
172 if (r < 0)
173 return r;
174
175 rev = 0;
176 if (FD_ISSET (fd, &rfds))
177 rev |= SEL_IN;
178 if (FD_ISSET (fd, &wfds))
179 rev |= SEL_OUT;
180 if (FD_ISSET (fd, &xfds))
181 rev |= SEL_EXC;
182 if (rev && r == 0)
183 failed ("select returned 0");
184 if (rev & ~ev)
185 failed ("select returned unrequested events");
186
187 return rev;
188 }
189
190 static int
191 do_select_nowait (int fd, int ev, select_fn my_select)
192 {
193 struct timeval tv0;
194 tv0.tv_sec = 0;
195 tv0.tv_usec = 0;
196 return do_select (fd, ev, &tv0, my_select);
197 }
198
199 static int
200 do_select_wait (int fd, int ev, select_fn my_select)
201 {
202 return do_select (fd, ev, NULL, my_select);
203 }
204
205
206 /* Test select(2) for TTYs. */
207
208 #ifdef INTERACTIVE
209 static void
210 test_tty (select_fn my_select)
211 {
212 if (do_select_nowait (0, SEL_IN, my_select) != 0)
213 failed ("can read");
214 if (do_select_nowait (0, SEL_OUT, my_select) == 0)
215 failed ("cannot write");
216
217 if (do_select_wait (0, SEL_IN, my_select) == 0)
218 failed ("return with infinite timeout");
219
220 getchar ();
221 if (do_select_nowait (0, SEL_IN, my_select) != 0)
222 failed ("can read after getc");
223 }
224 #endif
225
226
227 static int
228 do_select_bad_nfd_nowait (int nfd, select_fn my_select)
229 {
230 struct timeval tv0;
231 tv0.tv_sec = 0;
232 tv0.tv_usec = 0;
233 errno = 0;
234 return my_select (nfd, NULL, NULL, NULL, &tv0);
235 }
236
237 static void
238 test_bad_nfd (select_fn my_select)
239 {
240 if (do_select_bad_nfd_nowait (-1, my_select) != -1 || errno != EINVAL)
241 failed ("invalid errno after negative nfds");
242 /* Can't test FD_SETSIZE + 1 for EINVAL, since some systems allow
243 dynamically larger set size by redefining FD_SETSIZE anywhere up
244 to the actual maximum fd. */
245 #if 0
246 if (do_select_bad_nfd_nowait (FD_SETSIZE + 1, my_select) != -1
247 || errno != EINVAL)
248 failed ("invalid errno after bogus nfds");
249 #endif
250 }
251
252 /* Test select(2) on invalid file descriptors. */
253
254 static int
255 do_select_bad_fd (int fd, int ev, struct timeval *timeout, select_fn my_select)
256 {
257 fd_set rfds, wfds, xfds;
258
259 FD_ZERO (&rfds);
260 FD_ZERO (&wfds);
261 FD_ZERO (&xfds);
262 if (ev & SEL_IN)
263 FD_SET (fd, &rfds);
264 if (ev & SEL_OUT)
265 FD_SET (fd, &wfds);
266 if (ev & SEL_EXC)
267 FD_SET (fd, &xfds);
268 errno = 0;
269 return my_select (fd + 1, &rfds, &wfds, &xfds, timeout);
270 /* In this case, when fd is invalid, on some platforms, the bit for fd
271 is left alone in the fd_set, whereas on other platforms it is cleared.
272 So, don't check the bit for fd here. */
273 }
274
275 static int
276 do_select_bad_fd_nowait (int fd, int ev, select_fn my_select)
277 {
278 struct timeval tv0;
279 tv0.tv_sec = 0;
280 tv0.tv_usec = 0;
281 return do_select_bad_fd (fd, ev, &tv0, my_select);
282 }
283
284 static void
285 test_bad_fd (select_fn my_select)
286 {
287 /* This tests fails on OSF/1 and native Windows, even with fd = 16. */
288 #if !(defined __osf__ || defined WINDOWS_NATIVE)
289 int fd;
290
291 /* On Linux, Mac OS X, *BSD, values of fd like 99 or 399 are discarded
292 by the kernel early and therefore do *not* lead to EBADF, as required
293 by POSIX. */
294 # if defined __linux__ || (defined __APPLE__ && defined __MACH__) || (defined __FreeBSD__ || defined __DragonFly__) || defined __OpenBSD__ || defined __NetBSD__
295 fd = 14;
296 # else
297 fd = 99;
298 # endif
299 /* Even on the best POSIX compliant platforms, values of fd >= FD_SETSIZE
300 require an nfds argument that is > FD_SETSIZE and thus may lead to EINVAL,
301 not EBADF. */
302 if (fd >= FD_SETSIZE)
303 fd = FD_SETSIZE - 1;
304 close (fd);
305
306 if (do_select_bad_fd_nowait (fd, SEL_IN, my_select) == 0 || errno != EBADF)
307 failed ("invalid fd among rfds");
308 if (do_select_bad_fd_nowait (fd, SEL_OUT, my_select) == 0 || errno != EBADF)
309 failed ("invalid fd among wfds");
310 if (do_select_bad_fd_nowait (fd, SEL_EXC, my_select) == 0 || errno != EBADF)
311 failed ("invalid fd among xfds");
312 #endif
313 }
314
315
316 /* Test select(2) for unconnected nonblocking sockets. */
317
318 static void
319 test_connect_first (select_fn my_select)
320 {
321 int s = open_server_socket ();
322 struct sockaddr_in ia;
323 socklen_t addrlen;
324
325 int c1, c2;
326
327 if (do_select_nowait (s, SEL_IN | SEL_EXC, my_select) != 0)
328 failed ("can read, socket not connected");
329
330 c1 = connect_to_socket (false);
331
332 if (do_select_wait (s, SEL_IN | SEL_EXC, my_select) != SEL_IN)
333 failed ("expecting readability on passive socket");
334 if (do_select_nowait (s, SEL_IN | SEL_EXC, my_select) != SEL_IN)
335 failed ("expecting readability on passive socket");
336
337 addrlen = sizeof (ia);
338 c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
339 ASSERT (close (s) == 0);
340 ASSERT (close (c1) == 0);
341 ASSERT (close (c2) == 0);
342 }
343
344
345 /* Test select(2) for unconnected blocking sockets. */
346
347 static void
348 test_accept_first (select_fn my_select)
349 {
350 #ifndef WINDOWS_NATIVE
351 int s = open_server_socket ();
352 struct sockaddr_in ia;
353 socklen_t addrlen;
354 char buf[3];
355 int c, pid;
356
357 pid = fork ();
358 if (pid < 0)
359 return;
360
361 if (pid == 0)
362 {
363 addrlen = sizeof (ia);
364 c = accept (s, (struct sockaddr *) &ia, &addrlen);
365 ASSERT (close (s) == 0);
366 ASSERT (write (c, "foo", 3) == 3);
367 ASSERT (read (c, buf, 3) == 3);
368 shutdown (c, SHUT_RD);
369 ASSERT (close (c) == 0);
370 exit (0);
371 }
372 else
373 {
374 ASSERT (close (s) == 0);
375 c = connect_to_socket (true);
376 if (do_select_nowait (c, SEL_OUT, my_select) != SEL_OUT)
377 failed ("cannot write after blocking connect");
378 ASSERT (write (c, "foo", 3) == 3);
379 wait (&pid);
380 if (do_select_wait (c, SEL_IN, my_select) != SEL_IN)
381 failed ("cannot read data left in the socket by closed process");
382 ASSERT (read (c, buf, 3) == 3);
383 ASSERT (write (c, "foo", 3) == 3);
384 (void) close (c); /* may fail with errno = ECONNRESET */
385 }
386 #endif
387 }
388
389
390 /* Common code for pipes and connected sockets. */
391
392 static void
393 test_pair (int rd, int wd, select_fn my_select)
394 {
395 char buf[3];
396 if (do_select_wait (wd, SEL_IN | SEL_OUT | SEL_EXC, my_select) != SEL_OUT)
397 failed ("expecting writability before writing");
398 if (do_select_nowait (wd, SEL_IN | SEL_OUT | SEL_EXC, my_select) != SEL_OUT)
399 failed ("expecting writability before writing");
400
401 ASSERT (write (wd, "foo", 3) == 3);
402 if (do_select_wait (rd, SEL_IN, my_select) != SEL_IN)
403 failed ("expecting readability after writing");
404 if (do_select_nowait (rd, SEL_IN, my_select) != SEL_IN)
405 failed ("expecting readability after writing");
406
407 ASSERT (read (rd, buf, 3) == 3);
408 }
409
410
411 /* Test select(2) on connected sockets. */
412
413 static void
414 test_socket_pair (select_fn my_select)
415 {
416 struct sockaddr_in ia;
417
418 socklen_t addrlen = sizeof (ia);
419 int s = open_server_socket ();
420 int c1 = connect_to_socket (false);
421 int c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
422
423 ASSERT (close (s) == 0);
424
425 test_pair (c1, c2, my_select);
426 ASSERT (close (c1) == 0);
427 ASSERT (write (c2, "foo", 3) == 3);
428 (void) close (c2); /* may fail with errno = ECONNRESET */
429 }
430
431
432 /* Test select(2) on pipes. */
433
434 static void
435 test_pipe (select_fn my_select)
436 {
437 int fd[2];
438
439 ASSERT (pipe (fd) == 0);
440 test_pair (fd[0], fd[1], my_select);
441 ASSERT (close (fd[0]) == 0);
442 ASSERT (close (fd[1]) == 0);
443 }
444
445
446 /* Do them all. */
447
448 static int
449 test_function (select_fn my_select)
450 {
451 int result = 0;
452
453 #ifdef INTERACTIVE
454 printf ("Please press Enter\n");
455 test (test_tty, "TTY", my_select);
456 #endif
457
458 result += test (test_bad_nfd, my_select, "Invalid nfd test");
459 result += test (test_bad_fd, my_select, "Invalid fd test");
460 result += test (test_connect_first, my_select, "Unconnected socket test");
461 result += test (test_socket_pair, my_select, "Connected sockets test");
462 result += test (test_accept_first, my_select, "General socket test with fork");
463 result += test (test_pipe, my_select, "Pipe test");
464
465 return result;
466 }