gl/tests/test-select.h

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