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