xref: /freebsd/lib/libc/rpc/clnt_dg.c (revision f4a180cc7b3787b49069ac02de81bd53d88e8621)
18360efbdSAlfred Perlstein /*	$NetBSD: clnt_dg.c,v 1.4 2000/07/14 08:40:41 fvdl Exp $	*/
28360efbdSAlfred Perlstein 
38360efbdSAlfred Perlstein /*
48360efbdSAlfred Perlstein  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
58360efbdSAlfred Perlstein  * unrestricted use provided that this legend is included on all tape
68360efbdSAlfred Perlstein  * media and as a part of the software program in whole or part.  Users
78360efbdSAlfred Perlstein  * may copy or modify Sun RPC without charge, but are not authorized
88360efbdSAlfred Perlstein  * to license or distribute it to anyone else except as part of a product or
98360efbdSAlfred Perlstein  * program developed by the user.
108360efbdSAlfred Perlstein  *
118360efbdSAlfred Perlstein  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
128360efbdSAlfred Perlstein  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
138360efbdSAlfred Perlstein  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
148360efbdSAlfred Perlstein  *
158360efbdSAlfred Perlstein  * Sun RPC is provided with no support and without any obligation on the
168360efbdSAlfred Perlstein  * part of Sun Microsystems, Inc. to assist in its use, correction,
178360efbdSAlfred Perlstein  * modification or enhancement.
188360efbdSAlfred Perlstein  *
198360efbdSAlfred Perlstein  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
208360efbdSAlfred Perlstein  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
218360efbdSAlfred Perlstein  * OR ANY PART THEREOF.
228360efbdSAlfred Perlstein  *
238360efbdSAlfred Perlstein  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
248360efbdSAlfred Perlstein  * or profits or other special, indirect and consequential damages, even if
258360efbdSAlfred Perlstein  * Sun has been advised of the possibility of such damages.
268360efbdSAlfred Perlstein  *
278360efbdSAlfred Perlstein  * Sun Microsystems, Inc.
288360efbdSAlfred Perlstein  * 2550 Garcia Avenue
298360efbdSAlfred Perlstein  * Mountain View, California  94043
308360efbdSAlfred Perlstein  */
318360efbdSAlfred Perlstein /*
328360efbdSAlfred Perlstein  * Copyright (c) 1986-1991 by Sun Microsystems Inc.
338360efbdSAlfred Perlstein  */
348360efbdSAlfred Perlstein 
358360efbdSAlfred Perlstein /* #ident	"@(#)clnt_dg.c	1.23	94/04/22 SMI" */
368360efbdSAlfred Perlstein 
378360efbdSAlfred Perlstein #if !defined(lint) && defined(SCCSIDS)
388360efbdSAlfred Perlstein static char sccsid[] = "@(#)clnt_dg.c 1.19 89/03/16 Copyr 1988 Sun Micro";
398360efbdSAlfred Perlstein #endif
40d3d20c82SDavid E. O'Brien #include <sys/cdefs.h>
41d3d20c82SDavid E. O'Brien __FBSDID("$FreeBSD$");
428360efbdSAlfred Perlstein 
438360efbdSAlfred Perlstein /*
448360efbdSAlfred Perlstein  * Implements a connectionless client side RPC.
458360efbdSAlfred Perlstein  */
468360efbdSAlfred Perlstein 
478360efbdSAlfred Perlstein #include "namespace.h"
489f5afc13SIan Dowse #include "reentrant.h"
498360efbdSAlfred Perlstein #include <sys/types.h>
50d7cd6ba3SIan Dowse #include <sys/event.h>
518360efbdSAlfred Perlstein #include <sys/time.h>
528360efbdSAlfred Perlstein #include <sys/socket.h>
538360efbdSAlfred Perlstein #include <sys/ioctl.h>
54fd8e4ebcSMike Barcroft #include <arpa/inet.h>
558360efbdSAlfred Perlstein #include <rpc/rpc.h>
568360efbdSAlfred Perlstein #include <errno.h>
578360efbdSAlfred Perlstein #include <stdlib.h>
588360efbdSAlfred Perlstein #include <string.h>
598360efbdSAlfred Perlstein #include <signal.h>
608360efbdSAlfred Perlstein #include <unistd.h>
618360efbdSAlfred Perlstein #include <err.h>
628360efbdSAlfred Perlstein #include "un-namespace.h"
638360efbdSAlfred Perlstein #include "rpc_com.h"
648360efbdSAlfred Perlstein 
658360efbdSAlfred Perlstein 
668360efbdSAlfred Perlstein #define	RPC_MAX_BACKOFF		30 /* seconds */
678360efbdSAlfred Perlstein 
688360efbdSAlfred Perlstein 
69c05ac53bSDavid E. O'Brien static struct clnt_ops *clnt_dg_ops(void);
70c05ac53bSDavid E. O'Brien static bool_t time_not_ok(struct timeval *);
71f249dbccSDag-Erling Smørgrav static enum clnt_stat clnt_dg_call(CLIENT *, rpcproc_t, xdrproc_t, void *,
72f249dbccSDag-Erling Smørgrav 	    xdrproc_t, void *, struct timeval);
73c05ac53bSDavid E. O'Brien static void clnt_dg_geterr(CLIENT *, struct rpc_err *);
74f249dbccSDag-Erling Smørgrav static bool_t clnt_dg_freeres(CLIENT *, xdrproc_t, void *);
75c05ac53bSDavid E. O'Brien static void clnt_dg_abort(CLIENT *);
76cffc0b57SAlfred Perlstein static bool_t clnt_dg_control(CLIENT *, u_int, void *);
77c05ac53bSDavid E. O'Brien static void clnt_dg_destroy(CLIENT *);
788360efbdSAlfred Perlstein 
798360efbdSAlfred Perlstein 
808360efbdSAlfred Perlstein 
818360efbdSAlfred Perlstein 
828360efbdSAlfred Perlstein /*
838360efbdSAlfred Perlstein  *	This machinery implements per-fd locks for MT-safety.  It is not
848360efbdSAlfred Perlstein  *	sufficient to do per-CLIENT handle locks for MT-safety because a
858360efbdSAlfred Perlstein  *	user may create more than one CLIENT handle with the same fd behind
868360efbdSAlfred Perlstein  *	it.  Therfore, we allocate an array of flags (dg_fd_locks), protected
878360efbdSAlfred Perlstein  *	by the clnt_fd_lock mutex, and an array (dg_cv) of condition variables
888360efbdSAlfred Perlstein  *	similarly protected.  Dg_fd_lock[fd] == 1 => a call is activte on some
898360efbdSAlfred Perlstein  *	CLIENT handle created for that fd.
908360efbdSAlfred Perlstein  *	The current implementation holds locks across the entire RPC and reply,
918360efbdSAlfred Perlstein  *	including retransmissions.  Yes, this is silly, and as soon as this
928360efbdSAlfred Perlstein  *	code is proven to work, this should be the first thing fixed.  One step
938360efbdSAlfred Perlstein  *	at a time.
948360efbdSAlfred Perlstein  */
958360efbdSAlfred Perlstein static int	*dg_fd_locks;
968360efbdSAlfred Perlstein extern mutex_t clnt_fd_lock;
978360efbdSAlfred Perlstein static cond_t	*dg_cv;
988360efbdSAlfred Perlstein #define	release_fd_lock(fd, mask) {		\
998360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);	\
1008360efbdSAlfred Perlstein 	dg_fd_locks[fd] = 0;		\
1018360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);	\
102d7cd6ba3SIan Dowse 	thr_sigsetmask(SIG_SETMASK, &(mask), NULL); \
1038360efbdSAlfred Perlstein 	cond_signal(&dg_cv[fd]);	\
1048360efbdSAlfred Perlstein }
1058360efbdSAlfred Perlstein 
1068360efbdSAlfred Perlstein static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory";
1078360efbdSAlfred Perlstein 
1088360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY clnt_fd_lock: dg_fd_locks, dg_cv */
1098360efbdSAlfred Perlstein 
1108360efbdSAlfred Perlstein /*
1118360efbdSAlfred Perlstein  * Private data kept per client handle
1128360efbdSAlfred Perlstein  */
1138360efbdSAlfred Perlstein struct cu_data {
1148360efbdSAlfred Perlstein 	int			cu_fd;		/* connections fd */
1158360efbdSAlfred Perlstein 	bool_t			cu_closeit;	/* opened by library */
1168360efbdSAlfred Perlstein 	struct sockaddr_storage	cu_raddr;	/* remote address */
1178360efbdSAlfred Perlstein 	int			cu_rlen;
1188360efbdSAlfred Perlstein 	struct timeval		cu_wait;	/* retransmit interval */
1198360efbdSAlfred Perlstein 	struct timeval		cu_total;	/* total time for the call */
1208360efbdSAlfred Perlstein 	struct rpc_err		cu_error;
1218360efbdSAlfred Perlstein 	XDR			cu_outxdrs;
1228360efbdSAlfred Perlstein 	u_int			cu_xdrpos;
1238360efbdSAlfred Perlstein 	u_int			cu_sendsz;	/* send size */
1248360efbdSAlfred Perlstein 	char			*cu_outbuf;
1258360efbdSAlfred Perlstein 	u_int			cu_recvsz;	/* recv size */
12665d3c627SBill Paul 	int			cu_async;
12732de72d2SIan Dowse 	int			cu_connect;	/* Use connect(). */
12832de72d2SIan Dowse 	int			cu_connected;	/* Have done connect(). */
129d7cd6ba3SIan Dowse 	struct kevent		cu_kin;
130d7cd6ba3SIan Dowse 	int			cu_kq;
1318360efbdSAlfred Perlstein 	char			cu_inbuf[1];
1328360efbdSAlfred Perlstein };
1338360efbdSAlfred Perlstein 
1348360efbdSAlfred Perlstein /*
1358360efbdSAlfred Perlstein  * Connection less client creation returns with client handle parameters.
1368360efbdSAlfred Perlstein  * Default options are set, which the user can change using clnt_control().
1378360efbdSAlfred Perlstein  * fd should be open and bound.
1388360efbdSAlfred Perlstein  * NB: The rpch->cl_auth is initialized to null authentication.
1398360efbdSAlfred Perlstein  * 	Caller may wish to set this something more useful.
1408360efbdSAlfred Perlstein  *
1418360efbdSAlfred Perlstein  * sendsz and recvsz are the maximum allowable packet sizes that can be
1428360efbdSAlfred Perlstein  * sent and received. Normally they are the same, but they can be
1438360efbdSAlfred Perlstein  * changed to improve the program efficiency and buffer allocation.
1448360efbdSAlfred Perlstein  * If they are 0, use the transport default.
1458360efbdSAlfred Perlstein  *
1468360efbdSAlfred Perlstein  * If svcaddr is NULL, returns NULL.
1478360efbdSAlfred Perlstein  */
1488360efbdSAlfred Perlstein CLIENT *
1498360efbdSAlfred Perlstein clnt_dg_create(fd, svcaddr, program, version, sendsz, recvsz)
1508360efbdSAlfred Perlstein 	int fd;				/* open file descriptor */
1518360efbdSAlfred Perlstein 	const struct netbuf *svcaddr;	/* servers address */
1528360efbdSAlfred Perlstein 	rpcprog_t program;		/* program number */
1538360efbdSAlfred Perlstein 	rpcvers_t version;		/* version number */
1548360efbdSAlfred Perlstein 	u_int sendsz;			/* buffer recv size */
1558360efbdSAlfred Perlstein 	u_int recvsz;			/* buffer send size */
1568360efbdSAlfred Perlstein {
1578360efbdSAlfred Perlstein 	CLIENT *cl = NULL;		/* client handle */
1588360efbdSAlfred Perlstein 	struct cu_data *cu = NULL;	/* private data */
1598360efbdSAlfred Perlstein 	struct timeval now;
1608360efbdSAlfred Perlstein 	struct rpc_msg call_msg;
1618360efbdSAlfred Perlstein 	sigset_t mask;
1628360efbdSAlfred Perlstein 	sigset_t newmask;
1638360efbdSAlfred Perlstein 	struct __rpc_sockinfo si;
1648360efbdSAlfred Perlstein 	int one = 1;
1658360efbdSAlfred Perlstein 
1668360efbdSAlfred Perlstein 	sigfillset(&newmask);
1678360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
1688360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
1698360efbdSAlfred Perlstein 	if (dg_fd_locks == (int *) NULL) {
1708360efbdSAlfred Perlstein 		int cv_allocsz;
1718360efbdSAlfred Perlstein 		size_t fd_allocsz;
1728360efbdSAlfred Perlstein 		int dtbsize = __rpc_dtbsize();
1738360efbdSAlfred Perlstein 
1748360efbdSAlfred Perlstein 		fd_allocsz = dtbsize * sizeof (int);
1758360efbdSAlfred Perlstein 		dg_fd_locks = (int *) mem_alloc(fd_allocsz);
1768360efbdSAlfred Perlstein 		if (dg_fd_locks == (int *) NULL) {
1778360efbdSAlfred Perlstein 			mutex_unlock(&clnt_fd_lock);
1788360efbdSAlfred Perlstein 			thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
1798360efbdSAlfred Perlstein 			goto err1;
1808360efbdSAlfred Perlstein 		} else
1818360efbdSAlfred Perlstein 			memset(dg_fd_locks, '\0', fd_allocsz);
1828360efbdSAlfred Perlstein 
1838360efbdSAlfred Perlstein 		cv_allocsz = dtbsize * sizeof (cond_t);
1848360efbdSAlfred Perlstein 		dg_cv = (cond_t *) mem_alloc(cv_allocsz);
1858360efbdSAlfred Perlstein 		if (dg_cv == (cond_t *) NULL) {
1868360efbdSAlfred Perlstein 			mem_free(dg_fd_locks, fd_allocsz);
1878360efbdSAlfred Perlstein 			dg_fd_locks = (int *) NULL;
1888360efbdSAlfred Perlstein 			mutex_unlock(&clnt_fd_lock);
1898360efbdSAlfred Perlstein 			thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
1908360efbdSAlfred Perlstein 			goto err1;
1918360efbdSAlfred Perlstein 		} else {
1928360efbdSAlfred Perlstein 			int i;
1938360efbdSAlfred Perlstein 
1948360efbdSAlfred Perlstein 			for (i = 0; i < dtbsize; i++)
1958360efbdSAlfred Perlstein 				cond_init(&dg_cv[i], 0, (void *) 0);
1968360efbdSAlfred Perlstein 		}
1978360efbdSAlfred Perlstein 	}
1988360efbdSAlfred Perlstein 
1998360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
2008360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
2018360efbdSAlfred Perlstein 
2028360efbdSAlfred Perlstein 	if (svcaddr == NULL) {
2038360efbdSAlfred Perlstein 		rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
2048360efbdSAlfred Perlstein 		return (NULL);
2058360efbdSAlfred Perlstein 	}
2068360efbdSAlfred Perlstein 
2078360efbdSAlfred Perlstein 	if (!__rpc_fd2sockinfo(fd, &si)) {
2088360efbdSAlfred Perlstein 		rpc_createerr.cf_stat = RPC_TLIERROR;
2098360efbdSAlfred Perlstein 		rpc_createerr.cf_error.re_errno = 0;
2108360efbdSAlfred Perlstein 		return (NULL);
2118360efbdSAlfred Perlstein 	}
2128360efbdSAlfred Perlstein 	/*
2138360efbdSAlfred Perlstein 	 * Find the receive and the send size
2148360efbdSAlfred Perlstein 	 */
2158360efbdSAlfred Perlstein 	sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz);
2168360efbdSAlfred Perlstein 	recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz);
2178360efbdSAlfred Perlstein 	if ((sendsz == 0) || (recvsz == 0)) {
2188360efbdSAlfred Perlstein 		rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
2198360efbdSAlfred Perlstein 		rpc_createerr.cf_error.re_errno = 0;
2208360efbdSAlfred Perlstein 		return (NULL);
2218360efbdSAlfred Perlstein 	}
2228360efbdSAlfred Perlstein 
2238360efbdSAlfred Perlstein 	if ((cl = mem_alloc(sizeof (CLIENT))) == NULL)
2248360efbdSAlfred Perlstein 		goto err1;
2258360efbdSAlfred Perlstein 	/*
2268360efbdSAlfred Perlstein 	 * Should be multiple of 4 for XDR.
2278360efbdSAlfred Perlstein 	 */
2288360efbdSAlfred Perlstein 	sendsz = ((sendsz + 3) / 4) * 4;
2298360efbdSAlfred Perlstein 	recvsz = ((recvsz + 3) / 4) * 4;
2308360efbdSAlfred Perlstein 	cu = mem_alloc(sizeof (*cu) + sendsz + recvsz);
2318360efbdSAlfred Perlstein 	if (cu == NULL)
2328360efbdSAlfred Perlstein 		goto err1;
2338360efbdSAlfred Perlstein 	(void) memcpy(&cu->cu_raddr, svcaddr->buf, (size_t)svcaddr->len);
2348360efbdSAlfred Perlstein 	cu->cu_rlen = svcaddr->len;
2358360efbdSAlfred Perlstein 	cu->cu_outbuf = &cu->cu_inbuf[recvsz];
2368360efbdSAlfred Perlstein 	/* Other values can also be set through clnt_control() */
2378360efbdSAlfred Perlstein 	cu->cu_wait.tv_sec = 15;	/* heuristically chosen */
2388360efbdSAlfred Perlstein 	cu->cu_wait.tv_usec = 0;
2398360efbdSAlfred Perlstein 	cu->cu_total.tv_sec = -1;
2408360efbdSAlfred Perlstein 	cu->cu_total.tv_usec = -1;
2418360efbdSAlfred Perlstein 	cu->cu_sendsz = sendsz;
2428360efbdSAlfred Perlstein 	cu->cu_recvsz = recvsz;
24365d3c627SBill Paul 	cu->cu_async = FALSE;
24432de72d2SIan Dowse 	cu->cu_connect = FALSE;
24532de72d2SIan Dowse 	cu->cu_connected = FALSE;
2468360efbdSAlfred Perlstein 	(void) gettimeofday(&now, NULL);
2478360efbdSAlfred Perlstein 	call_msg.rm_xid = __RPC_GETXID(&now);
2488360efbdSAlfred Perlstein 	call_msg.rm_call.cb_prog = program;
2498360efbdSAlfred Perlstein 	call_msg.rm_call.cb_vers = version;
2508360efbdSAlfred Perlstein 	xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE);
2518360efbdSAlfred Perlstein 	if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
2528360efbdSAlfred Perlstein 		rpc_createerr.cf_stat = RPC_CANTENCODEARGS;  /* XXX */
2538360efbdSAlfred Perlstein 		rpc_createerr.cf_error.re_errno = 0;
2548360efbdSAlfred Perlstein 		goto err2;
2558360efbdSAlfred Perlstein 	}
2568360efbdSAlfred Perlstein 	cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
2578360efbdSAlfred Perlstein 
2588360efbdSAlfred Perlstein 	/* XXX fvdl - do we still want this? */
2598360efbdSAlfred Perlstein #if 0
2608360efbdSAlfred Perlstein 	(void)bindresvport_sa(fd, (struct sockaddr *)svcaddr->buf);
2618360efbdSAlfred Perlstein #endif
2628360efbdSAlfred Perlstein 	_ioctl(fd, FIONBIO, (char *)(void *)&one);
2638360efbdSAlfred Perlstein 
2648360efbdSAlfred Perlstein 	/*
2658360efbdSAlfred Perlstein 	 * By default, closeit is always FALSE. It is users responsibility
2668360efbdSAlfred Perlstein 	 * to do a close on it, else the user may use clnt_control
2678360efbdSAlfred Perlstein 	 * to let clnt_destroy do it for him/her.
2688360efbdSAlfred Perlstein 	 */
2698360efbdSAlfred Perlstein 	cu->cu_closeit = FALSE;
2708360efbdSAlfred Perlstein 	cu->cu_fd = fd;
2718360efbdSAlfred Perlstein 	cl->cl_ops = clnt_dg_ops();
2728360efbdSAlfred Perlstein 	cl->cl_private = (caddr_t)(void *)cu;
2738360efbdSAlfred Perlstein 	cl->cl_auth = authnone_create();
2748360efbdSAlfred Perlstein 	cl->cl_tp = NULL;
2758360efbdSAlfred Perlstein 	cl->cl_netid = NULL;
276d7cd6ba3SIan Dowse 	cu->cu_kq = -1;
277d7cd6ba3SIan Dowse 	EV_SET(&cu->cu_kin, cu->cu_fd, EVFILT_READ, EV_ADD, 0, 0, 0);
2788360efbdSAlfred Perlstein 	return (cl);
2798360efbdSAlfred Perlstein err1:
2808360efbdSAlfred Perlstein 	warnx(mem_err_clnt_dg);
2818360efbdSAlfred Perlstein 	rpc_createerr.cf_stat = RPC_SYSTEMERROR;
2828360efbdSAlfred Perlstein 	rpc_createerr.cf_error.re_errno = errno;
2838360efbdSAlfred Perlstein err2:
2848360efbdSAlfred Perlstein 	if (cl) {
2858360efbdSAlfred Perlstein 		mem_free(cl, sizeof (CLIENT));
2868360efbdSAlfred Perlstein 		if (cu)
2878360efbdSAlfred Perlstein 			mem_free(cu, sizeof (*cu) + sendsz + recvsz);
2888360efbdSAlfred Perlstein 	}
2898360efbdSAlfred Perlstein 	return (NULL);
2908360efbdSAlfred Perlstein }
2918360efbdSAlfred Perlstein 
2928360efbdSAlfred Perlstein static enum clnt_stat
2938360efbdSAlfred Perlstein clnt_dg_call(cl, proc, xargs, argsp, xresults, resultsp, utimeout)
2948360efbdSAlfred Perlstein 	CLIENT	*cl;			/* client handle */
2958360efbdSAlfred Perlstein 	rpcproc_t	proc;		/* procedure number */
2968360efbdSAlfred Perlstein 	xdrproc_t	xargs;		/* xdr routine for args */
297f249dbccSDag-Erling Smørgrav 	void		*argsp;		/* pointer to args */
2988360efbdSAlfred Perlstein 	xdrproc_t	xresults;	/* xdr routine for results */
299f249dbccSDag-Erling Smørgrav 	void		*resultsp;	/* pointer to results */
3008360efbdSAlfred Perlstein 	struct timeval	utimeout;	/* seconds to wait before giving up */
3018360efbdSAlfred Perlstein {
3028360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
3038360efbdSAlfred Perlstein 	XDR *xdrs;
304d7cd6ba3SIan Dowse 	size_t outlen = 0;
3058360efbdSAlfred Perlstein 	struct rpc_msg reply_msg;
3068360efbdSAlfred Perlstein 	XDR reply_xdrs;
3078360efbdSAlfred Perlstein 	bool_t ok;
3088360efbdSAlfred Perlstein 	int nrefreshes = 2;		/* number of times to refresh cred */
3098360efbdSAlfred Perlstein 	struct timeval timeout;
3108360efbdSAlfred Perlstein 	struct timeval retransmit_time;
311d7cd6ba3SIan Dowse 	struct timeval next_sendtime, starttime, time_waited, tv;
312d7cd6ba3SIan Dowse 	struct timespec ts;
313d7cd6ba3SIan Dowse 	struct kevent kv;
31432de72d2SIan Dowse 	struct sockaddr *sa;
3158360efbdSAlfred Perlstein 	sigset_t mask;
3168360efbdSAlfred Perlstein 	sigset_t newmask;
31732de72d2SIan Dowse 	socklen_t inlen, salen;
3188360efbdSAlfred Perlstein 	ssize_t recvlen = 0;
319d7cd6ba3SIan Dowse 	int kin_len, n, rpc_lock_value;
32065d3c627SBill Paul 	u_int32_t xid;
3218360efbdSAlfred Perlstein 
3228d630135SAlfred Perlstein 	outlen = 0;
3238360efbdSAlfred Perlstein 	sigfillset(&newmask);
3248360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
3258360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
3268360efbdSAlfred Perlstein 	while (dg_fd_locks[cu->cu_fd])
3278360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
3288360efbdSAlfred Perlstein 	if (__isthreaded)
3298360efbdSAlfred Perlstein 		rpc_lock_value = 1;
3308360efbdSAlfred Perlstein 	else
3318360efbdSAlfred Perlstein 		rpc_lock_value = 0;
3328360efbdSAlfred Perlstein 	dg_fd_locks[cu->cu_fd] = rpc_lock_value;
3338360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
3348360efbdSAlfred Perlstein 	if (cu->cu_total.tv_usec == -1) {
3358360efbdSAlfred Perlstein 		timeout = utimeout;	/* use supplied timeout */
3368360efbdSAlfred Perlstein 	} else {
3378360efbdSAlfred Perlstein 		timeout = cu->cu_total;	/* use default timeout */
3388360efbdSAlfred Perlstein 	}
3398360efbdSAlfred Perlstein 
34032de72d2SIan Dowse 	if (cu->cu_connect && !cu->cu_connected) {
34132de72d2SIan Dowse 		if (_connect(cu->cu_fd, (struct sockaddr *)&cu->cu_raddr,
34232de72d2SIan Dowse 		    cu->cu_rlen) < 0) {
34332de72d2SIan Dowse 			cu->cu_error.re_errno = errno;
344d7cd6ba3SIan Dowse 			cu->cu_error.re_status = RPC_CANTSEND;
345d7cd6ba3SIan Dowse 			goto out;
34632de72d2SIan Dowse 		}
34732de72d2SIan Dowse 		cu->cu_connected = 1;
34832de72d2SIan Dowse 	}
34932de72d2SIan Dowse 	if (cu->cu_connected) {
35032de72d2SIan Dowse 		sa = NULL;
35132de72d2SIan Dowse 		salen = 0;
35232de72d2SIan Dowse 	} else {
35332de72d2SIan Dowse 		sa = (struct sockaddr *)&cu->cu_raddr;
35432de72d2SIan Dowse 		salen = cu->cu_rlen;
35532de72d2SIan Dowse 	}
3568360efbdSAlfred Perlstein 	time_waited.tv_sec = 0;
3578360efbdSAlfred Perlstein 	time_waited.tv_usec = 0;
358d7cd6ba3SIan Dowse 	retransmit_time = next_sendtime = cu->cu_wait;
359d7cd6ba3SIan Dowse 	gettimeofday(&starttime, NULL);
360d7cd6ba3SIan Dowse 
361d7cd6ba3SIan Dowse 	/* Clean up in case the last call ended in a longjmp(3) call. */
362d7cd6ba3SIan Dowse 	if (cu->cu_kq >= 0)
363d7cd6ba3SIan Dowse 		_close(cu->cu_kq);
364d7cd6ba3SIan Dowse 	if ((cu->cu_kq = kqueue()) < 0) {
365d7cd6ba3SIan Dowse 		cu->cu_error.re_errno = errno;
366d7cd6ba3SIan Dowse 		cu->cu_error.re_status = RPC_CANTSEND;
367d7cd6ba3SIan Dowse 		goto out;
368d7cd6ba3SIan Dowse 	}
369d7cd6ba3SIan Dowse 	kin_len = 1;
3708360efbdSAlfred Perlstein 
3718360efbdSAlfred Perlstein call_again:
3728360efbdSAlfred Perlstein 	xdrs = &(cu->cu_outxdrs);
37365d3c627SBill Paul 	if (cu->cu_async == TRUE && xargs == NULL)
37465d3c627SBill Paul 		goto get_reply;
3758360efbdSAlfred Perlstein 	xdrs->x_op = XDR_ENCODE;
3768360efbdSAlfred Perlstein 	XDR_SETPOS(xdrs, cu->cu_xdrpos);
3778360efbdSAlfred Perlstein 	/*
3788360efbdSAlfred Perlstein 	 * the transaction is the first thing in the out buffer
37965d3c627SBill Paul 	 * XXX Yes, and it's in network byte order, so we should to
38065d3c627SBill Paul 	 * be careful when we increment it, shouldn't we.
3818360efbdSAlfred Perlstein 	 */
38265d3c627SBill Paul 	xid = ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf));
38365d3c627SBill Paul 	xid++;
38465d3c627SBill Paul 	*(u_int32_t *)(void *)(cu->cu_outbuf) = htonl(xid);
38565d3c627SBill Paul 
3868360efbdSAlfred Perlstein 	if ((! XDR_PUTINT32(xdrs, &proc)) ||
3878360efbdSAlfred Perlstein 	    (! AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
3888360efbdSAlfred Perlstein 	    (! (*xargs)(xdrs, argsp))) {
389d7cd6ba3SIan Dowse 		cu->cu_error.re_status = RPC_CANTENCODEARGS;
390d7cd6ba3SIan Dowse 		goto out;
3918360efbdSAlfred Perlstein 	}
3928360efbdSAlfred Perlstein 	outlen = (size_t)XDR_GETPOS(xdrs);
3938360efbdSAlfred Perlstein 
3948360efbdSAlfred Perlstein send_again:
39532de72d2SIan Dowse 	if (_sendto(cu->cu_fd, cu->cu_outbuf, outlen, 0, sa, salen) != outlen) {
3968360efbdSAlfred Perlstein 		cu->cu_error.re_errno = errno;
397d7cd6ba3SIan Dowse 		cu->cu_error.re_status = RPC_CANTSEND;
398d7cd6ba3SIan Dowse 		goto out;
3998360efbdSAlfred Perlstein 	}
4008360efbdSAlfred Perlstein 
4018360efbdSAlfred Perlstein 	/*
4028360efbdSAlfred Perlstein 	 * Hack to provide rpc-based message passing
4038360efbdSAlfred Perlstein 	 */
4048360efbdSAlfred Perlstein 	if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
405d7cd6ba3SIan Dowse 		cu->cu_error.re_status = RPC_TIMEDOUT;
406d7cd6ba3SIan Dowse 		goto out;
4078360efbdSAlfred Perlstein 	}
40865d3c627SBill Paul 
40965d3c627SBill Paul get_reply:
41065d3c627SBill Paul 
4118360efbdSAlfred Perlstein 	/*
4128360efbdSAlfred Perlstein 	 * sub-optimal code appears here because we have
4138360efbdSAlfred Perlstein 	 * some clock time to spare while the packets are in flight.
4148360efbdSAlfred Perlstein 	 * (We assume that this is actually only executed once.)
4158360efbdSAlfred Perlstein 	 */
4168360efbdSAlfred Perlstein 	reply_msg.acpted_rply.ar_verf = _null_auth;
4178360efbdSAlfred Perlstein 	reply_msg.acpted_rply.ar_results.where = resultsp;
4188360efbdSAlfred Perlstein 	reply_msg.acpted_rply.ar_results.proc = xresults;
4198360efbdSAlfred Perlstein 
4208360efbdSAlfred Perlstein 	for (;;) {
421d7cd6ba3SIan Dowse 		/* Decide how long to wait. */
422d7cd6ba3SIan Dowse 		if (timercmp(&next_sendtime, &timeout, <))
423d7cd6ba3SIan Dowse 			timersub(&next_sendtime, &time_waited, &tv);
424d7cd6ba3SIan Dowse 		else
425d7cd6ba3SIan Dowse 			timersub(&timeout, &time_waited, &tv);
426d7cd6ba3SIan Dowse 		if (tv.tv_sec < 0 || tv.tv_usec < 0)
427d7cd6ba3SIan Dowse 			tv.tv_sec = tv.tv_usec = 0;
428d7cd6ba3SIan Dowse 		TIMEVAL_TO_TIMESPEC(&tv, &ts);
4298360efbdSAlfred Perlstein 
430d7cd6ba3SIan Dowse 		n = _kevent(cu->cu_kq, &cu->cu_kin, kin_len, &kv, 1, &ts);
431d7cd6ba3SIan Dowse 		/* We don't need to register the event again. */
432d7cd6ba3SIan Dowse 		kin_len = 0;
4338360efbdSAlfred Perlstein 
434d7cd6ba3SIan Dowse 		if (n == 1) {
435d7cd6ba3SIan Dowse 			if (kv.flags & EV_ERROR) {
436d7cd6ba3SIan Dowse 				cu->cu_error.re_errno = kv.data;
4378360efbdSAlfred Perlstein 				cu->cu_error.re_status = RPC_CANTRECV;
438d7cd6ba3SIan Dowse 				goto out;
4398360efbdSAlfred Perlstein 			}
4408360efbdSAlfred Perlstein 			/* We have some data now */
4418360efbdSAlfred Perlstein 			do {
4428360efbdSAlfred Perlstein 				recvlen = _recvfrom(cu->cu_fd, cu->cu_inbuf,
443a9d09e93SIan Dowse 				    cu->cu_recvsz, 0, NULL, NULL);
4448360efbdSAlfred Perlstein 			} while (recvlen < 0 && errno == EINTR);
445d7cd6ba3SIan Dowse 			if (recvlen < 0 && errno != EWOULDBLOCK) {
4468360efbdSAlfred Perlstein 				cu->cu_error.re_errno = errno;
447d7cd6ba3SIan Dowse 				cu->cu_error.re_status = RPC_CANTRECV;
448d7cd6ba3SIan Dowse 				goto out;
4498360efbdSAlfred Perlstein 			}
450d7cd6ba3SIan Dowse 			if (recvlen >= sizeof(u_int32_t) &&
451d7cd6ba3SIan Dowse 			    (cu->cu_async == TRUE ||
452d7cd6ba3SIan Dowse 			    *((u_int32_t *)(void *)(cu->cu_inbuf)) ==
453d7cd6ba3SIan Dowse 			    *((u_int32_t *)(void *)(cu->cu_outbuf)))) {
454d7cd6ba3SIan Dowse 				/* We now assume we have the proper reply. */
4558360efbdSAlfred Perlstein 				break;
4568360efbdSAlfred Perlstein 			}
457d7cd6ba3SIan Dowse 		}
458d7cd6ba3SIan Dowse 		if (n == -1 && errno != EINTR) {
459d7cd6ba3SIan Dowse 			cu->cu_error.re_errno = errno;
460d7cd6ba3SIan Dowse 			cu->cu_error.re_status = RPC_CANTRECV;
461d7cd6ba3SIan Dowse 			goto out;
462d7cd6ba3SIan Dowse 		}
463d7cd6ba3SIan Dowse 		gettimeofday(&tv, NULL);
464d7cd6ba3SIan Dowse 		timersub(&tv, &starttime, &time_waited);
465d7cd6ba3SIan Dowse 
466d7cd6ba3SIan Dowse 		/* Check for timeout. */
467d7cd6ba3SIan Dowse 		if (timercmp(&time_waited, &timeout, >)) {
468d7cd6ba3SIan Dowse 			cu->cu_error.re_status = RPC_TIMEDOUT;
469d7cd6ba3SIan Dowse 			goto out;
470d7cd6ba3SIan Dowse 		}
471d7cd6ba3SIan Dowse 
472d7cd6ba3SIan Dowse 		/* Retransmit if necessary. */
473d7cd6ba3SIan Dowse 		if (timercmp(&time_waited, &next_sendtime, >)) {
474d7cd6ba3SIan Dowse 			/* update retransmit_time */
475d7cd6ba3SIan Dowse 			if (retransmit_time.tv_sec < RPC_MAX_BACKOFF)
476d7cd6ba3SIan Dowse 				timeradd(&retransmit_time, &retransmit_time,
477d7cd6ba3SIan Dowse 				    &retransmit_time);
478d7cd6ba3SIan Dowse 			timeradd(&next_sendtime, &retransmit_time,
479d7cd6ba3SIan Dowse 			    &next_sendtime);
480d7cd6ba3SIan Dowse 			goto send_again;
481d7cd6ba3SIan Dowse 		}
482d7cd6ba3SIan Dowse 	}
4838360efbdSAlfred Perlstein 	inlen = (socklen_t)recvlen;
4848360efbdSAlfred Perlstein 
4858360efbdSAlfred Perlstein 	/*
4868360efbdSAlfred Perlstein 	 * now decode and validate the response
4878360efbdSAlfred Perlstein 	 */
4888360efbdSAlfred Perlstein 
489f4a180ccSMartin Blapp 	xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)recvlen, XDR_DECODE);
4908360efbdSAlfred Perlstein 	ok = xdr_replymsg(&reply_xdrs, &reply_msg);
4918360efbdSAlfred Perlstein 	/* XDR_DESTROY(&reply_xdrs);	save a few cycles on noop destroy */
4928360efbdSAlfred Perlstein 	if (ok) {
4938360efbdSAlfred Perlstein 		if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
4948360efbdSAlfred Perlstein 			(reply_msg.acpted_rply.ar_stat == SUCCESS))
4958360efbdSAlfred Perlstein 			cu->cu_error.re_status = RPC_SUCCESS;
4968360efbdSAlfred Perlstein 		else
4978360efbdSAlfred Perlstein 			_seterr_reply(&reply_msg, &(cu->cu_error));
4988360efbdSAlfred Perlstein 
4998360efbdSAlfred Perlstein 		if (cu->cu_error.re_status == RPC_SUCCESS) {
5008360efbdSAlfred Perlstein 			if (! AUTH_VALIDATE(cl->cl_auth,
5018360efbdSAlfred Perlstein 					    &reply_msg.acpted_rply.ar_verf)) {
5028360efbdSAlfred Perlstein 				cu->cu_error.re_status = RPC_AUTHERROR;
5038360efbdSAlfred Perlstein 				cu->cu_error.re_why = AUTH_INVALIDRESP;
5048360efbdSAlfred Perlstein 			}
5058360efbdSAlfred Perlstein 			if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
5068360efbdSAlfred Perlstein 				xdrs->x_op = XDR_FREE;
5078360efbdSAlfred Perlstein 				(void) xdr_opaque_auth(xdrs,
5088360efbdSAlfred Perlstein 					&(reply_msg.acpted_rply.ar_verf));
5098360efbdSAlfred Perlstein 			}
5108360efbdSAlfred Perlstein 		}		/* end successful completion */
5118360efbdSAlfred Perlstein 		/*
5128360efbdSAlfred Perlstein 		 * If unsuccesful AND error is an authentication error
5138360efbdSAlfred Perlstein 		 * then refresh credentials and try again, else break
5148360efbdSAlfred Perlstein 		 */
5158360efbdSAlfred Perlstein 		else if (cu->cu_error.re_status == RPC_AUTHERROR)
5168360efbdSAlfred Perlstein 			/* maybe our credentials need to be refreshed ... */
5178360efbdSAlfred Perlstein 			if (nrefreshes > 0 &&
5188360efbdSAlfred Perlstein 			    AUTH_REFRESH(cl->cl_auth, &reply_msg)) {
5198360efbdSAlfred Perlstein 				nrefreshes--;
5208360efbdSAlfred Perlstein 				goto call_again;
5218360efbdSAlfred Perlstein 			}
5228360efbdSAlfred Perlstein 		/* end of unsuccessful completion */
5238360efbdSAlfred Perlstein 	}	/* end of valid reply message */
5248360efbdSAlfred Perlstein 	else {
5258360efbdSAlfred Perlstein 		cu->cu_error.re_status = RPC_CANTDECODERES;
5268360efbdSAlfred Perlstein 
5278360efbdSAlfred Perlstein 	}
528d7cd6ba3SIan Dowse out:
529d7cd6ba3SIan Dowse 	if (cu->cu_kq >= 0)
530d7cd6ba3SIan Dowse 		_close(cu->cu_kq);
531d7cd6ba3SIan Dowse 	cu->cu_kq = -1;
5328360efbdSAlfred Perlstein 	release_fd_lock(cu->cu_fd, mask);
5338360efbdSAlfred Perlstein 	return (cu->cu_error.re_status);
5348360efbdSAlfred Perlstein }
5358360efbdSAlfred Perlstein 
5368360efbdSAlfred Perlstein static void
5378360efbdSAlfred Perlstein clnt_dg_geterr(cl, errp)
5388360efbdSAlfred Perlstein 	CLIENT *cl;
5398360efbdSAlfred Perlstein 	struct rpc_err *errp;
5408360efbdSAlfred Perlstein {
5418360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
5428360efbdSAlfred Perlstein 
5438360efbdSAlfred Perlstein 	*errp = cu->cu_error;
5448360efbdSAlfred Perlstein }
5458360efbdSAlfred Perlstein 
5468360efbdSAlfred Perlstein static bool_t
5478360efbdSAlfred Perlstein clnt_dg_freeres(cl, xdr_res, res_ptr)
5488360efbdSAlfred Perlstein 	CLIENT *cl;
5498360efbdSAlfred Perlstein 	xdrproc_t xdr_res;
550f249dbccSDag-Erling Smørgrav 	void *res_ptr;
5518360efbdSAlfred Perlstein {
5528360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
5538360efbdSAlfred Perlstein 	XDR *xdrs = &(cu->cu_outxdrs);
5548360efbdSAlfred Perlstein 	bool_t dummy;
5558360efbdSAlfred Perlstein 	sigset_t mask;
5568360efbdSAlfred Perlstein 	sigset_t newmask;
5578360efbdSAlfred Perlstein 
5588360efbdSAlfred Perlstein 	sigfillset(&newmask);
5598360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
5608360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
5618360efbdSAlfred Perlstein 	while (dg_fd_locks[cu->cu_fd])
5628360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
5638360efbdSAlfred Perlstein 	xdrs->x_op = XDR_FREE;
5648360efbdSAlfred Perlstein 	dummy = (*xdr_res)(xdrs, res_ptr);
5658360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
5668360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &mask, NULL);
5678360efbdSAlfred Perlstein 	cond_signal(&dg_cv[cu->cu_fd]);
5688360efbdSAlfred Perlstein 	return (dummy);
5698360efbdSAlfred Perlstein }
5708360efbdSAlfred Perlstein 
5718360efbdSAlfred Perlstein /*ARGSUSED*/
5728360efbdSAlfred Perlstein static void
5738360efbdSAlfred Perlstein clnt_dg_abort(h)
5748360efbdSAlfred Perlstein 	CLIENT *h;
5758360efbdSAlfred Perlstein {
5768360efbdSAlfred Perlstein }
5778360efbdSAlfred Perlstein 
5788360efbdSAlfred Perlstein static bool_t
5798360efbdSAlfred Perlstein clnt_dg_control(cl, request, info)
5808360efbdSAlfred Perlstein 	CLIENT *cl;
5818360efbdSAlfred Perlstein 	u_int request;
582cffc0b57SAlfred Perlstein 	void *info;
5838360efbdSAlfred Perlstein {
5848360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
5858360efbdSAlfred Perlstein 	struct netbuf *addr;
5868360efbdSAlfred Perlstein 	sigset_t mask;
5878360efbdSAlfred Perlstein 	sigset_t newmask;
5888360efbdSAlfred Perlstein 	int rpc_lock_value;
5898360efbdSAlfred Perlstein 
5908360efbdSAlfred Perlstein 	sigfillset(&newmask);
5918360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
5928360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
5938360efbdSAlfred Perlstein 	while (dg_fd_locks[cu->cu_fd])
5948360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
5958360efbdSAlfred Perlstein 	if (__isthreaded)
5968360efbdSAlfred Perlstein                 rpc_lock_value = 1;
5978360efbdSAlfred Perlstein         else
5988360efbdSAlfred Perlstein                 rpc_lock_value = 0;
5998360efbdSAlfred Perlstein 	dg_fd_locks[cu->cu_fd] = rpc_lock_value;
6008360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
6018360efbdSAlfred Perlstein 	switch (request) {
6028360efbdSAlfred Perlstein 	case CLSET_FD_CLOSE:
6038360efbdSAlfred Perlstein 		cu->cu_closeit = TRUE;
6048360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
6058360efbdSAlfred Perlstein 		return (TRUE);
6068360efbdSAlfred Perlstein 	case CLSET_FD_NCLOSE:
6078360efbdSAlfred Perlstein 		cu->cu_closeit = FALSE;
6088360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
6098360efbdSAlfred Perlstein 		return (TRUE);
6108360efbdSAlfred Perlstein 	}
6118360efbdSAlfred Perlstein 
6128360efbdSAlfred Perlstein 	/* for other requests which use info */
6138360efbdSAlfred Perlstein 	if (info == NULL) {
6148360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
6158360efbdSAlfred Perlstein 		return (FALSE);
6168360efbdSAlfred Perlstein 	}
6178360efbdSAlfred Perlstein 	switch (request) {
6188360efbdSAlfred Perlstein 	case CLSET_TIMEOUT:
619cffc0b57SAlfred Perlstein 		if (time_not_ok((struct timeval *)info)) {
6208360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
6218360efbdSAlfred Perlstein 			return (FALSE);
6228360efbdSAlfred Perlstein 		}
623cffc0b57SAlfred Perlstein 		cu->cu_total = *(struct timeval *)info;
6248360efbdSAlfred Perlstein 		break;
6258360efbdSAlfred Perlstein 	case CLGET_TIMEOUT:
626cffc0b57SAlfred Perlstein 		*(struct timeval *)info = cu->cu_total;
6278360efbdSAlfred Perlstein 		break;
6288360efbdSAlfred Perlstein 	case CLGET_SERVER_ADDR:		/* Give him the fd address */
6298360efbdSAlfred Perlstein 		/* Now obsolete. Only for backward compatibility */
6308360efbdSAlfred Perlstein 		(void) memcpy(info, &cu->cu_raddr, (size_t)cu->cu_rlen);
6318360efbdSAlfred Perlstein 		break;
6328360efbdSAlfred Perlstein 	case CLSET_RETRY_TIMEOUT:
633cffc0b57SAlfred Perlstein 		if (time_not_ok((struct timeval *)info)) {
6348360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
6358360efbdSAlfred Perlstein 			return (FALSE);
6368360efbdSAlfred Perlstein 		}
637cffc0b57SAlfred Perlstein 		cu->cu_wait = *(struct timeval *)info;
6388360efbdSAlfred Perlstein 		break;
6398360efbdSAlfred Perlstein 	case CLGET_RETRY_TIMEOUT:
640cffc0b57SAlfred Perlstein 		*(struct timeval *)info = cu->cu_wait;
6418360efbdSAlfred Perlstein 		break;
6428360efbdSAlfred Perlstein 	case CLGET_FD:
643cffc0b57SAlfred Perlstein 		*(int *)info = cu->cu_fd;
6448360efbdSAlfred Perlstein 		break;
6458360efbdSAlfred Perlstein 	case CLGET_SVC_ADDR:
646cffc0b57SAlfred Perlstein 		addr = (struct netbuf *)info;
6478360efbdSAlfred Perlstein 		addr->buf = &cu->cu_raddr;
6488360efbdSAlfred Perlstein 		addr->len = cu->cu_rlen;
6498360efbdSAlfred Perlstein 		addr->maxlen = sizeof cu->cu_raddr;
6508360efbdSAlfred Perlstein 		break;
6518360efbdSAlfred Perlstein 	case CLSET_SVC_ADDR:		/* set to new address */
652cffc0b57SAlfred Perlstein 		addr = (struct netbuf *)info;
653cd517469SIan Dowse 		if (addr->len < sizeof cu->cu_raddr) {
654cd517469SIan Dowse 			release_fd_lock(cu->cu_fd, mask);
6558360efbdSAlfred Perlstein 			return (FALSE);
656cd517469SIan Dowse 		}
6578360efbdSAlfred Perlstein 		(void) memcpy(&cu->cu_raddr, addr->buf, addr->len);
6588360efbdSAlfred Perlstein 		cu->cu_rlen = addr->len;
6598360efbdSAlfred Perlstein 		break;
6608360efbdSAlfred Perlstein 	case CLGET_XID:
6618360efbdSAlfred Perlstein 		/*
6628360efbdSAlfred Perlstein 		 * use the knowledge that xid is the
6638360efbdSAlfred Perlstein 		 * first element in the call structure *.
6648360efbdSAlfred Perlstein 		 * This will get the xid of the PREVIOUS call
6658360efbdSAlfred Perlstein 		 */
666cffc0b57SAlfred Perlstein 		*(u_int32_t *)info =
6678360efbdSAlfred Perlstein 		    ntohl(*(u_int32_t *)(void *)cu->cu_outbuf);
6688360efbdSAlfred Perlstein 		break;
6698360efbdSAlfred Perlstein 
6708360efbdSAlfred Perlstein 	case CLSET_XID:
6718360efbdSAlfred Perlstein 		/* This will set the xid of the NEXT call */
6728360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)cu->cu_outbuf =
673cffc0b57SAlfred Perlstein 		    htonl(*(u_int32_t *)info - 1);
6748360efbdSAlfred Perlstein 		/* decrement by 1 as clnt_dg_call() increments once */
6758360efbdSAlfred Perlstein 		break;
6768360efbdSAlfred Perlstein 
6778360efbdSAlfred Perlstein 	case CLGET_VERS:
6788360efbdSAlfred Perlstein 		/*
6798360efbdSAlfred Perlstein 		 * This RELIES on the information that, in the call body,
6808360efbdSAlfred Perlstein 		 * the version number field is the fifth field from the
6818360efbdSAlfred Perlstein 		 * begining of the RPC header. MUST be changed if the
6828360efbdSAlfred Perlstein 		 * call_struct is changed
6838360efbdSAlfred Perlstein 		 */
684cffc0b57SAlfred Perlstein 		*(u_int32_t *)info =
6858360efbdSAlfred Perlstein 		    ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf +
6868360efbdSAlfred Perlstein 		    4 * BYTES_PER_XDR_UNIT));
6878360efbdSAlfred Perlstein 		break;
6888360efbdSAlfred Perlstein 
6898360efbdSAlfred Perlstein 	case CLSET_VERS:
6908360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT)
691cffc0b57SAlfred Perlstein 			= htonl(*(u_int32_t *)info);
6928360efbdSAlfred Perlstein 		break;
6938360efbdSAlfred Perlstein 
6948360efbdSAlfred Perlstein 	case CLGET_PROG:
6958360efbdSAlfred Perlstein 		/*
6968360efbdSAlfred Perlstein 		 * This RELIES on the information that, in the call body,
6978360efbdSAlfred Perlstein 		 * the program number field is the fourth field from the
6988360efbdSAlfred Perlstein 		 * begining of the RPC header. MUST be changed if the
6998360efbdSAlfred Perlstein 		 * call_struct is changed
7008360efbdSAlfred Perlstein 		 */
701cffc0b57SAlfred Perlstein 		*(u_int32_t *)info =
7028360efbdSAlfred Perlstein 		    ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf +
7038360efbdSAlfred Perlstein 		    3 * BYTES_PER_XDR_UNIT));
7048360efbdSAlfred Perlstein 		break;
7058360efbdSAlfred Perlstein 
7068360efbdSAlfred Perlstein 	case CLSET_PROG:
7078360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT)
708cffc0b57SAlfred Perlstein 			= htonl(*(u_int32_t *)info);
7098360efbdSAlfred Perlstein 		break;
71065d3c627SBill Paul 	case CLSET_ASYNC:
711cffc0b57SAlfred Perlstein 		cu->cu_async = *(int *)info;
71265d3c627SBill Paul 		break;
71332de72d2SIan Dowse 	case CLSET_CONNECT:
714cffc0b57SAlfred Perlstein 		cu->cu_connect = *(int *)info;
71532de72d2SIan Dowse 		break;
7168360efbdSAlfred Perlstein 	default:
7178360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
7188360efbdSAlfred Perlstein 		return (FALSE);
7198360efbdSAlfred Perlstein 	}
7208360efbdSAlfred Perlstein 	release_fd_lock(cu->cu_fd, mask);
7218360efbdSAlfred Perlstein 	return (TRUE);
7228360efbdSAlfred Perlstein }
7238360efbdSAlfred Perlstein 
7248360efbdSAlfred Perlstein static void
7258360efbdSAlfred Perlstein clnt_dg_destroy(cl)
7268360efbdSAlfred Perlstein 	CLIENT *cl;
7278360efbdSAlfred Perlstein {
7288360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
7298360efbdSAlfred Perlstein 	int cu_fd = cu->cu_fd;
7308360efbdSAlfred Perlstein 	sigset_t mask;
7318360efbdSAlfred Perlstein 	sigset_t newmask;
7328360efbdSAlfred Perlstein 
7338360efbdSAlfred Perlstein 	sigfillset(&newmask);
7348360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
7358360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
7368360efbdSAlfred Perlstein 	while (dg_fd_locks[cu_fd])
7378360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu_fd], &clnt_fd_lock);
7388360efbdSAlfred Perlstein 	if (cu->cu_closeit)
7398360efbdSAlfred Perlstein 		(void)_close(cu_fd);
740d7cd6ba3SIan Dowse 	if (cu->cu_kq >= 0)
741d7cd6ba3SIan Dowse 		_close(cu->cu_kq);
7428360efbdSAlfred Perlstein 	XDR_DESTROY(&(cu->cu_outxdrs));
7438360efbdSAlfred Perlstein 	mem_free(cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
7448360efbdSAlfred Perlstein 	if (cl->cl_netid && cl->cl_netid[0])
7458360efbdSAlfred Perlstein 		mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
7468360efbdSAlfred Perlstein 	if (cl->cl_tp && cl->cl_tp[0])
7478360efbdSAlfred Perlstein 		mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
7488360efbdSAlfred Perlstein 	mem_free(cl, sizeof (CLIENT));
7498360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
7508360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &mask, NULL);
7518360efbdSAlfred Perlstein 	cond_signal(&dg_cv[cu_fd]);
7528360efbdSAlfred Perlstein }
7538360efbdSAlfred Perlstein 
7548360efbdSAlfred Perlstein static struct clnt_ops *
7558360efbdSAlfred Perlstein clnt_dg_ops()
7568360efbdSAlfred Perlstein {
7578360efbdSAlfred Perlstein 	static struct clnt_ops ops;
7588360efbdSAlfred Perlstein 	extern mutex_t	ops_lock;
7598360efbdSAlfred Perlstein 	sigset_t mask;
7608360efbdSAlfred Perlstein 	sigset_t newmask;
7618360efbdSAlfred Perlstein 
7628360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY ops_lock: ops */
7638360efbdSAlfred Perlstein 
7648360efbdSAlfred Perlstein 	sigfillset(&newmask);
7658360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
7668360efbdSAlfred Perlstein 	mutex_lock(&ops_lock);
7678360efbdSAlfred Perlstein 	if (ops.cl_call == NULL) {
7688360efbdSAlfred Perlstein 		ops.cl_call = clnt_dg_call;
7698360efbdSAlfred Perlstein 		ops.cl_abort = clnt_dg_abort;
7708360efbdSAlfred Perlstein 		ops.cl_geterr = clnt_dg_geterr;
7718360efbdSAlfred Perlstein 		ops.cl_freeres = clnt_dg_freeres;
7728360efbdSAlfred Perlstein 		ops.cl_destroy = clnt_dg_destroy;
7738360efbdSAlfred Perlstein 		ops.cl_control = clnt_dg_control;
7748360efbdSAlfred Perlstein 	}
7758360efbdSAlfred Perlstein 	mutex_unlock(&ops_lock);
7768360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &mask, NULL);
7778360efbdSAlfred Perlstein 	return (&ops);
7788360efbdSAlfred Perlstein }
7798360efbdSAlfred Perlstein 
7808360efbdSAlfred Perlstein /*
7818360efbdSAlfred Perlstein  * Make sure that the time is not garbage.  -1 value is allowed.
7828360efbdSAlfred Perlstein  */
7838360efbdSAlfred Perlstein static bool_t
7848360efbdSAlfred Perlstein time_not_ok(t)
7858360efbdSAlfred Perlstein 	struct timeval *t;
7868360efbdSAlfred Perlstein {
7878360efbdSAlfred Perlstein 	return (t->tv_sec < -1 || t->tv_sec > 100000000 ||
7888360efbdSAlfred Perlstein 		t->tv_usec < -1 || t->tv_usec > 1000000);
7898360efbdSAlfred Perlstein }
7908360efbdSAlfred Perlstein 
791