1/* Copyright (C) 1997-2019 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, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <string.h>
20#include <time.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 */
31struct 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/*
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.
53 */
54u_short
55__pmap_getnisport (struct sockaddr_in *address, u_long program,
56 u_long version, u_int protocol)
57{
58 return __libc_rpc_getport (address, program, version, protocol, 1, 1);
59}
60
61/* This is now the public function, which should find the fastest server */
62
63struct findserv_req
64{
65 struct sockaddr_in sin;
66 uint32_t xid;
67 u_int server_nr;
68 u_int server_ep;
69};
70
71
72static long int
73__nis_findfastest_with_timeout (dir_binding *bind,
74 const struct timeval *timeout)
75{
76 static const struct timeval TIMEOUT00 = { 0, 0 };
77 struct findserv_req *pings;
78 struct sockaddr_in sin, saved_sin;
79 int found = -1;
80 uint32_t xid_seed;
81 int sock, dontblock = 1;
82 CLIENT *clnt;
83 u_long i, j, pings_count, pings_max, fastest = -1;
84 struct cu_data *cu;
85
86 pings_max = bind->server_len * 2; /* Reserve a little bit more memory
87 for multihomed hosts */
88 pings_count = 0;
89 pings = malloc (sizeof (struct findserv_req) * pings_max);
90 xid_seed = (uint32_t) (time (NULL) ^ getpid ());
91
92 if (__glibc_unlikely (pings == NULL))
93 return -1;
94
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'))
103 {
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)
107 continue;
108 sin.sin_port = htons (__pmap_getnisport (&sin, NIS_PROG,
109 NIS_VERSION,
110 IPPROTO_UDP));
111 if (sin.sin_port == 0)
112 continue;
113
114 if (pings_count >= pings_max)
115 {
116 struct findserv_req *new_pings;
117
118 pings_max += 10;
119 new_pings = realloc (pings, sizeof (struct findserv_req) *
120 pings_max);
121 if (__glibc_unlikely (new_pings == NULL))
122 {
123 free (pings);
124 return -1;
125 }
126 pings = new_pings;
127 }
128 memcpy ((char *) &pings[pings_count].sin, (char *) &sin,
129 sizeof (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;
134 ++pings_count;
135 }
136
137 /* Make sure at least one server was assigned */
138 if (pings_count == 0)
139 {
140 free (pings);
141 return -1;
142 }
143
144 /* Create RPC handle */
145 sock = socket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
146 clnt = clntudp_create (&saved_sin, NIS_PROG, NIS_VERSION, *timeout, &sock);
147 if (clnt == NULL)
148 {
149 close (sock);
150 free (pings);
151 return -1;
152 }
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)
159 {
160 /* clntudp_call() will increment, subtract one */
161 *((uint32_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);
168 }
169
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,
175 *timeout);
176 if (RPC_SUCCESS == rc) {
177 uint32_t val;
178 memcpy (&val, cu->cu_inbuf, sizeof (uint32_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;
183 found = 1;
184 }
185 } else {
186 /* clnt_perror(clnt, "__nis_findfastest"); */
187 break;
188 }
189 }
190
191
192 auth_destroy (clnt->cl_auth);
193 clnt_destroy (clnt);
194 close (sock);
195
196 free (pings);
197
198 return found;
199}
200
201
202long int
203__nis_findfastest (dir_binding *bind)
204{
205 struct timeval timeout = { __NIS_PING_TIMEOUT_START, 0 };
206 long int found = -1;
207 long int retry = __NIS_PING_RETRY + 1;
208
209 while (retry--)
210 {
211 found = __nis_findfastest_with_timeout (bind, &timeout);
212 if (found != -1)
213 break;
214 timeout.tv_sec += __NIS_PING_TIMEOUT_INCREMENT;
215 }
216
217 return found;
218}
219