commit cf0bd2f73bd65beab613865bba567d7787836888

Author: Florian Weimer <fweimer@redhat.com>

Date:   Tue Feb 28 15:28:45 2017 +0100

    sunrpc: Improvements for UDP client timeout handling [BZ #20257]

    This commit fixes various aspects in the UDP client timeout handling.

    Timeouts are now applied in a more consistent fashion.  Discarded UDP

    packets no longer prevent the timeout from happening at all.

Index: b/inet/deadline.c

===================================================================

--- /dev/null

+++ b/inet/deadline.c

@@ -0,0 +1,122 @@

+/* Computing deadlines for timeouts.

+   Copyright (C) 2017 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#include <net-internal.h>

+

+#include <assert.h>

+#include <limits.h>

+#include <stdio.h>

+#include <stdint.h>

+#include <time.h>

+

+struct deadline_current_time internal_function

+__deadline_current_time (void)

+{

+  struct deadline_current_time result;

+  if (__clock_gettime (CLOCK_MONOTONIC, &result.current) != 0)

+    {

+      struct timeval current_tv;

+      if (__gettimeofday (&current_tv, NULL) == 0)

+        __libc_fatal ("Fatal error: gettimeofday system call failed\n");

+      result.current.tv_sec = current_tv.tv_sec;

+      result.current.tv_nsec = current_tv.tv_usec * 1000;

+    }

+  assert (result.current.tv_sec >= 0);

+  return result;

+}

+

+/* A special deadline value for which __deadline_is_infinite is

+   true.  */

+static inline struct deadline

+infinite_deadline (void)

+{

+  return (struct deadline) { { -1, -1 } };

+}

+

+struct deadline internal_function

+__deadline_from_timeval (struct deadline_current_time current,

+                         struct timeval tv)

+{

+  assert (__is_timeval_valid_timeout (tv));

+

+  /* Compute second-based deadline.  Perform the addition in

+     uintmax_t, which is unsigned, to simply overflow detection.  */

+  uintmax_t sec = current.current.tv_sec;

+  sec += tv.tv_sec;

+  if (sec < (uintmax_t) tv.tv_sec)

+    return infinite_deadline ();

+

+  /* Compute nanosecond deadline.  */

+  int nsec = current.current.tv_nsec + tv.tv_usec * 1000;

+  if (nsec >= 1000 * 1000 * 1000)

+    {

+      /* Carry nanosecond overflow to seconds.  */

+      nsec -= 1000 * 1000 * 1000;

+      if (sec + 1 < sec)

+        return infinite_deadline ();

+      ++sec;

+    }

+  /* This uses a GCC extension, otherwise these casts for detecting

+     overflow would not be defined.  */

+  if ((time_t) sec < 0 || sec != (uintmax_t) (time_t) sec)

+    return infinite_deadline ();

+

+  return (struct deadline) { { sec, nsec } };

+}

+

+int internal_function

+__deadline_to_ms (struct deadline_current_time current,

+                  struct deadline deadline)

+{

+  if (__deadline_is_infinite (deadline))

+    return INT_MAX;

+

+  if (current.current.tv_sec > deadline.absolute.tv_sec

+      || (current.current.tv_sec == deadline.absolute.tv_sec

+          && current.current.tv_nsec >= deadline.absolute.tv_nsec))

+    return 0;

+  time_t sec = deadline.absolute.tv_sec - current.current.tv_sec;

+  if (sec >= INT_MAX)

+    /* This value will overflow below.  */

+    return INT_MAX;

+  int nsec = deadline.absolute.tv_nsec - current.current.tv_nsec;

+  if (nsec < 0)

+    {

+      /* Borrow from the seconds field.  */

+      assert (sec > 0);

+      --sec;

+      nsec += 1000 * 1000 * 1000;

+    }

+

+  /* Prepare for rounding up to milliseconds.  */

+  nsec += 999999;

+  if (nsec > 1000 * 1000 * 1000)

+    {

+      assert (sec < INT_MAX);

+      ++sec;

+      nsec -= 1000 * 1000 * 1000;

+    }

+

+  unsigned int msec = nsec / (1000 * 1000);

+  if (sec > INT_MAX / 1000)

+    return INT_MAX;

+  msec += sec * 1000;

+  if (msec > INT_MAX)

+    return INT_MAX;

+  return msec;

+}

Index: b/inet/tst-deadline.c

===================================================================

--- /dev/null

+++ b/inet/tst-deadline.c

@@ -0,0 +1,188 @@

+/* Tests for computing deadlines for timeouts.

+   Copyright (C) 2017 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#include <inet/net-internal.h>

+#include <limits.h>

+#include <stdbool.h>

+#include <stdint.h>

+#include <support/check.h>

+

+/* Find the maximum value which can be represented in a time_t.  */

+static time_t

+time_t_max (void)

+{

+  _Static_assert (0 > (time_t) -1, "time_t is signed");

+  uintmax_t current = 1;

+  while (true)

+    {

+      uintmax_t next = current * 2;

+      /* This cannot happen because time_t is signed.  */

+      TEST_VERIFY_EXIT (next > current);

+      ++next;

+      if ((time_t) next < 0 || next != (uintmax_t) (time_t) next)

+        /* Value cannot be represented in time_t.  Return the previous

+           value. */

+        return current;

+      current = next;

+    }

+}

+

+static int

+do_test (void)

+{

+  {

+    struct deadline_current_time current_time = __deadline_current_time ();

+    TEST_VERIFY (current_time.current.tv_sec >= 0);

+    current_time = __deadline_current_time ();

+    /* Due to CLOCK_MONOTONIC, either seconds or nanoseconds are

+       greater than zero.  This is also true for the gettimeofday

+       fallback.  */

+    TEST_VERIFY (current_time.current.tv_sec >= 0);

+    TEST_VERIFY (current_time.current.tv_sec > 0

+                 || current_time.current.tv_nsec > 0);

+  }

+

+  /* Check basic computations of deadlines.  */

+  struct deadline_current_time current_time = { { 1, 123456789 } };

+  struct deadline deadline = __deadline_from_timeval

+    (current_time, (struct timeval) { 0, 1 });

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 123457789);

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1);

+

+  deadline = __deadline_from_timeval

+    (current_time, ((struct timeval) { 0, 2 }));

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 123458789);

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1);

+

+  deadline = __deadline_from_timeval

+    (current_time, ((struct timeval) { 1, 0 }));

+  TEST_VERIFY (deadline.absolute.tv_sec == 2);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 123456789);

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1000);

+

+  /* Check if timeouts are correctly rounded up to the next

+     millisecond.  */

+  for (int i = 0; i < 999999; ++i)

+    {

+      ++current_time.current.tv_nsec;

+      TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1000);

+    }

+

+  /* A full millisecond has elapsed, so the time to the deadline is

+     now less than 1000.  */

+  ++current_time.current.tv_nsec;

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 999);

+

+  /* Check __deadline_to_ms carry-over.  */

+  current_time = (struct deadline_current_time) { { 9, 123456789 } };

+  deadline = (struct deadline) { { 10, 122456789 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 999);

+  deadline = (struct deadline) { { 10, 122456790 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1000);

+  deadline = (struct deadline) { { 10, 123456788 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1000);

+  deadline = (struct deadline) { { 10, 123456789 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 1000);

+

+  /* Check __deadline_to_ms overflow.  */

+  deadline = (struct deadline) { { INT_MAX - 1, 1 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == INT_MAX);

+

+  /* Check __deadline_to_ms for elapsed deadlines.  */

+  current_time = (struct deadline_current_time) { { 9, 123456789 } };

+  deadline.absolute = current_time.current;

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 0);

+  current_time = (struct deadline_current_time) { { 9, 123456790 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 0);

+  current_time = (struct deadline_current_time) { { 10, 0 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 0);

+  current_time = (struct deadline_current_time) { { 10, 123456788 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 0);

+  current_time = (struct deadline_current_time) { { 10, 123456789 } };

+  TEST_VERIFY (__deadline_to_ms (current_time, deadline) == 0);

+

+  /* Check carry-over in __deadline_from_timeval.  */

+  current_time = (struct deadline_current_time) { { 9, 998000001 } };

+  for (int i = 0; i < 2000; ++i)

+    {

+      deadline = __deadline_from_timeval

+        (current_time, (struct timeval) { 1, i });

+      TEST_VERIFY (deadline.absolute.tv_sec == 10);

+      TEST_VERIFY (deadline.absolute.tv_nsec == 998000001 + i * 1000);

+    }

+  for (int i = 2000; i < 3000; ++i)

+    {

+      deadline = __deadline_from_timeval

+        (current_time, (struct timeval) { 2, i });

+      TEST_VERIFY (deadline.absolute.tv_sec == 12);

+      TEST_VERIFY (deadline.absolute.tv_nsec == 1 + (i - 2000) * 1000);

+    }

+

+  /* Check infinite deadlines.  */

+  deadline = __deadline_from_timeval

+    ((struct deadline_current_time) { { 0, 1000 * 1000 * 1000 - 1000 } },

+     (struct timeval) { time_t_max (), 1 });

+  TEST_VERIFY (__deadline_is_infinite (deadline));

+  deadline = __deadline_from_timeval

+    ((struct deadline_current_time) { { 0, 1000 * 1000 * 1000 - 1001 } },

+     (struct timeval) { time_t_max (), 1 });

+  TEST_VERIFY (!__deadline_is_infinite (deadline));

+  deadline = __deadline_from_timeval

+    ((struct deadline_current_time)

+       { { time_t_max (), 1000 * 1000 * 1000 - 1000 } },

+     (struct timeval) { 0, 1 });

+  TEST_VERIFY (__deadline_is_infinite (deadline));

+  deadline = __deadline_from_timeval

+    ((struct deadline_current_time)

+       { { time_t_max () / 2 + 1, 0 } },

+     (struct timeval) { time_t_max () / 2 + 1, 0 });

+  TEST_VERIFY (__deadline_is_infinite (deadline));

+

+  /* Check __deadline_first behavior.  */

+  deadline = __deadline_first

+    ((struct deadline) { { 1, 2 } },

+     (struct deadline) { { 1, 3 } });

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 2);

+  deadline = __deadline_first

+    ((struct deadline) { { 1, 3 } },

+     (struct deadline) { { 1, 2 } });

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 2);

+  deadline = __deadline_first

+    ((struct deadline) { { 1, 2 } },

+     (struct deadline) { { 2, 1 } });

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 2);

+  deadline = __deadline_first

+    ((struct deadline) { { 1, 2 } },

+     (struct deadline) { { 2, 4 } });

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 2);

+  deadline = __deadline_first

+    ((struct deadline) { { 2, 4 } },

+     (struct deadline) { { 1, 2 } });

+  TEST_VERIFY (deadline.absolute.tv_sec == 1);

+  TEST_VERIFY (deadline.absolute.tv_nsec == 2);

+

+  return 0;

+}

+

+#include <support/test-driver.c>

Index: b/sunrpc/Makefile

===================================================================

--- a/sunrpc/Makefile

+++ b/sunrpc/Makefile

@@ -96,11 +96,13 @@ others += rpcgen

 all: # Make this the default target; it will be defined in Rules.

-tests = tst-xdrmem tst-xdrmem2

+tests = tst-xdrmem tst-xdrmem2 tst-udp-timeout \

+  tst-udp-nonblocking

 xtests := tst-getmyaddr

 ifeq ($(have-thread-library),yes)

 xtests += thrsvc

+tests += tst-udp-garbage

 endif

 headers += $(rpcsvc:%.x=rpcsvc/%.h)

@@ -225,3 +227,8 @@ endif

 endif

 $(objpfx)thrsvc: $(common-objpfx)linkobj/libc.so $(shared-thread-library)

+

+$(objpfx)tst-udp-timeout: $(common-objpfx)linkobj/libc.so

+$(objpfx)tst-udp-nonblocking: $(common-objpfx)linkobj/libc.so

+$(objpfx)tst-udp-garbage: \

+  $(common-objpfx)linkobj/libc.so $(shared-thread-library)

Index: b/sunrpc/clnt_udp.c

===================================================================

--- a/sunrpc/clnt_udp.c

+++ b/sunrpc/clnt_udp.c

@@ -54,6 +54,7 @@

 #endif

 #include <kernel-features.h>

+#include <inet/net-internal.h>

 extern u_long _create_xid (void);

@@ -79,7 +80,9 @@ static const struct clnt_ops udp_ops =

 };

 /*

- * Private data kept per client handle

+ * Private data kept per client handle.  This private struct is

+ * unfortunately part of the ABI; ypbind contains a copy of it and

+ * accesses it through CLIENT::cl_private field.

  */

 struct cu_data

   {

@@ -309,28 +312,38 @@ clntudp_call (cl, proc, xargs, argsp, xr

   int inlen;

   socklen_t fromlen;

   struct pollfd fd;

-  int milliseconds = (cu->cu_wait.tv_sec * 1000) +

-    (cu->cu_wait.tv_usec / 1000);

   struct sockaddr_in from;

   struct rpc_msg reply_msg;

   XDR reply_xdrs;

-  struct timeval time_waited;

   bool_t ok;

   int nrefreshes = 2;		/* number of times to refresh cred */

-  struct timeval timeout;

   int anyup;			/* any network interface up */

-  if (cu->cu_total.tv_usec == -1)

-    {

-      timeout = utimeout;	/* use supplied timeout */

-    }

-  else

-    {

-      timeout = cu->cu_total;	/* use default timeout */

-    }

+  struct deadline_current_time current_time = __deadline_current_time ();

+  struct deadline total_deadline; /* Determined once by overall timeout.  */

+  struct deadline response_deadline; /* Determined anew for each query.  */

+

+  /* Choose the timeout value.  For non-sending usage (xargs == NULL),

+     the total deadline does not matter, only cu->cu_wait is used

+     below.  */

+  if (xargs != NULL)

+    {

+      struct timeval tv;

+      if (cu->cu_total.tv_usec == -1)

+	/* Use supplied timeout.  */

+	tv = utimeout;

+      else

+	/* Use default timeout.  */

+	tv = cu->cu_total;

+      if (!__is_timeval_valid_timeout (tv))

+	return (cu->cu_error.re_status = RPC_TIMEDOUT);

+      total_deadline = __deadline_from_timeval (current_time, tv);

+    }

+

+  /* Guard against bad timeout specification.  */

+  if (!__is_timeval_valid_timeout (cu->cu_wait))

+    return (cu->cu_error.re_status = RPC_TIMEDOUT);

-  time_waited.tv_sec = 0;

-  time_waited.tv_usec = 0;

 call_again:

   xdrs = &(cu->cu_outxdrs);

   if (xargs == NULL)

@@ -356,27 +369,46 @@ send_again:

       return (cu->cu_error.re_status = RPC_CANTSEND);

     }

-  /*

-   * Hack to provide rpc-based message passing

-   */

-  if (timeout.tv_sec == 0 && timeout.tv_usec == 0)

-    {

-      return (cu->cu_error.re_status = RPC_TIMEDOUT);

-    }

+  /* sendto may have blocked, so recompute the current time.  */

+  current_time = __deadline_current_time ();

  get_reply:

-  /*

-   * sub-optimal code appears here because we have

-   * some clock time to spare while the packets are in flight.

-   * (We assume that this is actually only executed once.)

-   */

+  response_deadline = __deadline_from_timeval (current_time, cu->cu_wait);

+

   reply_msg.acpted_rply.ar_verf = _null_auth;

   reply_msg.acpted_rply.ar_results.where = resultsp;

   reply_msg.acpted_rply.ar_results.proc = xresults;

   fd.fd = cu->cu_sock;

   fd.events = POLLIN;

   anyup = 0;

+

+  /* Per-response retry loop.  current_time must be up-to-date at the

+     top of the loop.  */

   for (;;)

     {

+      int milliseconds;

+      if (xargs != NULL)

+	{

+	  if (__deadline_elapsed (current_time, total_deadline))

+	    /* Overall timeout expired.  */

+	    return (cu->cu_error.re_status = RPC_TIMEDOUT);

+	  milliseconds = __deadline_to_ms

+	    (current_time, __deadline_first (total_deadline,

+					     response_deadline));

+	  if (milliseconds == 0)

+	    /* Per-query timeout expired.  */

+	    goto send_again;

+	}

+      else

+	{

+	  /* xatgs == NULL.  Collect a response without sending a

+	     query.  In this mode, we need to ignore the total

+	     deadline.  */

+	  milliseconds = __deadline_to_ms (current_time, response_deadline);

+	  if (milliseconds == 0)

+	    /* Cannot send again, so bail out.  */

+	    return (cu->cu_error.re_status = RPC_CANTSEND);

+	}

+

       switch (__poll (&fd, 1, milliseconds))

 	{

@@ -387,27 +419,10 @@ send_again:

 	      if (!anyup)

 		return (cu->cu_error.re_status = RPC_CANTRECV);

 	    }

-

-	  time_waited.tv_sec += cu->cu_wait.tv_sec;

-	  time_waited.tv_usec += cu->cu_wait.tv_usec;

-	  while (time_waited.tv_usec >= 1000000)

-	    {

-	      time_waited.tv_sec++;

-	      time_waited.tv_usec -= 1000000;

-	    }

-	  if ((time_waited.tv_sec < timeout.tv_sec) ||

-	      ((time_waited.tv_sec == timeout.tv_sec) &&

-	       (time_waited.tv_usec < timeout.tv_usec)))

-	    goto send_again;

-	  return (cu->cu_error.re_status = RPC_TIMEDOUT);

-

-	  /*

-	   * buggy in other cases because time_waited is not being

-	   * updated.

-	   */

+	  goto next_response;

 	case -1:

 	  if (errno == EINTR)

-	    continue;

+	    goto next_response;

 	  cu->cu_error.re_errno = errno;

 	  return (cu->cu_error.re_status = RPC_CANTRECV);

 	}

@@ -463,20 +478,22 @@ send_again:

       if (inlen < 0)

 	{

 	  if (errno == EWOULDBLOCK)

-	    continue;

+	    goto next_response;

 	  cu->cu_error.re_errno = errno;

 	  return (cu->cu_error.re_status = RPC_CANTRECV);

 	}

-      if (inlen < 4)

-	continue;

+      /* Accept the response if the packet is sufficiently long and

+	 the transaction ID matches the query (if available).  */

+      if (inlen >= 4

+	  && (xargs == NULL

+	      || memcmp (cu->cu_inbuf, cu->cu_outbuf,

+			 sizeof (u_int32_t)) == 0))

+	break;

-      /* see if reply transaction id matches sent id.

-	Don't do this if we only wait for a replay */

-      if (xargs != NULL

-	  && memcmp (cu->cu_inbuf, cu->cu_outbuf, sizeof (u_int32_t)) != 0)

-	continue;

-      /* we now assume we have the proper reply */

-      break;

+    next_response:

+      /* Update the current time because poll and recvmsg waited for

+	 an unknown time.  */

+      current_time = __deadline_current_time ();

     }

   /*

Index: b/sunrpc/tst-udp-garbage.c

===================================================================

--- /dev/null

+++ b/sunrpc/tst-udp-garbage.c

@@ -0,0 +1,104 @@

+/* Test that garbage packets do not affect timeout handling.

+   Copyright (C) 2017 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#include <netinet/in.h>

+#include <rpc/clnt.h>

+#include <rpc/svc.h>

+#include <stdbool.h>

+#include <support/check.h>

+#include <support/namespace.h>

+#include <support/xsocket.h>

+#include <support/xthread.h>

+#include <sys/socket.h>

+#include <unistd.h>

+

+/* Descriptor for the server UDP socket.  */

+static int server_fd;

+

+static void *

+garbage_sender_thread (void *unused)

+{

+  while (true)

+    {

+      struct sockaddr_storage sa;

+      socklen_t salen = sizeof (sa);

+      char buf[1];

+      if (recvfrom (server_fd, buf, sizeof (buf), 0,

+                    (struct sockaddr *) &sa, &salen) < 0)

+        FAIL_EXIT1 ("recvfrom: %m");

+

+      /* Send garbage packets indefinitely.  */

+      buf[0] = 0;

+      while (true)

+        {

+          /* sendto can fail if the client closed the socket.  */

+          if (sendto (server_fd, buf, sizeof (buf), 0,

+                      (struct sockaddr *) &sa, salen) < 0)

+            break;

+

+          /* Wait a bit, to avoid burning too many CPU cycles in a

+             tight loop.  The wait period must be much shorter than

+             the client timeouts configured below.  */

+          usleep (50 * 1000);

+        }

+    }

+}

+

+static int

+do_test (void)

+{

+  support_become_root ();

+  support_enter_network_namespace ();

+

+  server_fd = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);

+  struct sockaddr_in server_address =

+    {

+      .sin_family = AF_INET,

+      .sin_addr.s_addr = htonl (INADDR_LOOPBACK),

+    };

+  xbind (server_fd,

+         (struct sockaddr *) &server_address, sizeof (server_address));

+  {

+    socklen_t sinlen = sizeof (server_address);

+    xgetsockname (server_fd, (struct sockaddr *) &server_address, &sinlen);

+    TEST_VERIFY (sizeof (server_address) == sinlen);

+  }

+

+  /* Garbage packet source.  */

+  xpthread_detach (xpthread_create (NULL, garbage_sender_thread, NULL));

+

+  /* Test client.  Use an arbitrary timeout of one second, which is

+     much longer than the garbage packet interval, but still

+     reasonably short, so that the test completes quickly.  */

+  int client_fd = RPC_ANYSOCK;

+  CLIENT *clnt = clntudp_create (&server_address,

+                                 1, 2, /* Arbitrary RPC endpoint numbers.  */

+                                 (struct timeval) { 1, 0 },

+                                 &client_fd);

+  if (clnt == NULL)

+    FAIL_EXIT1 ("clntudp_create: %m");

+

+  TEST_VERIFY (clnt_call (clnt, 3, /* Arbitrary RPC procedure number.  */

+                          (xdrproc_t) xdr_void, NULL,

+                          (xdrproc_t) xdr_void, NULL,

+                          ((struct timeval) { 1, 0 })));

+

+  return 0;

+}

+

+#include <support/test-driver.c>

Index: b/sunrpc/tst-udp-nonblocking.c

===================================================================

--- /dev/null

+++ b/sunrpc/tst-udp-nonblocking.c

@@ -0,0 +1,333 @@

+/* Test non-blocking use of the UDP client.

+   Copyright (C) 2017 Free Software Foundation, Inc.

+   This file is part of the GNU C Library.

+

+   The GNU C Library is free software; you can redistribute it and/or

+   modify it under the terms of the GNU Lesser General Public

+   License as published by the Free Software Foundation; either

+   version 2.1 of the License, or (at your option) any later version.

+

+   The GNU C Library is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   Lesser General Public License for more details.

+

+   You should have received a copy of the GNU Lesser General Public

+   License along with the GNU C Library; if not, see

+   <http://www.gnu.org/licenses/>.  */

+

+#include <netinet/in.h>

+#include <rpc/clnt.h>

+#include <rpc/svc.h>

+#include <stdbool.h>

+#include <string.h>

+#include <support/check.h>

+#include <support/namespace.h>

+#include <support/test-driver.h>

+#include <support/xsocket.h>

+#include <support/xunistd.h>

+#include <sys/socket.h>

+#include <time.h>

+#include <unistd.h>

+

+/* Test data serialization and deserialization.   */

+

+struct test_query

+{

+  uint32_t a;

+  uint32_t b;

+  uint32_t timeout_ms;

+};

+

+static bool_t

+xdr_test_query (XDR *xdrs, void *data, ...)

+{

+  struct test_query *p = data;

+  return xdr_uint32_t (xdrs, &p->a)

+    && xdr_uint32_t (xdrs, &p->b)

+    && xdr_uint32_t (xdrs, &p->timeout_ms);

+}