xref: /freebsd/usr.sbin/ypbind/yp_ping.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
1 /*
2  * Copyright (c) 1996, 1997
3  *	Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by Bill Paul.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32 
33 /*
34  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
35  * unrestricted use provided that this legend is included on all tape
36  * media and as a part of the software program in whole or part.  Users
37  * may copy or modify Sun RPC without charge, but are not authorized
38  * to license or distribute it to anyone else except as part of a product or
39  * program developed by the user.
40  *
41  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
42  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
44  *
45  * Sun RPC is provided with no support and without any obligation on the
46  * part of Sun Microsystems, Inc. to assist in its use, correction,
47  * modification or enhancement.
48  *
49  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
50  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
51  * OR ANY PART THEREOF.
52  *
53  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
54  * or profits or other special, indirect and consequential damages, even if
55  * Sun has been advised of the possibility of such damages.
56  *
57  * Sun Microsystems, Inc.
58  * 2550 Garcia Avenue
59  * Mountain View, California  94043
60  */
61 
62 #if 0
63 #ifndef lint
64 static char *sccsid = "@(#)from: clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
65 static char *sccsid = "@(#)from: clnt_udp.c	2.2 88/08/01 4.0 RPCSRC";
66 #endif
67 #endif
68 #include <sys/cdefs.h>
69 __FBSDID("$FreeBSD$");
70 
71 /*
72  * clnt_udp.c, Implements a UDP/IP based, client side RPC.
73  *
74  * Copyright (C) 1984, Sun Microsystems, Inc.
75  */
76 
77 #include <errno.h>
78 #include <netdb.h>
79 #include <stdio.h>
80 #include <stdlib.h>
81 #include <string.h>
82 #include <unistd.h>
83 #include <pthread.h>
84 #include <rpc/rpc.h>
85 #include <rpc/pmap_clnt.h>
86 #include <rpc/pmap_prot.h>
87 #include <rpcsvc/yp.h>
88 #include <sys/types.h>
89 #include <sys/poll.h>
90 #include <sys/socket.h>
91 #include <sys/signal.h>
92 #include <sys/ioctl.h>
93 #include <arpa/inet.h>
94 #include <net/if.h>
95 
96 #include "yp_ping.h"
97 
98 struct cu_data {
99 	int			cu_fd;		/* connections fd */
100 	bool_t			cu_closeit;	/* opened by library */
101 	struct sockaddr_storage	cu_raddr;	/* remote address */
102 	int			cu_rlen;
103 	struct timeval		cu_wait;	/* retransmit interval */
104 	struct timeval		cu_total;	/* total time for the call */
105 	struct rpc_err		cu_error;
106 	XDR			cu_outxdrs;
107 	u_int			cu_xdrpos;
108 	u_int			cu_sendsz;	/* send size */
109 	char			*cu_outbuf;
110 	u_int			cu_recvsz;	/* recv size */
111 	struct pollfd		pfdp;
112 	int			cu_async;
113 	char			cu_inbuf[1];
114 };
115 
116 /*
117  * pmap_getport.c
118  * Client interface to pmap rpc service.
119  *
120  * Copyright (C) 1984, Sun Microsystems, Inc.
121  */
122 
123 
124 static struct timeval timeout = { 1, 0 };
125 static struct timeval tottimeout = { 1, 0 };
126 
127 /*
128  * Find the mapped port for program,version.
129  * Calls the pmap service remotely to do the lookup.
130  * Returns 0 if no map exists.
131  */
132 static u_short
133 __pmap_getport(struct sockaddr_in *address, u_long program, u_long version,
134     u_int protocol)
135 {
136 	u_short port = 0;
137 	int sock = -1;
138 	register CLIENT *client;
139 	struct pmap parms;
140 
141 	address->sin_port = htons(PMAPPORT);
142 
143 	client = clntudp_bufcreate(address, PMAPPROG,
144 	    PMAPVERS, timeout, &sock, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE);
145 	if (client != (CLIENT *)NULL) {
146 		parms.pm_prog = program;
147 		parms.pm_vers = version;
148 		parms.pm_prot = protocol;
149 		parms.pm_port = 0;  /* not needed or used */
150 		if (CLNT_CALL(client, PMAPPROC_GETPORT,
151 			(xdrproc_t)xdr_pmap, &parms,
152 			(xdrproc_t)xdr_u_short, &port,
153 			tottimeout) != RPC_SUCCESS){
154 			rpc_createerr.cf_stat = RPC_PMAPFAILURE;
155 			clnt_geterr(client, &rpc_createerr.cf_error);
156 		} else if (port == 0) {
157 			rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
158 		}
159 		CLNT_DESTROY(client);
160 	}
161 	if (sock != -1)
162 		(void)close(sock);
163 	address->sin_port = 0;
164 	return (port);
165 }
166 
167 /*
168  * Transmit to YPPROC_DOMAIN_NONACK, return immediately.
169  */
170 static bool_t *
171 ypproc_domain_nonack_2_send(domainname *argp, CLIENT *clnt)
172 {
173 	static bool_t clnt_res;
174 	struct timeval TIMEOUT = { 0, 0 };
175 
176 	memset((char *)&clnt_res, 0, sizeof (clnt_res));
177 	if (clnt_call(clnt, YPPROC_DOMAIN_NONACK,
178 		(xdrproc_t) xdr_domainname, (caddr_t) argp,
179 		(xdrproc_t) xdr_bool, (caddr_t) &clnt_res,
180 		TIMEOUT) != RPC_SUCCESS) {
181 		return (NULL);
182 	}
183 	return (&clnt_res);
184 }
185 
186 /*
187  * Receive response from YPPROC_DOMAIN_NONACK asynchronously.
188  */
189 static bool_t *
190 ypproc_domain_nonack_2_recv(domainname *argp, CLIENT *clnt)
191 {
192 	static bool_t clnt_res;
193 	struct timeval TIMEOUT = { 0, 0 };
194 
195 	memset((char *)&clnt_res, 0, sizeof (clnt_res));
196 	if (clnt_call(clnt, YPPROC_DOMAIN_NONACK,
197 		(xdrproc_t) NULL, (caddr_t) argp,
198 		(xdrproc_t) xdr_bool, (caddr_t) &clnt_res,
199 		TIMEOUT) != RPC_SUCCESS) {
200 		return (NULL);
201 	}
202 	return (&clnt_res);
203 }
204 
205 /*
206  * "We have the machine that goes 'ping!'" -- Monty Python
207  *
208  * This function blasts packets at the YPPROC_DOMAIN_NONACK procedures
209  * of the NIS servers listed in restricted_addrs structure.
210  * Whoever replies the fastest becomes our chosen server.
211  *
212  * Note: THIS IS NOT A BROADCAST OPERATION! We could use clnt_broadcast()
213  * for this, but that has the following problems:
214  * - We only get the address of the machine that replied in the
215  *   'eachresult' callback, and on multi-homed machines this can
216  *   lead to confusion.
217  * - clnt_broadcast() only transmits to local networks, whereas with
218  *   NIS+ you can have a perfectly good server located anywhere on or
219  *   off the local network.
220  * - clnt_broadcast() blocks for an arbitrary amount of time which the
221  *   caller can't control -- we want to avoid that.
222  *
223  * Also note that this has nothing to do with the NIS_PING procedure used
224  * for replica updates.
225  */
226 
227 struct ping_req {
228 	struct sockaddr_in	sin;
229 	u_int32_t		xid;
230 };
231 
232 int
233 __yp_ping(struct in_addr *restricted_addrs, int cnt, char *dom, short *port)
234 {
235 	struct timeval		tv = { 5, 0 };
236 	struct ping_req		**reqs;
237 	unsigned long		i;
238 	int			async;
239 	struct sockaddr_in	sin, *any = NULL;
240 	int			winner = -1;
241 	u_int32_t		xid_seed, xid_lookup;
242 	int			sock, dontblock = 1;
243 	CLIENT			*clnt;
244 	char			*foo = dom;
245 	struct cu_data		*cu;
246 	int			validsrvs = 0;
247 
248 	/* Set up handles. */
249 	reqs = calloc(1, sizeof(struct ping_req *) * cnt);
250 	xid_seed = time(NULL) ^ getpid();
251 
252 	for (i = 0; i < cnt; i++) {
253 		bzero((char *)&sin, sizeof(sin));
254 		sin.sin_family = AF_INET;
255 		bcopy((char *)&restricted_addrs[i],
256 			(char *)&sin.sin_addr, sizeof(struct in_addr));
257 		sin.sin_port = htons(__pmap_getport(&sin, YPPROG,
258 					YPVERS, IPPROTO_UDP));
259 		if (sin.sin_port == 0)
260 			continue;
261 		reqs[i] = calloc(1, sizeof(struct ping_req));
262 		bcopy((char *)&sin, (char *)&reqs[i]->sin, sizeof(sin));
263 		any = &reqs[i]->sin;
264 		reqs[i]->xid = xid_seed;
265 		xid_seed++;
266 		validsrvs++;
267 	}
268 
269 	/* Make sure at least one server was assigned */
270 	if (!validsrvs) {
271 		free(reqs);
272 		return(-1);
273 	}
274 
275 	/* Create RPC handle */
276 	sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
277 	clnt = clntudp_create(any, YPPROG, YPVERS, tv, &sock);
278 	if (clnt == NULL) {
279 		close(sock);
280 		for (i = 0; i < cnt; i++)
281 			if (reqs[i] != NULL)
282 				free(reqs[i]);
283 		free(reqs);
284 		return(-1);
285 	}
286 	clnt->cl_auth = authunix_create_default();
287 	cu = (struct cu_data *)clnt->cl_private;
288 	tv.tv_sec = 0;
289 
290 	clnt_control(clnt, CLSET_TIMEOUT, (char *)&tv);
291 	async = TRUE;
292 	clnt_control(clnt, CLSET_ASYNC, (char *)&async);
293 	ioctl(sock, FIONBIO, &dontblock);
294 
295 	/* Transmit */
296 	for (i = 0; i < cnt; i++) {
297 		if (reqs[i] != NULL) {
298 			clnt_control(clnt, CLSET_XID, (char *)&reqs[i]->xid);
299 			bcopy((char *)&reqs[i]->sin, (char *)&cu->cu_raddr,
300 				sizeof(struct sockaddr_in));
301 			ypproc_domain_nonack_2_send(&foo, clnt);
302 		}
303 	}
304 
305 	/* Receive reply */
306 	ypproc_domain_nonack_2_recv(&foo, clnt);
307 
308 	/* Got a winner -- look him up. */
309 	clnt_control(clnt, CLGET_XID, (char *)&xid_lookup);
310 	for (i = 0; i < cnt; i++) {
311 		if (reqs[i] != NULL && reqs[i]->xid == xid_lookup) {
312 			winner = i;
313 			*port = reqs[i]->sin.sin_port;
314 		}
315 	}
316 
317 	/* Shut everything down */
318 	auth_destroy(clnt->cl_auth);
319 	clnt_destroy(clnt);
320 	close(sock);
321 
322 	for (i = 0; i < cnt; i++)
323 		if (reqs[i] != NULL)
324 			free(reqs[i]);
325 	free(reqs);
326 
327 	return(winner);
328 }
329