tests/test-poll.c

   1 /* Test of poll() function.
   2    Copyright (C) 2008-2025 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, or (at your option)
   7    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.  */
  18
  19 #include <config.h>
  20
  21 /* Specification.  */
  22 #include <poll.h>
  23
  24 #include "signature.h"
  25 SIGNATURE_CHECK (poll, int, (struct pollfd[], nfds_t, int));
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <sys/socket.h>
  30 #include <netinet/in.h>
  31 #include <arpa/inet.h>
  32 #include <fcntl.h>
  33 #include <stdlib.h>
  34 #include <sys/ioctl.h>
  35 #include <errno.h>
  36
  37 #include "macros.h"
  38
  39 #if defined _WIN32 && ! defined __CYGWIN__
  40 # define WINDOWS_NATIVE
  41 #endif
  42
  43 #ifdef WINDOWS_NATIVE
  44 #include <io.h>
  45 #define pipe(x) _pipe(x, 256, O_BINARY)
  46 #endif
  47 #ifdef HAVE_UNISTD_H
  48 #include <unistd.h>
  49 #endif
  50 #ifdef HAVE_SYS_WAIT_H
  51 #include <sys/wait.h>
  52 #endif
  53
  54 #define TEST_PORT       12345
  55
  56
  57 /* Minimal testing infrastructure.  */
  58
  59 static int failures;
  60
  61 static void
  62 failed (const char *reason)
  63 {
  64   if (++failures > 1)
  65     printf ("  ");
  66   printf ("failed (%s)\n", reason);
  67 }
  68
  69 static int
  70 test (void (*fn) (void), const char *msg)
  71 {
  72   failures = 0;
  73   printf ("%s... ", msg);
  74   fflush (stdout);
  75   fn ();
  76
  77   if (!failures)
  78     printf ("passed\n");
  79
  80   return failures;
  81 }
  82
  83
  84 /* Funny socket code.  */
  85
  86 static int
  87 open_server_socket ()
  88 {
  89   int s, x;
  90   struct sockaddr_in ia;
  91
  92   s = socket (AF_INET, SOCK_STREAM, 0);
  93
  94   x = 1;
  95   setsockopt (s, SOL_SOCKET, SO_REUSEPORT, &x, sizeof (x));
  96
  97   memset (&ia, 0, sizeof (ia));
  98   ia.sin_family = AF_INET;
  99   inet_pton (AF_INET, "127.0.0.1", &ia.sin_addr);
 100   ia.sin_port = htons (TEST_PORT);
 101   if (bind (s, (struct sockaddr *) &ia, sizeof (ia)) < 0)
 102     {
 103       perror ("bind");
 104       exit (77);
 105     }
 106
 107   if (listen (s, 1) < 0)
 108     {
 109       perror ("listen");
 110       exit (77);
 111     }
 112
 113   return s;
 114 }
 115
 116 static int
 117 connect_to_socket (int blocking)
 118 {
 119   int s;
 120   struct sockaddr_in ia;
 121
 122   s = socket (AF_INET, SOCK_STREAM, 0);
 123
 124   memset (&ia, 0, sizeof (ia));
 125   ia.sin_family = AF_INET;
 126   inet_pton (AF_INET, "127.0.0.1", &ia.sin_addr);
 127   ia.sin_port = htons (TEST_PORT);
 128
 129   if (!blocking)
 130     {
 131 #ifdef WINDOWS_NATIVE
 132       unsigned long iMode = 1;
 133       ioctl (s, FIONBIO, (char *) &iMode);
 134
 135 #elif defined F_GETFL
 136       int oldflags = fcntl (s, F_GETFL, NULL);
 137
 138       if (!(oldflags & O_NONBLOCK))
 139         fcntl (s, F_SETFL, oldflags | O_NONBLOCK);
 140 #endif
 141     }
 142
 143   if (connect (s, (struct sockaddr *) &ia, sizeof (ia)) < 0
 144       && (blocking || errno != EINPROGRESS))
 145     {
 146       perror ("connect");
 147       exit (77);
 148     }
 149
 150   return s;
 151 }
 152
 153
 154 /* A slightly more convenient interface to poll(2).  */
 155
 156 static int
 157 poll1 (int fd, int ev, int time)
 158 {
 159   struct pollfd pfd;
 160   int r;
 161
 162   pfd.fd = fd;
 163   pfd.events = ev;
 164   pfd.revents = -1;
 165   r = poll (&pfd, 1, time);
 166   if (r < 0)
 167     return r;
 168
 169   if (pfd.revents & ~(POLLHUP | POLLERR | POLLNVAL | ev))
 170     failed ("invalid flag combination (unrequested events)");
 171
 172   return pfd.revents;
 173 }
 174
 175 static int
 176 poll1_nowait (int fd, int ev)
 177 {
 178   return poll1 (fd, ev, 0);
 179 }
 180
 181 static int
 182 poll1_wait (int fd, int ev)
 183 {
 184   return poll1 (fd, ev, -1);
 185 }
 186
 187
 188 /* Test poll(2) for TTYs.  */
 189
 190 #ifdef INTERACTIVE
 191 static void
 192 test_tty (void)
 193 {
 194   if (poll1_nowait (0, POLLIN | POLLRDNORM) != 0)
 195     failed ("can read");
 196   if (poll1_nowait (0, POLLOUT) == 0)
 197     failed ("cannot write");
 198
 199   if (poll1_wait (0, POLLIN | POLLRDNORM) == 0)
 200     failed ("return with infinite timeout");
 201
 202   getchar ();
 203   if (poll1_nowait (0, POLLIN | POLLRDNORM) != 0)
 204     failed ("can read after getc");
 205 }
 206 #endif
 207
 208
 209 /* Test poll(2) for unconnected nonblocking sockets.  */
 210
 211 static void
 212 test_connect_first (void)
 213 {
 214   int s = open_server_socket ();
 215   struct sockaddr_in ia;
 216   socklen_t addrlen;
 217
 218   int c1, c2;
 219
 220   if (poll1_nowait (s, POLLIN | POLLRDNORM | POLLRDBAND) != 0)
 221     failed ("can read, socket not connected");
 222
 223   c1 = connect_to_socket (false);
 224
 225   if (poll1_wait (s, POLLIN | POLLRDNORM | POLLRDBAND) != (POLLIN | POLLRDNORM))
 226     failed ("expecting POLLIN | POLLRDNORM on passive socket");
 227   if (poll1_nowait (s, POLLIN | POLLRDBAND) != POLLIN)
 228     failed ("expecting POLLIN on passive socket");
 229   if (poll1_nowait (s, POLLRDNORM | POLLRDBAND) != POLLRDNORM)
 230     failed ("expecting POLLRDNORM on passive socket");
 231
 232   addrlen = sizeof (ia);
 233   c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
 234   close (s);
 235   close (c1);
 236   close (c2);
 237 }
 238
 239
 240 /* Test poll(2) for unconnected blocking sockets.  */
 241
 242 static void
 243 test_accept_first (void)
 244 {
 245 #ifndef WINDOWS_NATIVE
 246   int s = open_server_socket ();
 247   struct sockaddr_in ia;
 248   socklen_t addrlen;
 249   char buf[3];
 250   int c, pid;
 251
 252   pid = fork ();
 253   if (pid < 0)
 254     return;
 255
 256   if (pid == 0)
 257     {
 258       addrlen = sizeof (ia);
 259       c = accept (s, (struct sockaddr *) &ia, &addrlen);
 260       ASSERT (c >= 0);
 261       close (s);
 262       ASSERT (write (c, "foo", 3) == 3);
 263       ASSERT (read (c, buf, 3) == 3);
 264       shutdown (c, SHUT_RD);
 265       close (c);
 266       exit (0);
 267     }
 268   else
 269     {
 270       close (s);
 271       c = connect_to_socket (true);
 272       ASSERT (c >= 0);
 273       if (poll1_nowait (c, POLLOUT | POLLWRNORM | POLLRDBAND)
 274           != (POLLOUT | POLLWRNORM))
 275         failed ("cannot write after blocking connect");
 276       ASSERT (write (c, "foo", 3) == 3);
 277       wait (&pid);
 278       if (poll1_wait (c, POLLIN) != POLLIN)
 279         failed ("cannot read data left in the socket by closed process");
 280       ASSERT (read (c, buf, 3) == 3);
 281       ASSERT (write (c, "foo", 3) == 3);
 282       int revents = poll1_wait (c, POLLIN | POLLOUT);
 283 # ifdef __linux__
 284       if ((revents & (POLLHUP | POLLERR)) == 0)
 285         failed ("expecting POLLHUP after shutdown");
 286 # else
 287       (void) revents;
 288 # endif
 289       close (c);
 290     }
 291 #endif
 292 }
 293
 294
 295 /* Common code for pipes and connected sockets.  */
 296
 297 static void
 298 test_pair (int rd, int wd)
 299 {
 300   char buf[3];
 301   if (poll1_wait (wd, POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM | POLLRDBAND)
 302       != (POLLOUT | POLLWRNORM))
 303     failed ("expecting POLLOUT | POLLWRNORM before writing");
 304   if (poll1_nowait (wd, POLLIN | POLLRDNORM | POLLOUT | POLLRDBAND) != POLLOUT)
 305     failed ("expecting POLLOUT before writing");
 306   if (poll1_nowait (wd, POLLIN | POLLRDNORM | POLLWRNORM | POLLRDBAND)
 307       != POLLWRNORM)
 308     failed ("expecting POLLWRNORM before writing");
 309
 310   ASSERT (write (wd, "foo", 3) == 3);
 311   if (poll1_wait (rd, POLLIN | POLLRDNORM) != (POLLIN | POLLRDNORM))
 312     failed ("expecting POLLIN | POLLRDNORM after writing");
 313   if (poll1_nowait (rd, POLLIN) != POLLIN)
 314     failed ("expecting POLLIN after writing");
 315   if (poll1_nowait (rd, POLLRDNORM) != POLLRDNORM)
 316     failed ("expecting POLLRDNORM after writing");
 317
 318   ASSERT (read (rd, buf, 3) == 3);
 319 }
 320
 321
 322 /* Test poll(2) on connected sockets.  */
 323
 324 static void
 325 test_socket_pair (void)
 326 {
 327   struct sockaddr_in ia;
 328
 329   socklen_t addrlen = sizeof (ia);
 330   int s = open_server_socket ();
 331   int c1 = connect_to_socket (false);
 332   int c2 = accept (s, (struct sockaddr *) &ia, &addrlen);
 333   ASSERT (s >= 0);
 334   ASSERT (c1 >= 0);
 335   ASSERT (c2 >= 0);
 336
 337   close (s);
 338
 339   test_pair (c1, c2);
 340   close (c1);
 341   ASSERT (write (c2, "foo", 3) == 3);
 342   int revents = poll1_nowait (c2, POLLIN | POLLOUT);
 343 #ifdef __linux__
 344   if ((revents & (POLLHUP | POLLERR)) == 0)
 345     failed ("expecting POLLHUP after shutdown");
 346 #else
 347   (void) revents;
 348 #endif
 349
 350   close (c2);
 351 }
 352
 353
 354 /* Test poll(2) on pipes.  */
 355
 356 static void
 357 test_pipe (void)
 358 {
 359   int fd[2];
 360
 361   ASSERT (pipe (fd) >= 0);
 362   test_pair (fd[0], fd[1]);
 363   close (fd[0]);
 364   int revents = poll1_wait (fd[1], POLLIN | POLLOUT);
 365 #if !(defined _AIX || defined __CYGWIN__ || (defined _WIN32 && !defined __CYGWIN__))
 366   if ((revents & (POLLHUP | POLLERR)) == 0)
 367     failed ("expecting POLLHUP after shutdown");
 368 #else
 369   (void) revents;
 370 #endif
 371
 372   close (fd[1]);
 373 }
 374
 375
 376 /* Do them all.  */
 377
 378 int
 379 main ()
 380 {
 381   int result;
 382
 383 #ifdef INTERACTIVE
 384   printf ("Please press Enter\n");
 385   test (test_tty, "TTY");
 386 #endif
 387
 388   result = test (test_connect_first, "Unconnected socket test");
 389   result += test (test_socket_pair, "Connected sockets test");
 390   result += test (test_accept_first, "General socket test with fork");
 391   result += test (test_pipe, "Pipe test");
 392
 393   return (result ? result : test_exit_status);
 394 }