1/*	$NetBSD: clnt_bcast.c,v 1.3 2000/07/06 03:05:20 christos Exp $	*/
2
3/*-
4 * SPDX-License-Identifier: BSD-3-Clause
5 *
6 * Copyright (c) 2009, Sun Microsystems, Inc.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 * - Redistributions of source code must retain the above copyright notice,
12 *   this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright notice,
14 *   this list of conditions and the following disclaimer in the documentation
15 *   and/or other materials provided with the distribution.
16 * - Neither the name of Sun Microsystems, Inc. nor the names of its
17 *   contributors may be used to endorse or promote products derived
18 *   from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND 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 THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32/*
33 * Copyright (c) 1986-1991 by Sun Microsystems Inc.
34 */
35
36/*
37 * clnt_bcast.c
38 * Client interface to broadcast service.
39 *
40 * Copyright (C) 1988, Sun Microsystems, Inc.
41 *
42 * The following is kludged-up support for simple rpc broadcasts.
43 * Someday a large, complicated system will replace these routines.
44 */
45
46#include "namespace.h"
47#include <sys/types.h>
48#include <sys/socket.h>
49#include <sys/queue.h>
50#include <net/if.h>
51#include <netinet/in.h>
52#include <ifaddrs.h>
53#include <sys/poll.h>
54#include <rpc/rpc.h>
55#ifdef PORTMAP
56#include <rpc/pmap_prot.h>
57#include <rpc/pmap_clnt.h>
58#include <rpc/pmap_rmt.h>
59#endif				/* PORTMAP */
60#include <rpc/nettype.h>
61#include <arpa/inet.h>
62#ifdef RPC_DEBUG
63#include <stdio.h>
64#endif
65#include <errno.h>
66#include <stdlib.h>
67#include <unistd.h>
68#include <netdb.h>
69#include <err.h>
70#include <string.h>
71#include "un-namespace.h"
72
73#include "rpc_com.h"
74
75#define	MAXBCAST 20	/* Max no of broadcasting transports */
76#define	INITTIME 4000	/* Time to wait initially */
77#define	WAITTIME 8000	/* Maximum time to wait */
78
79/*
80 * If nettype is NULL, it broadcasts on all the available
81 * datagram_n transports. May potentially lead to broadacst storms
82 * and hence should be used with caution, care and courage.
83 *
84 * The current parameter xdr packet size is limited by the max tsdu
85 * size of the transport. If the max tsdu size of any transport is
86 * smaller than the parameter xdr packet, then broadcast is not
87 * sent on that transport.
88 *
89 * Also, the packet size should be less the packet size of
90 * the data link layer (for ethernet it is 1400 bytes).  There is
91 * no easy way to find out the max size of the data link layer and
92 * we are assuming that the args would be smaller than that.
93 *
94 * The result size has to be smaller than the transport tsdu size.
95 *
96 * If PORTMAP has been defined, we send two packets for UDP, one for
97 * rpcbind and one for portmap. For those machines which support
98 * both rpcbind and portmap, it will cause them to reply twice, and
99 * also here it will get two responses ... inefficient and clumsy.
100 */
101
102struct broadif {
103	int index;
104	struct sockaddr_storage broadaddr;
105	TAILQ_ENTRY(broadif) link;
106};
107
108typedef TAILQ_HEAD(, broadif) broadlist_t;
109
110int __rpc_getbroadifs(int, int, int, broadlist_t *);
111void __rpc_freebroadifs(broadlist_t *);
112int __rpc_broadenable(int, int, struct broadif *);
113
114int __rpc_lowvers = 0;
115
116int
117__rpc_getbroadifs(int af, int proto, int socktype, broadlist_t *list)
118{
119	int count = 0;
120	struct broadif *bip;
121	struct ifaddrs *ifap, *ifp;
122#ifdef INET6
123	struct sockaddr_in6 *sin6;
124#endif
125	struct sockaddr_in *sin;
126	struct addrinfo hints, *res;
127
128	if (getifaddrs(&ifp) < 0)
129		return 0;
130
131	memset(&hints, 0, sizeof hints);
132
133	hints.ai_family = af;
134	hints.ai_protocol = proto;
135	hints.ai_socktype = socktype;
136
137	if (getaddrinfo(NULL, "sunrpc", &hints, &res) != 0) {
138		freeifaddrs(ifp);
139		return 0;
140	}
141
142	for (ifap = ifp; ifap != NULL; ifap = ifap->ifa_next) {
143		if (ifap->ifa_addr->sa_family != af ||
144		    !(ifap->ifa_flags & IFF_UP))
145			continue;
146		bip = (struct broadif *)malloc(sizeof *bip);
147		if (bip == NULL)
148			break;
149		bip->index = if_nametoindex(ifap->ifa_name);
150		if (
151#ifdef INET6
152		af != AF_INET6 &&
153#endif
154		(ifap->ifa_flags & IFF_BROADCAST) &&
155		 ifap->ifa_broadaddr) {
156			memcpy(&bip->broadaddr, ifap->ifa_broadaddr,
157			    (size_t)ifap->ifa_broadaddr->sa_len);
158			sin = (struct sockaddr_in *)(void *)&bip->broadaddr;
159			sin->sin_port =
160			    ((struct sockaddr_in *)
161			    (void *)res->ai_addr)->sin_port;
162		} else
163#ifdef INET6
164		if (af == AF_INET6 && (ifap->ifa_flags & IFF_MULTICAST)) {
165			sin6 = (struct sockaddr_in6 *)(void *)&bip->broadaddr;
166			inet_pton(af, RPCB_MULTICAST_ADDR, &sin6->sin6_addr);
167			sin6->sin6_family = af;
168			sin6->sin6_len = sizeof *sin6;
169			sin6->sin6_port =
170			    ((struct sockaddr_in6 *)
171			    (void *)res->ai_addr)->sin6_port;
172			sin6->sin6_scope_id = bip->index;
173		} else
174#endif
175		{
176			free(bip);
177			continue;
178		}
179		TAILQ_INSERT_TAIL(list, bip, link);
180		count++;
181	}
182	freeifaddrs(ifp);
183	freeaddrinfo(res);
184
185	return count;
186}
187
188void
189__rpc_freebroadifs(broadlist_t *list)
190{
191	struct broadif *bip, *next;
192
193	bip = TAILQ_FIRST(list);
194
195	while (bip != NULL) {
196		next = TAILQ_NEXT(bip, link);
197		free(bip);
198		bip = next;
199	}
200}
201
202int
203/*ARGSUSED*/
204__rpc_broadenable(int af, int s, struct broadif *bip)
205{
206	int o = 1;
207
208#if 0
209	if (af == AF_INET6) {
210		fprintf(stderr, "set v6 multicast if to %d\n", bip->index);
211		if (_setsockopt(s, IPPROTO_IPV6, IPV6_MULTICAST_IF, &bip->index,
212		    sizeof bip->index) < 0)
213			return -1;
214	} else
215#endif
216		if (_setsockopt(s, SOL_SOCKET, SO_BROADCAST, &o, sizeof o) < 0)
217			return -1;
218
219	return 0;
220}
221
222/*
223 * rpc_broadcast_exp()
224 *
225 * prog      - program number
226 * vers      - version number
227 * proc      - procedure number
228 * xargs     - xdr routine for args
229 * argsp     - pointer to args
230 * xresults  - xdr routine for results
231 * resultsp  - pointer to results
232 * eachresult - call with each result obtained
233 * inittime  - how long to wait initially
234 * waittime  - maximum time to wait
235 * nettype   - transport type
236 */
237enum clnt_stat
238rpc_broadcast_exp(rpcprog_t prog, rpcvers_t vers, rpcproc_t proc,
239    xdrproc_t xargs, caddr_t argsp, xdrproc_t xresults, caddr_t resultsp,
240    resultproc_t eachresult, int inittime, int waittime,
241    const char *nettype)
242{
243	enum clnt_stat	stat = RPC_SUCCESS; /* Return status */
244	XDR 		xdr_stream; /* XDR stream */
245	XDR 		*xdrs = &xdr_stream;
246	struct rpc_msg	msg;	/* RPC message */
247	struct timeval	t;
248	char 		*outbuf = NULL;	/* Broadcast msg buffer */
249	char		*inbuf = NULL; /* Reply buf */
250	int		inlen;
251	u_int 		maxbufsize = 0;
252	AUTH 		*sys_auth = authunix_create_default();
253	u_int		i;
254	void		*handle;
255	char		uaddress[1024];	/* A self imposed limit */
256	char		*uaddrp = uaddress;
257	int 		pmap_reply_flag; /* reply recvd from PORTMAP */
258	/* An array of all the suitable broadcast transports */
259	struct {
260		int fd;		/* File descriptor */
261		int af;
262		int proto;
263		struct netconfig *nconf; /* Netconfig structure */
264		u_int asize;	/* Size of the addr buf */
265		u_int dsize;	/* Size of the data buf */
266		struct sockaddr_storage raddr; /* Remote address */
267		broadlist_t nal;
268	} fdlist[MAXBCAST];
269	struct pollfd pfd[MAXBCAST];
270	size_t fdlistno = 0;
271	struct r_rpcb_rmtcallargs barg;	/* Remote arguments */
272	struct r_rpcb_rmtcallres bres; /* Remote results */
273	size_t outlen;
274	struct netconfig *nconf;
275	int msec;
276	int pollretval;
277	int fds_found;
278
279#ifdef PORTMAP
280	size_t outlen_pmap = 0;
281	u_long port;		/* Remote port number */
282	int pmap_flag = 0;	/* UDP exists ? */
283	char *outbuf_pmap = NULL;
284	struct rmtcallargs barg_pmap;	/* Remote arguments */
285	struct rmtcallres bres_pmap; /* Remote results */
286	u_int udpbufsz = 0;
287#endif				/* PORTMAP */
288
289	if (sys_auth == NULL) {
290		return (RPC_SYSTEMERROR);
291	}
292	/*
293	 * initialization: create a fd, a broadcast address, and send the
294	 * request on the broadcast transport.
295	 * Listen on all of them and on replies, call the user supplied
296	 * function.
297	 */
298
299	if (nettype == NULL)
300		nettype = "datagram_n";
301	if ((handle = __rpc_setconf(nettype)) == NULL) {
302		AUTH_DESTROY(sys_auth);
303		return (RPC_UNKNOWNPROTO);
304	}
305	while ((nconf = __rpc_getconf(handle)) != NULL) {
306		int fd;
307		struct __rpc_sockinfo si;
308
309		if (nconf->nc_semantics != NC_TPI_CLTS)
310			continue;
311		if (fdlistno >= MAXBCAST)
312			break;	/* No more slots available */
313		if (!__rpc_nconf2sockinfo(nconf, &si))
314			continue;
315
316		TAILQ_INIT(&fdlist[fdlistno].nal);
317		if (__rpc_getbroadifs(si.si_af, si.si_proto, si.si_socktype,
318		    &fdlist[fdlistno].nal) == 0)
319			continue;
320
321		fd = _socket(si.si_af, si.si_socktype, si.si_proto);
322		if (fd < 0) {
323			stat = RPC_CANTSEND;
324			continue;
325		}
326		fdlist[fdlistno].af = si.si_af;
327		fdlist[fdlistno].proto = si.si_proto;
328		fdlist[fdlistno].fd = fd;
329		fdlist[fdlistno].nconf = nconf;
330		fdlist[fdlistno].asize = __rpc_get_a_size(si.si_af);
331		pfd[fdlistno].events = POLLIN | POLLPRI |
332			POLLRDNORM | POLLRDBAND;
333		pfd[fdlistno].fd = fdlist[fdlistno].fd = fd;
334		fdlist[fdlistno].dsize = __rpc_get_t_size(si.si_af, si.si_proto,
335							  0);
336
337		if (maxbufsize <= fdlist[fdlistno].dsize)
338			maxbufsize = fdlist[fdlistno].dsize;
339
340#ifdef PORTMAP
341		if (si.si_af == AF_INET && si.si_proto == IPPROTO_UDP) {
342			udpbufsz = fdlist[fdlistno].dsize;
343			outbuf_pmap = reallocf(outbuf_pmap, udpbufsz);
344			if (outbuf_pmap == NULL) {
345				_close(fd);
346				stat = RPC_SYSTEMERROR;
347				goto done_broad;
348			}
349			pmap_flag = 1;
350		}
351#endif				/* PORTMAP */
352		fdlistno++;
353	}
354
355	if (fdlistno == 0) {
356		if (stat == RPC_SUCCESS)
357			stat = RPC_UNKNOWNPROTO;
358		goto done_broad;
359	}
360	if (maxbufsize == 0) {
361		if (stat == RPC_SUCCESS)
362			stat = RPC_CANTSEND;
363		goto done_broad;
364	}
365	inbuf = malloc(maxbufsize);
366	outbuf = malloc(maxbufsize);
367	if ((inbuf == NULL) || (outbuf == NULL)) {
368		stat = RPC_SYSTEMERROR;
369		goto done_broad;
370	}
371
372	/* Serialize all the arguments which have to be sent */
373	(void) gettimeofday(&t, NULL);
374	msg.rm_xid = __RPC_GETXID(&t);
375	msg.rm_direction = CALL;
376	msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
377	msg.rm_call.cb_prog = RPCBPROG;
378	msg.rm_call.cb_vers = RPCBVERS;
379	msg.rm_call.cb_proc = RPCBPROC_CALLIT;
380	barg.prog = prog;
381	barg.vers = vers;
382	barg.proc = proc;
383	barg.args.args_val = argsp;
384	barg.xdr_args = xargs;
385	bres.addr = uaddrp;
386	bres.results.results_val = resultsp;
387	bres.xdr_res = xresults;
388	msg.rm_call.cb_cred = sys_auth->ah_cred;
389	msg.rm_call.cb_verf = sys_auth->ah_verf;
390	xdrmem_create(xdrs, outbuf, maxbufsize, XDR_ENCODE);
391	if ((!xdr_callmsg(xdrs, &msg)) ||
392	    (!xdr_rpcb_rmtcallargs(xdrs,
393	    (struct rpcb_rmtcallargs *)(void *)&barg))) {
394		stat = RPC_CANTENCODEARGS;
395		goto done_broad;
396	}
397	outlen = xdr_getpos(xdrs);
398	xdr_destroy(xdrs);
399
400#ifdef PORTMAP
401	/* Prepare the packet for version 2 PORTMAP */
402	if (pmap_flag) {
403		msg.rm_xid++;	/* One way to distinguish */
404		msg.rm_call.cb_prog = PMAPPROG;
405		msg.rm_call.cb_vers = PMAPVERS;
406		msg.rm_call.cb_proc = PMAPPROC_CALLIT;
407		barg_pmap.prog = prog;
408		barg_pmap.vers = vers;
409		barg_pmap.proc = proc;
410		barg_pmap.args_ptr = argsp;
411		barg_pmap.xdr_args = xargs;
412		bres_pmap.port_ptr = &port;
413		bres_pmap.xdr_results = xresults;
414		bres_pmap.results_ptr = resultsp;
415		xdrmem_create(xdrs, outbuf_pmap, udpbufsz, XDR_ENCODE);
416		if ((! xdr_callmsg(xdrs, &msg)) ||
417		    (! xdr_rmtcall_args(xdrs, &barg_pmap))) {
418			stat = RPC_CANTENCODEARGS;
419			goto done_broad;
420		}
421		outlen_pmap = xdr_getpos(xdrs);
422		xdr_destroy(xdrs);
423	}
424#endif				/* PORTMAP */
425
426	/*
427	 * Basic loop: broadcast the packets to transports which
428	 * support data packets of size such that one can encode
429	 * all the arguments.
430	 * Wait a while for response(s).
431	 * The response timeout grows larger per iteration.
432	 */
433	for (msec = inittime; msec <= waittime; msec += msec) {
434		struct broadif *bip;
435
436		/* Broadcast all the packets now */
437		for (i = 0; i < fdlistno; i++) {
438			if (fdlist[i].dsize < outlen) {
439				stat = RPC_CANTSEND;
440				continue;
441			}
442			for (bip = TAILQ_FIRST(&fdlist[i].nal); bip != NULL;
443			     bip = TAILQ_NEXT(bip, link)) {
444				void *addr;
445
446				addr = &bip->broadaddr;
447
448				__rpc_broadenable(fdlist[i].af, fdlist[i].fd,
449				    bip);
450
451				/*
452				 * Only use version 3 if lowvers is not set
453				 */
454
455				if (!__rpc_lowvers)
456					if (_sendto(fdlist[i].fd, outbuf,
457					    outlen, 0, (struct sockaddr*)addr,
458					    (size_t)fdlist[i].asize) !=
459					    outlen) {
460#ifdef RPC_DEBUG
461						perror("sendto");
462#endif
463						warnx("clnt_bcast: cannot send "
464						      "broadcast packet");
465						stat = RPC_CANTSEND;
466						continue;
467					}
468#ifdef RPC_DEBUG
469				if (!__rpc_lowvers)
470					fprintf(stderr, "Broadcast packet sent "
471						"for %s\n",
472						 fdlist[i].nconf->nc_netid);
473#endif
474#ifdef PORTMAP
475				/*
476				 * Send the version 2 packet also
477				 * for UDP/IP
478				 */
479				if (pmap_flag &&
480				    fdlist[i].proto == IPPROTO_UDP) {
481					if (_sendto(fdlist[i].fd, outbuf_pmap,
482					    outlen_pmap, 0, addr,
483					    (size_t)fdlist[i].asize) !=
484						outlen_pmap) {
485						warnx("clnt_bcast: "
486						    "Cannot send broadcast packet");
487						stat = RPC_CANTSEND;
488						continue;
489					}
490				}
491#ifdef RPC_DEBUG
492				fprintf(stderr, "PMAP Broadcast packet "
493					"sent for %s\n",
494					fdlist[i].nconf->nc_netid);
495#endif
496#endif				/* PORTMAP */
497			}
498			/* End for sending all packets on this transport */
499		}	/* End for sending on all transports */
500
501		if (eachresult == NULL) {
502			stat = RPC_SUCCESS;
503			goto done_broad;
504		}
505
506		/*
507		 * Get all the replies from these broadcast requests
508		 */
509	recv_again:
510
511		switch (pollretval = _poll(pfd, fdlistno, msec)) {
512		case 0:		/* timed out */
513			stat = RPC_TIMEDOUT;
514			continue;
515		case -1:	/* some kind of error - we ignore it */
516			goto recv_again;
517		}		/* end of poll results switch */
518
519		for (i = fds_found = 0;
520		     i < fdlistno && fds_found < pollretval; i++) {
521			bool_t done = FALSE;
522
523			if (pfd[i].revents == 0)
524				continue;
525			else if (pfd[i].revents & POLLNVAL) {
526				/*
527				 * Something bad has happened to this descri-
528				 * ptor. We can cause _poll() to ignore
529				 * it simply by using a negative fd.  We do that
530				 * rather than compacting the pfd[] and fdlist[]
531				 * arrays.
532				 */
533				pfd[i].fd = -1;
534				fds_found++;
535				continue;
536			} else
537				fds_found++;
538#ifdef RPC_DEBUG
539			fprintf(stderr, "response for %s\n",
540				fdlist[i].nconf->nc_netid);
541#endif
542		try_again:
543			inlen = _recvfrom(fdlist[i].fd, inbuf, fdlist[i].dsize,
544			    0, (struct sockaddr *)(void *)&fdlist[i].raddr,
545			    &fdlist[i].asize);
546			if (inlen < 0) {
547				if (errno == EINTR)
548					goto try_again;
549				warnx("clnt_bcast: Cannot receive reply to "
550					"broadcast");
551				stat = RPC_CANTRECV;
552				continue;
553			}
554			if (inlen < sizeof (u_int32_t))
555				continue; /* Drop that and go ahead */
556			/*
557			 * see if reply transaction id matches sent id.
558			 * If so, decode the results. If return id is xid + 1
559			 * it was a PORTMAP reply
560			 */
561			if (*((u_int32_t *)(void *)(inbuf)) ==
562			    *((u_int32_t *)(void *)(outbuf))) {
563				pmap_reply_flag = 0;
564				msg.acpted_rply.ar_verf = _null_auth;
565				msg.acpted_rply.ar_results.where =
566					(caddr_t)(void *)&bres;
567				msg.acpted_rply.ar_results.proc =
568					(xdrproc_t)xdr_rpcb_rmtcallres;
569#ifdef PORTMAP
570			} else if (pmap_flag &&
571				*((u_int32_t *)(void *)(inbuf)) ==
572				*((u_int32_t *)(void *)(outbuf_pmap))) {
573				pmap_reply_flag = 1;
574				msg.acpted_rply.ar_verf = _null_auth;
575				msg.acpted_rply.ar_results.where =
576					(caddr_t)(void *)&bres_pmap;
577				msg.acpted_rply.ar_results.proc =
578					(xdrproc_t)xdr_rmtcallres;
579#endif				/* PORTMAP */
580			} else
581				continue;
582			xdrmem_create(xdrs, inbuf, (u_int)inlen, XDR_DECODE);
583			if (xdr_replymsg(xdrs, &msg)) {
584				if ((msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
585				    (msg.acpted_rply.ar_stat == SUCCESS)) {
586					struct netbuf taddr, *np;
587					struct sockaddr_in *sin;
588
589#ifdef PORTMAP
590					if (pmap_flag && pmap_reply_flag) {
591						sin = (struct sockaddr_in *)
592						    (void *)&fdlist[i].raddr;
593						sin->sin_port =
594						    htons((u_short)port);
595						taddr.len = taddr.maxlen =
596						    fdlist[i].raddr.ss_len;
597						taddr.buf = &fdlist[i].raddr;
598						done = (*eachresult)(resultsp,
599						    &taddr, fdlist[i].nconf);
600					} else {
601#endif				/* PORTMAP */
602#ifdef RPC_DEBUG
603						fprintf(stderr, "uaddr %s\n",
604						    uaddrp);
605#endif
606						np = uaddr2taddr(
607						    fdlist[i].nconf, uaddrp);
608						done = (*eachresult)(resultsp,
609						    np, fdlist[i].nconf);
610						free(np);
611#ifdef PORTMAP
612					}
613#endif				/* PORTMAP */
614				}
615				/* otherwise, we just ignore the errors ... */
616			}
617			/* else some kind of deserialization problem ... */
618
619			xdrs->x_op = XDR_FREE;
620			msg.acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
621			(void) xdr_replymsg(xdrs, &msg);
622			(void) (*xresults)(xdrs, resultsp);
623			XDR_DESTROY(xdrs);
624			if (done) {
625				stat = RPC_SUCCESS;
626				goto done_broad;
627			} else {
628				goto recv_again;
629			}
630		}		/* The recv for loop */
631	}			/* The giant for loop */
632
633done_broad:
634	free(inbuf);
635	free(outbuf);
636#ifdef PORTMAP
637	free(outbuf_pmap);
638#endif				/* PORTMAP */
639	for (i = 0; i < fdlistno; i++) {
640		(void)_close(fdlist[i].fd);
641		__rpc_freebroadifs(&fdlist[i].nal);
642	}
643	AUTH_DESTROY(sys_auth);
644	(void) __rpc_endconf(handle);
645
646	return (stat);
647}
648
649/*
650 * rpc_broadcast()
651 *
652 * prog       - program number
653 * vers       - version number
654 * proc       - procedure number
655 * xargs      - xdr routine for args
656 * argsp      - pointer to args
657 * xresults   - xdr routine for results
658 * resultsp   - pointer to results
659 * eachresult - call with each result obtained
660 * nettype    - transport type
661 */
662enum clnt_stat
663rpc_broadcast(rpcprog_t prog, rpcvers_t vers, rpcproc_t proc, xdrproc_t xargs,
664    caddr_t argsp, xdrproc_t xresults, caddr_t resultsp,
665    resultproc_t eachresult, const char *nettype)
666{
667	enum clnt_stat	dummy;
668
669	dummy = rpc_broadcast_exp(prog, vers, proc, xargs, argsp,
670		xresults, resultsp, eachresult,
671		INITTIME, WAITTIME, nettype);
672	return (dummy);
673}
674