nis/nis_findserv.c

   1 /* Copyright (C) 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <string.h>
  21 #include <time.h>
  22 #include <unistd.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/socket.h>
  25 #include <rpc/pmap_prot.h>
  26 #include <rpc/pmap_clnt.h>
  27 #include <rpcsvc/nis.h>
  28
  29 #include "nis_intern.h"
  30
  31 /* Private data kept per client handle, from sunrpc/clnt_udp.c */
  32 struct cu_data
  33   {
  34     int cu_sock;
  35     bool_t cu_closeit;
  36     struct sockaddr_in cu_raddr;
  37     int cu_rlen;
  38     struct timeval cu_wait;
  39     struct timeval cu_total;
  40     struct rpc_err cu_error;
  41     XDR cu_outxdrs;
  42     u_int cu_xdrpos;
  43     u_int cu_sendsz;
  44     char *cu_outbuf;
  45     u_int cu_recvsz;
  46     char cu_inbuf[1];
  47   };
  48
  49
  50 /* The following is the original routine from sunrpc/pm_getport.c.
  51    The only change is the much shorter timeout. */
  52 /*
  53  * pmap_getport.c
  54  * Client interface to pmap rpc service.
  55  *
  56  * Copyright (C) 1984, Sun Microsystems, Inc.
  57  */
  58
  59 /*
  60  * Find the mapped port for program,version.
  61  * Calls the pmap service remotely to do the lookup.
  62  * Returns 0 if no map exists.
  63  */
  64 u_short
  65 __pmap_getnisport (struct sockaddr_in *address, u_long program,
  66                    u_long version, u_int protocol)
  67 {
  68   const struct timeval timeout = {1, 0};
  69   const struct timeval tottimeout = {1, 0};
  70   u_short port = 0;
  71   int socket = -1;
  72   CLIENT *client;
  73   struct pmap parms;
  74
  75   address->sin_port = htons (PMAPPORT);
  76   client = clntudp_bufcreate (address, PMAPPROG, PMAPVERS, timeout, &socket,
  77                               RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
  78   if (client != (CLIENT *) NULL)
  79     {
  80       parms.pm_prog = program;
  81       parms.pm_vers = version;
  82       parms.pm_prot = protocol;
  83       parms.pm_port = 0;        /* not needed or used */
  84       if (CLNT_CALL (client, PMAPPROC_GETPORT, (xdrproc_t) xdr_pmap,
  85                      (caddr_t) & parms, (xdrproc_t) xdr_u_short,
  86                      (caddr_t) & port, tottimeout) != RPC_SUCCESS)
  87         {
  88           rpc_createerr.cf_stat = RPC_PMAPFAILURE;
  89           clnt_geterr (client, &rpc_createerr.cf_error);
  90         }
  91       else
  92         {
  93           if (port == 0)
  94             rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
  95         }
  96       CLNT_DESTROY (client);
  97     }
  98   /* (void)close(socket); CLNT_DESTROY already closed it */
  99   address->sin_port = 0;
 100   return port;
 101 }
 102
 103 /* This is now the public function, which should find the fastest server */
 104
 105 struct findserv_req
 106 {
 107   struct sockaddr_in sin;
 108   u_int32_t xid;
 109   u_int server_nr;
 110   u_int server_ep;
 111 };
 112
 113 long
 114 __nis_findfastest (dir_binding *bind)
 115 {
 116 #if 0
 117   unsigned long i, j;
 118
 119   for (i = 0; i < bind->server_len; i++)
 120     for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
 121       if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
 122         if ((bind->server_val[i].ep.ep_val[j].proto == NULL) ||
 123             (bind->server_val[i].ep.ep_val[j].proto[0] ==  '-') ||
 124             (bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
 125           {
 126             bind->server_used = i;
 127             bind->current_ep = j;
 128             return 1;
 129           }
 130
 131   return 0;
 132 #else
 133   const struct timeval TIMEOUT50 = {5, 0};
 134   const struct timeval TIMEOUT00 = {0, 0};
 135   struct findserv_req *pings;
 136   struct sockaddr_in sin, saved_sin;
 137   int found = -1;
 138   u_int32_t xid_seed;
 139   int sock, dontblock = 1;
 140   CLIENT *clnt;
 141   u_long i, j, pings_count, pings_max, fastest = -1;
 142   struct cu_data *cu;
 143
 144   pings_max = bind->server_len * 2;     /* Reserve a little bit more memory
 145                                            for multihomed hosts */
 146   pings_count = 0;
 147   pings = malloc (sizeof (struct findserv_req) * pings_max);
 148   xid_seed = (u_int32_t) (time (NULL) ^ getpid ());
 149
 150   if (__builtin_expect (pings == NULL, 0))
 151     return -1;
 152
 153   memset (&sin, '\0', sizeof (sin));
 154   sin.sin_family = AF_INET;
 155   for (i = 0; i < bind->server_len; i++)
 156     for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
 157       if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
 158         if ((bind->server_val[i].ep.ep_val[j].proto == NULL) ||
 159             (bind->server_val[i].ep.ep_val[j].proto[0] == '-') ||
 160             (bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
 161           {
 162             sin.sin_addr.s_addr =
 163               inetstr2int (bind->server_val[i].ep.ep_val[j].uaddr);
 164             if (sin.sin_addr.s_addr == 0)
 165               continue;
 166             sin.sin_port = htons (__pmap_getnisport (&sin, NIS_PROG,
 167                                                      NIS_VERSION,
 168                                                      IPPROTO_UDP));
 169             if (sin.sin_port == 0)
 170               continue;
 171
 172             if (pings_count >= pings_max)
 173               {
 174                 struct findserv_req *new_pings;
 175
 176                 pings_max += 10;
 177                 new_pings = realloc (pings, sizeof (struct findserv_req) *
 178                                      pings_max);
 179                 if (__builtin_expect (new_pings == NULL, 0))
 180                   {
 181                     free (pings);
 182                     return -1;
 183                   }
 184                 pings = new_pings;
 185               }
 186             memcpy ((char *) &pings[pings_count].sin, (char *) &sin,
 187                     sizeof (sin));
 188             memcpy ((char *)&saved_sin, (char *)&sin, sizeof(sin));
 189             pings[pings_count].xid = xid_seed + pings_count;
 190             pings[pings_count].server_nr = i;
 191             pings[pings_count].server_ep = j;
 192             ++pings_count;
 193           }
 194
 195   /* Make sure at least one server was assigned */
 196   if (pings_count == 0)
 197     {
 198       free (pings);
 199       return -1;
 200     }
 201
 202   /* Create RPC handle */
 203   sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 204   clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, TIMEOUT50, &sock);
 205   if (clnt == NULL)
 206     {
 207       close (sock);
 208       free (pings);
 209       return -1;
 210     }
 211   auth_destroy (clnt->cl_auth);
 212   clnt->cl_auth = authunix_create_default ();
 213   cu = (struct cu_data *) clnt->cl_private;
 214   clnt_control (clnt, CLSET_TIMEOUT, (char *) &TIMEOUT00);
 215   ioctl (sock, FIONBIO, &dontblock);
 216
 217   /* Send to all servers the NULLPROC */
 218   for (i = 0; i < pings_count; ++i)
 219     {
 220       /* clntudp_call() will increment, subtract one */
 221       *((u_int32_t *) (cu->cu_outbuf)) = pings[i].xid - 1;
 222       memcpy ((char *) &cu->cu_raddr, (char *) &pings[i].sin,
 223               sizeof (struct sockaddr_in));
 224       /* Transmit to NULLPROC, return immediately. */
 225       clnt_call (clnt, NULLPROC,
 226                  (xdrproc_t) xdr_void, (caddr_t) 0,
 227                  (xdrproc_t) xdr_void, (caddr_t) 0, TIMEOUT00);
 228     }
 229
 230   /* Receive reply from NULLPROC asynchronously */
 231   while (RPC_SUCCESS == clnt_call (clnt, NULLPROC,
 232                                    (xdrproc_t) NULL, (caddr_t) 0,
 233                                    (xdrproc_t) xdr_void, (caddr_t) 0,
 234                                    TIMEOUT00))
 235     {
 236       fastest = *((u_int32_t *) (cu->cu_inbuf)) - xid_seed;
 237       if (fastest < pings_count) {
 238         break;
 239       }
 240     }
 241
 242   if (fastest < pings_count)
 243     {
 244       bind->server_used = pings[fastest].server_nr;
 245       bind->current_ep = pings[fastest].server_ep;
 246       found = 1;
 247     }
 248
 249   auth_destroy (clnt->cl_auth);
 250   clnt_destroy (clnt);
 251   close (sock);
 252
 253   free (pings);
 254
 255   return found;
 256 #endif
 257 }