typo
[kopensolaris-gnu/glibc.git] / nis / nis_findserv.c
index 832b6a5..472a2bf 100644 (file)
@@ -1,23 +1,24 @@
-/* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   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
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 #include <string.h>
+#include <time.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
@@ -109,35 +110,37 @@ struct findserv_req
   u_int server_ep;
 };
 
-long
-__nis_findfastest (dir_binding * bind)
+
+static long int
+__nis_findfastest_with_timeout (dir_binding *bind,
+                               const struct timeval *timeout)
 {
-  const struct timeval TIMEOUT50 = {5, 0};
-  const struct timeval TIMEOUT00 = {0, 0};
-  struct findserv_req **pings;
+  static const struct timeval TIMEOUT00 = { 0, 0 };
+  struct findserv_req *pings;
   struct sockaddr_in sin, saved_sin;
   int found = -1;
-  u_int32_t xid_seed, xid_lookup;
+  u_int32_t xid_seed;
   int sock, dontblock = 1;
   CLIENT *clnt;
-  char clnt_res;
-  void *foo = NULL;
-  u_long i, j, pings_count, pings_max;
+  u_long i, j, pings_count, pings_max, fastest = -1;
   struct cu_data *cu;
 
   pings_max = bind->server_len * 2;    /* Reserve a little bit more memory
                                           for multihomed hosts */
   pings_count = 0;
-  pings = malloc (sizeof (struct findserv_req *) * pings_max);
+  pings = malloc (sizeof (struct findserv_req) * pings_max);
   xid_seed = (u_int32_t) (time (NULL) ^ getpid ());
 
+  if (__builtin_expect (pings == NULL, 0))
+    return -1;
+
   memset (&sin, '\0', sizeof (sin));
   sin.sin_family = AF_INET;
   for (i = 0; i < bind->server_len; i++)
     for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
       if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
        if ((bind->server_val[i].ep.ep_val[j].proto == NULL) ||
-           (strcmp (bind->server_val[i].ep.ep_val[j].proto, "-") == 0) ||
+           (bind->server_val[i].ep.ep_val[j].proto[0] == '-') ||
            (bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
          {
            sin.sin_addr.s_addr =
@@ -152,18 +155,24 @@ __nis_findfastest (dir_binding * bind)
 
            if (pings_count >= pings_max)
              {
+               struct findserv_req *new_pings;
+
                pings_max += 10;
-               pings = realloc (pings, sizeof (struct findserv_req) *
-                                pings_max);
+               new_pings = realloc (pings, sizeof (struct findserv_req) *
+                                    pings_max);
+               if (__builtin_expect (new_pings == NULL, 0))
+                 {
+                   free (pings);
+                   return -1;
+                 }
+               pings = new_pings;
              }
-           pings[pings_count] = calloc (1, sizeof (struct findserv_req));
-           memcpy ((char *) &pings[pings_count]->sin, (char *) &sin,
+           memcpy ((char *) &pings[pings_count].sin, (char *) &sin,
                    sizeof (sin));
            memcpy ((char *)&saved_sin, (char *)&sin, sizeof(sin));
-           pings[pings_count]->xid = xid_seed;
-           pings[pings_count]->server_nr = i;
-           pings[pings_count]->server_ep = j;
-           ++xid_seed;
+           pings[pings_count].xid = xid_seed + pings_count;
+           pings[pings_count].server_nr = i;
+           pings[pings_count].server_ep = j;
            ++pings_count;
          }
 
@@ -176,56 +185,74 @@ __nis_findfastest (dir_binding * bind)
 
   /* Create RPC handle */
   sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-  clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, TIMEOUT50, &sock);
+  clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, *timeout, &sock);
   if (clnt == NULL)
     {
       close (sock);
-      for (i = 0; i < pings_count; ++i)
-       free (pings[i]);
       free (pings);
       return -1;
     }
   auth_destroy (clnt->cl_auth);
   clnt->cl_auth = authunix_create_default ();
   cu = (struct cu_data *) clnt->cl_private;
-  clnt_control (clnt, CLSET_TIMEOUT, (char *) &TIMEOUT00);
   ioctl (sock, FIONBIO, &dontblock);
-
   /* Send to all servers the NULLPROC */
   for (i = 0; i < pings_count; ++i)
     {
       /* clntudp_call() will increment, subtract one */
-      *((u_int32_t *) (cu->cu_outbuf)) = pings[i]->xid - 1;
-      memcpy ((char *) &cu->cu_raddr, (char *) &pings[i]->sin,
+      *((u_int32_t *) (cu->cu_outbuf)) = pings[i].xid - 1;
+      memcpy ((char *) &cu->cu_raddr, (char *) &pings[i].sin,
              sizeof (struct sockaddr_in));
       /* Transmit to NULLPROC, return immediately. */
-      clnt_call (clnt, NULLPROC, (xdrproc_t) xdr_void, (caddr_t) foo,
-                (xdrproc_t) xdr_void, (caddr_t) & clnt_res, TIMEOUT00);
+      clnt_call (clnt, NULLPROC,
+                (xdrproc_t) xdr_void, (caddr_t) 0,
+                (xdrproc_t) xdr_void, (caddr_t) 0, TIMEOUT00);
     }
 
-  /* Receive reply from NULLPROC asynchronously */
-  memset ((char *) &clnt_res, 0, sizeof (clnt_res));
-  clnt_call (clnt, NULLPROC, (xdrproc_t) NULL, (caddr_t) foo,
-            (xdrproc_t) xdr_void, (caddr_t) &clnt_res, TIMEOUT00);
-
-  xid_lookup = *((u_int32_t *) (cu->cu_inbuf));
-  for (i = 0; i < pings_count; i++)
-    {
-      if (pings[i]->xid == xid_lookup)
-       {
-         bind->server_used = pings[i]->server_nr;
-         bind->current_ep = pings[i]->server_ep;
-         found = 1;
-       }
+  while (found == -1) {
+    /* Receive reply from NULLPROC asynchronously. Note null inproc. */
+    int rc = clnt_call (clnt, NULLPROC,
+                       (xdrproc_t) NULL, (caddr_t) 0,
+                       (xdrproc_t) xdr_void, (caddr_t) 0,
+                       *timeout);
+    if (RPC_SUCCESS == rc) {
+      fastest = *((u_int32_t *) (cu->cu_inbuf)) - xid_seed;
+      if (fastest < pings_count) {
+       bind->server_used = pings[fastest].server_nr;
+       bind->current_ep = pings[fastest].server_ep;
+       found = 1;
+      }
+    } else {
+      /*      clnt_perror(clnt, "__nis_findfastest"); */
+      break;
     }
+  }
+
 
   auth_destroy (clnt->cl_auth);
   clnt_destroy (clnt);
   close (sock);
 
-  for (i = 0; i < pings_count; ++i)
-    free (pings[i]);
   free (pings);
 
   return found;
 }
+
+
+long int
+__nis_findfastest (dir_binding *bind)
+{
+  struct timeval timeout = { __NIS_PING_TIMEOUT_START, 0 };
+  long int found = -1;
+  long int retry = __NIS_PING_RETRY + 1;
+
+  while (retry--)
+    {
+      found = __nis_findfastest_with_timeout (bind, &timeout);
+      if (found != -1)
+       break;
+      timeout.tv_sec += __NIS_PING_TIMEOUT_INCREMENT;
+    }
+
+  return found;
+}