1 /* Copyright (C) 1997-2015 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.
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.
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.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
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>
28 #include "nis_intern.h"
30 /* Private data kept per client handle, from sunrpc/clnt_udp.c */
35 struct sockaddr_in cu_raddr;
37 struct timeval cu_wait;
38 struct timeval cu_total;
39 struct rpc_err cu_error;
50 * Find the mapped port for program,version.
51 * Calls the pmap service remotely to do the lookup.
52 * Returns 0 if no map exists.
55 __pmap_getnisport (struct sockaddr_in *address, u_long program,
56 u_long version, u_int protocol)
58 return __libc_rpc_getport (address, program, version, protocol, 1, 1);
61 /* This is now the public function, which should find the fastest server */
65 struct sockaddr_in sin;
73 __nis_findfastest_with_timeout (dir_binding *bind,
74 const struct timeval *timeout)
76 static const struct timeval TIMEOUT00 = { 0, 0 };
77 struct findserv_req *pings;
78 struct sockaddr_in sin, saved_sin;
81 int sock, dontblock = 1;
83 u_long i, j, pings_count, pings_max, fastest = -1;
86 pings_max = bind->server_len * 2; /* Reserve a little bit more memory
87 for multihomed hosts */
89 pings = malloc (sizeof (struct findserv_req) * pings_max);
90 xid_seed = (u_int32_t) (time (NULL) ^ getpid ());
92 if (__glibc_unlikely (pings == NULL))
95 memset (&sin, '\0', sizeof (sin));
96 sin.sin_family = AF_INET;
97 for (i = 0; i < bind->server_len; i++)
98 for (j = 0; j < bind->server_val[i].ep.ep_len; ++j)
99 if (strcmp (bind->server_val[i].ep.ep_val[j].family, "inet") == 0)
100 if ((bind->server_val[i].ep.ep_val[j].proto == NULL) ||
101 (bind->server_val[i].ep.ep_val[j].proto[0] == '-') ||
102 (bind->server_val[i].ep.ep_val[j].proto[0] == '\0'))
104 sin.sin_addr.s_addr =
105 inetstr2int (bind->server_val[i].ep.ep_val[j].uaddr);
106 if (sin.sin_addr.s_addr == 0)
108 sin.sin_port = htons (__pmap_getnisport (&sin, NIS_PROG,
111 if (sin.sin_port == 0)
114 if (pings_count >= pings_max)
116 struct findserv_req *new_pings;
119 new_pings = realloc (pings, sizeof (struct findserv_req) *
121 if (__glibc_unlikely (new_pings == NULL))
128 memcpy ((char *) &pings[pings_count].sin, (char *) &sin,
130 memcpy ((char *)&saved_sin, (char *)&sin, sizeof(sin));
131 pings[pings_count].xid = xid_seed + pings_count;
132 pings[pings_count].server_nr = i;
133 pings[pings_count].server_ep = j;
137 /* Make sure at least one server was assigned */
138 if (pings_count == 0)
144 /* Create RPC handle */
145 sock = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
146 clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, *timeout, &sock);
153 auth_destroy (clnt->cl_auth);
154 clnt->cl_auth = authunix_create_default ();
155 cu = (struct cu_data *) clnt->cl_private;
156 ioctl (sock, FIONBIO, &dontblock);
157 /* Send to all servers the NULLPROC */
158 for (i = 0; i < pings_count; ++i)
160 /* clntudp_call() will increment, subtract one */
161 *((u_int32_t *) (cu->cu_outbuf)) = pings[i].xid - 1;
162 memcpy ((char *) &cu->cu_raddr, (char *) &pings[i].sin,
163 sizeof (struct sockaddr_in));
164 /* Transmit to NULLPROC, return immediately. */
165 clnt_call (clnt, NULLPROC,
166 (xdrproc_t) xdr_void, (caddr_t) 0,
167 (xdrproc_t) xdr_void, (caddr_t) 0, TIMEOUT00);
170 while (found == -1) {
171 /* Receive reply from NULLPROC asynchronously. Note null inproc. */
172 int rc = clnt_call (clnt, NULLPROC,
173 (xdrproc_t) NULL, (caddr_t) 0,
174 (xdrproc_t) xdr_void, (caddr_t) 0,
176 if (RPC_SUCCESS == rc) {
178 memcpy (&val, cu->cu_inbuf, sizeof (u_int32_t));
179 fastest = val - xid_seed;
180 if (fastest < pings_count) {
181 bind->server_used = pings[fastest].server_nr;
182 bind->current_ep = pings[fastest].server_ep;
186 /* clnt_perror(clnt, "__nis_findfastest"); */
192 auth_destroy (clnt->cl_auth);
203 __nis_findfastest (dir_binding *bind)
205 struct timeval timeout = { __NIS_PING_TIMEOUT_START, 0 };
207 long int retry = __NIS_PING_RETRY + 1;
211 found = __nis_findfastest_with_timeout (bind, &timeout);
214 timeout.tv_sec += __NIS_PING_TIMEOUT_INCREMENT;