xref: /freebsd/lib/libc/rpc/clnt_dg.c (revision f249dbcc7149848de00cd8f4e93fe140dfa3f219)
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/poll.h>
508360efbdSAlfred Perlstein #include <sys/types.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 *);
76c05ac53bSDavid E. O'Brien static bool_t clnt_dg_control(CLIENT *, u_int, char *);
77c05ac53bSDavid E. O'Brien static void clnt_dg_destroy(CLIENT *);
78c05ac53bSDavid E. O'Brien static int __rpc_timeval_to_msec(struct timeval *);
798360efbdSAlfred Perlstein 
808360efbdSAlfred Perlstein 
818360efbdSAlfred Perlstein 
828360efbdSAlfred Perlstein 
838360efbdSAlfred Perlstein /*
848360efbdSAlfred Perlstein  *	This machinery implements per-fd locks for MT-safety.  It is not
858360efbdSAlfred Perlstein  *	sufficient to do per-CLIENT handle locks for MT-safety because a
868360efbdSAlfred Perlstein  *	user may create more than one CLIENT handle with the same fd behind
878360efbdSAlfred Perlstein  *	it.  Therfore, we allocate an array of flags (dg_fd_locks), protected
888360efbdSAlfred Perlstein  *	by the clnt_fd_lock mutex, and an array (dg_cv) of condition variables
898360efbdSAlfred Perlstein  *	similarly protected.  Dg_fd_lock[fd] == 1 => a call is activte on some
908360efbdSAlfred Perlstein  *	CLIENT handle created for that fd.
918360efbdSAlfred Perlstein  *	The current implementation holds locks across the entire RPC and reply,
928360efbdSAlfred Perlstein  *	including retransmissions.  Yes, this is silly, and as soon as this
938360efbdSAlfred Perlstein  *	code is proven to work, this should be the first thing fixed.  One step
948360efbdSAlfred Perlstein  *	at a time.
958360efbdSAlfred Perlstein  */
968360efbdSAlfred Perlstein static int	*dg_fd_locks;
978360efbdSAlfred Perlstein extern mutex_t clnt_fd_lock;
988360efbdSAlfred Perlstein static cond_t	*dg_cv;
998360efbdSAlfred Perlstein #define	release_fd_lock(fd, mask) {		\
1008360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);	\
1018360efbdSAlfred Perlstein 	dg_fd_locks[fd] = 0;		\
1028360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);	\
1038360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &(mask), (sigset_t *) NULL);	\
1048360efbdSAlfred Perlstein 	cond_signal(&dg_cv[fd]);	\
1058360efbdSAlfred Perlstein }
1068360efbdSAlfred Perlstein 
1078360efbdSAlfred Perlstein static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory";
1088360efbdSAlfred Perlstein 
1098360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY clnt_fd_lock: dg_fd_locks, dg_cv */
1108360efbdSAlfred Perlstein 
1118360efbdSAlfred Perlstein /*
1128360efbdSAlfred Perlstein  * Private data kept per client handle
1138360efbdSAlfred Perlstein  */
1148360efbdSAlfred Perlstein struct cu_data {
1158360efbdSAlfred Perlstein 	int			cu_fd;		/* connections fd */
1168360efbdSAlfred Perlstein 	bool_t			cu_closeit;	/* opened by library */
1178360efbdSAlfred Perlstein 	struct sockaddr_storage	cu_raddr;	/* remote address */
1188360efbdSAlfred Perlstein 	int			cu_rlen;
1198360efbdSAlfred Perlstein 	struct timeval		cu_wait;	/* retransmit interval */
1208360efbdSAlfred Perlstein 	struct timeval		cu_total;	/* total time for the call */
1218360efbdSAlfred Perlstein 	struct rpc_err		cu_error;
1228360efbdSAlfred Perlstein 	XDR			cu_outxdrs;
1238360efbdSAlfred Perlstein 	u_int			cu_xdrpos;
1248360efbdSAlfred Perlstein 	u_int			cu_sendsz;	/* send size */
1258360efbdSAlfred Perlstein 	char			*cu_outbuf;
1268360efbdSAlfred Perlstein 	u_int			cu_recvsz;	/* recv size */
1278360efbdSAlfred Perlstein 	struct pollfd		pfdp;
12865d3c627SBill Paul 	int			cu_async;
12932de72d2SIan Dowse 	int			cu_connect;	/* Use connect(). */
13032de72d2SIan Dowse 	int			cu_connected;	/* Have done connect(). */
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;
2768360efbdSAlfred Perlstein 	cu->pfdp.fd = cu->cu_fd;
2778360efbdSAlfred Perlstein 	cu->pfdp.events = POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND;
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;
3048360efbdSAlfred Perlstein 	size_t outlen;
3058360efbdSAlfred Perlstein 	struct rpc_msg reply_msg;
3068360efbdSAlfred Perlstein 	XDR reply_xdrs;
3078360efbdSAlfred Perlstein 	struct timeval time_waited;
3088360efbdSAlfred Perlstein 	bool_t ok;
3098360efbdSAlfred Perlstein 	int nrefreshes = 2;		/* number of times to refresh cred */
3108360efbdSAlfred Perlstein 	struct timeval timeout;
3118360efbdSAlfred Perlstein 	struct timeval retransmit_time;
3128360efbdSAlfred Perlstein 	struct timeval startime, curtime;
3138360efbdSAlfred Perlstein 	int firsttimeout = 1;
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;
3198360efbdSAlfred Perlstein 	int 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 			release_fd_lock(cu->cu_fd, mask);
34432de72d2SIan Dowse 			cu->cu_error.re_errno = errno;
34532de72d2SIan Dowse 			return (cu->cu_error.re_status = RPC_CANTSEND);
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;
3588360efbdSAlfred Perlstein 	retransmit_time = cu->cu_wait;
3598360efbdSAlfred Perlstein 
3608360efbdSAlfred Perlstein call_again:
3618360efbdSAlfred Perlstein 	xdrs = &(cu->cu_outxdrs);
36265d3c627SBill Paul 	if (cu->cu_async == TRUE && xargs == NULL)
36365d3c627SBill Paul 		goto get_reply;
3648360efbdSAlfred Perlstein 	xdrs->x_op = XDR_ENCODE;
3658360efbdSAlfred Perlstein 	XDR_SETPOS(xdrs, cu->cu_xdrpos);
3668360efbdSAlfred Perlstein 	/*
3678360efbdSAlfred Perlstein 	 * the transaction is the first thing in the out buffer
36865d3c627SBill Paul 	 * XXX Yes, and it's in network byte order, so we should to
36965d3c627SBill Paul 	 * be careful when we increment it, shouldn't we.
3708360efbdSAlfred Perlstein 	 */
37165d3c627SBill Paul 	xid = ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf));
37265d3c627SBill Paul 	xid++;
37365d3c627SBill Paul 	*(u_int32_t *)(void *)(cu->cu_outbuf) = htonl(xid);
37465d3c627SBill Paul 
3758360efbdSAlfred Perlstein 	if ((! XDR_PUTINT32(xdrs, &proc)) ||
3768360efbdSAlfred Perlstein 	    (! AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
3778360efbdSAlfred Perlstein 	    (! (*xargs)(xdrs, argsp))) {
3788360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
3798360efbdSAlfred Perlstein 		return (cu->cu_error.re_status = RPC_CANTENCODEARGS);
3808360efbdSAlfred Perlstein 	}
3818360efbdSAlfred Perlstein 	outlen = (size_t)XDR_GETPOS(xdrs);
3828360efbdSAlfred Perlstein 
3838360efbdSAlfred Perlstein send_again:
38432de72d2SIan Dowse 	if (_sendto(cu->cu_fd, cu->cu_outbuf, outlen, 0, sa, salen) != outlen) {
3858360efbdSAlfred Perlstein 		cu->cu_error.re_errno = errno;
3868360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
3878360efbdSAlfred Perlstein 		return (cu->cu_error.re_status = RPC_CANTSEND);
3888360efbdSAlfred Perlstein 	}
3898360efbdSAlfred Perlstein 
3908360efbdSAlfred Perlstein 	/*
3918360efbdSAlfred Perlstein 	 * Hack to provide rpc-based message passing
3928360efbdSAlfred Perlstein 	 */
3938360efbdSAlfred Perlstein 	if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
3948360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
3958360efbdSAlfred Perlstein 		return (cu->cu_error.re_status = RPC_TIMEDOUT);
3968360efbdSAlfred Perlstein 	}
39765d3c627SBill Paul 
39865d3c627SBill Paul get_reply:
39965d3c627SBill Paul 
4008360efbdSAlfred Perlstein 	/*
4018360efbdSAlfred Perlstein 	 * sub-optimal code appears here because we have
4028360efbdSAlfred Perlstein 	 * some clock time to spare while the packets are in flight.
4038360efbdSAlfred Perlstein 	 * (We assume that this is actually only executed once.)
4048360efbdSAlfred Perlstein 	 */
4058360efbdSAlfred Perlstein 	reply_msg.acpted_rply.ar_verf = _null_auth;
4068360efbdSAlfred Perlstein 	reply_msg.acpted_rply.ar_results.where = resultsp;
4078360efbdSAlfred Perlstein 	reply_msg.acpted_rply.ar_results.proc = xresults;
4088360efbdSAlfred Perlstein 
4098360efbdSAlfred Perlstein 
4108360efbdSAlfred Perlstein 	for (;;) {
4118360efbdSAlfred Perlstein 		switch (_poll(&cu->pfdp, 1,
4128360efbdSAlfred Perlstein 		    __rpc_timeval_to_msec(&retransmit_time))) {
4138360efbdSAlfred Perlstein 		case 0:
4148360efbdSAlfred Perlstein 			time_waited.tv_sec += retransmit_time.tv_sec;
4158360efbdSAlfred Perlstein 			time_waited.tv_usec += retransmit_time.tv_usec;
4168360efbdSAlfred Perlstein 			while (time_waited.tv_usec >= 1000000) {
4178360efbdSAlfred Perlstein 				time_waited.tv_sec++;
4188360efbdSAlfred Perlstein 				time_waited.tv_usec -= 1000000;
4198360efbdSAlfred Perlstein 			}
4208360efbdSAlfred Perlstein 			/* update retransmit_time */
4218360efbdSAlfred Perlstein 			if (retransmit_time.tv_sec < RPC_MAX_BACKOFF) {
4228360efbdSAlfred Perlstein 				retransmit_time.tv_usec *= 2;
4238360efbdSAlfred Perlstein 				retransmit_time.tv_sec *= 2;
4248360efbdSAlfred Perlstein 				while (retransmit_time.tv_usec >= 1000000) {
4258360efbdSAlfred Perlstein 					retransmit_time.tv_sec++;
4268360efbdSAlfred Perlstein 					retransmit_time.tv_usec -= 1000000;
4278360efbdSAlfred Perlstein 				}
4288360efbdSAlfred Perlstein 			}
4298360efbdSAlfred Perlstein 
4308360efbdSAlfred Perlstein 			if ((time_waited.tv_sec < timeout.tv_sec) ||
4318360efbdSAlfred Perlstein 			    ((time_waited.tv_sec == timeout.tv_sec) &&
4328360efbdSAlfred Perlstein 				(time_waited.tv_usec < timeout.tv_usec)))
4338360efbdSAlfred Perlstein 				goto send_again;
4348360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
4358360efbdSAlfred Perlstein 			return (cu->cu_error.re_status = RPC_TIMEDOUT);
4368360efbdSAlfred Perlstein 
4378360efbdSAlfred Perlstein 		case -1:
4388360efbdSAlfred Perlstein 			if (errno == EBADF) {
4398360efbdSAlfred Perlstein 				cu->cu_error.re_errno = errno;
4408360efbdSAlfred Perlstein 				release_fd_lock(cu->cu_fd, mask);
4418360efbdSAlfred Perlstein 				return (cu->cu_error.re_status = RPC_CANTRECV);
4428360efbdSAlfred Perlstein 			}
4438360efbdSAlfred Perlstein 			if (errno != EINTR) {
4448360efbdSAlfred Perlstein 				errno = 0; /* reset it */
4458360efbdSAlfred Perlstein 				continue;
4468360efbdSAlfred Perlstein 			}
4478360efbdSAlfred Perlstein 			/* interrupted by another signal, update time_waited */
4488360efbdSAlfred Perlstein 			if (firsttimeout) {
4498360efbdSAlfred Perlstein 				/*
4508360efbdSAlfred Perlstein 				 * Could have done gettimeofday before clnt_call
4518360efbdSAlfred Perlstein 				 * but that means 1 more system call per each
4528360efbdSAlfred Perlstein 				 * clnt_call, so do it after first time out
4538360efbdSAlfred Perlstein 				 */
4548360efbdSAlfred Perlstein 				if (gettimeofday(&startime,
4558360efbdSAlfred Perlstein 					(struct timezone *) NULL) == -1) {
4568360efbdSAlfred Perlstein 					errno = 0;
4578360efbdSAlfred Perlstein 					continue;
4588360efbdSAlfred Perlstein 				}
4598360efbdSAlfred Perlstein 				firsttimeout = 0;
4608360efbdSAlfred Perlstein 				errno = 0;
4618360efbdSAlfred Perlstein 				continue;
4628360efbdSAlfred Perlstein 			};
4638360efbdSAlfred Perlstein 			if (gettimeofday(&curtime,
4648360efbdSAlfred Perlstein 				(struct timezone *) NULL) == -1) {
4658360efbdSAlfred Perlstein 				errno = 0;
4668360efbdSAlfred Perlstein 				continue;
4678360efbdSAlfred Perlstein 			};
4688360efbdSAlfred Perlstein 			time_waited.tv_sec += curtime.tv_sec - startime.tv_sec;
4698360efbdSAlfred Perlstein 			time_waited.tv_usec += curtime.tv_usec -
4708360efbdSAlfred Perlstein 							startime.tv_usec;
4718360efbdSAlfred Perlstein 			while (time_waited.tv_usec < 0) {
4728360efbdSAlfred Perlstein 				time_waited.tv_sec--;
4738360efbdSAlfred Perlstein 				time_waited.tv_usec += 1000000;
4748360efbdSAlfred Perlstein 			};
4758360efbdSAlfred Perlstein 			while (time_waited.tv_usec >= 1000000) {
4768360efbdSAlfred Perlstein 				time_waited.tv_sec++;
4778360efbdSAlfred Perlstein 				time_waited.tv_usec -= 1000000;
4788360efbdSAlfred Perlstein 			}
4798360efbdSAlfred Perlstein 			startime.tv_sec = curtime.tv_sec;
4808360efbdSAlfred Perlstein 			startime.tv_usec = curtime.tv_usec;
4818360efbdSAlfred Perlstein 			if ((time_waited.tv_sec > timeout.tv_sec) ||
4828360efbdSAlfred Perlstein 				((time_waited.tv_sec == timeout.tv_sec) &&
4838360efbdSAlfred Perlstein 				(time_waited.tv_usec > timeout.tv_usec))) {
4848360efbdSAlfred Perlstein 				release_fd_lock(cu->cu_fd, mask);
4858360efbdSAlfred Perlstein 				return (cu->cu_error.re_status = RPC_TIMEDOUT);
4868360efbdSAlfred Perlstein 			}
4878360efbdSAlfred Perlstein 			errno = 0; /* reset it */
4888360efbdSAlfred Perlstein 			continue;
4898360efbdSAlfred Perlstein 		};
4908360efbdSAlfred Perlstein 
4918360efbdSAlfred Perlstein 		if (cu->pfdp.revents & POLLNVAL || (cu->pfdp.revents == 0)) {
4928360efbdSAlfred Perlstein 			cu->cu_error.re_status = RPC_CANTRECV;
4938360efbdSAlfred Perlstein 			/*
4948360efbdSAlfred Perlstein 			 *	Note:  we're faking errno here because we
4958360efbdSAlfred Perlstein 			 *	previously would have expected _poll() to
4968360efbdSAlfred Perlstein 			 *	return -1 with errno EBADF.  Poll(BA_OS)
4978360efbdSAlfred Perlstein 			 *	returns 0 and sets the POLLNVAL revents flag
4988360efbdSAlfred Perlstein 			 *	instead.
4998360efbdSAlfred Perlstein 			 */
5008360efbdSAlfred Perlstein 			cu->cu_error.re_errno = errno = EBADF;
5018360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
5028360efbdSAlfred Perlstein 			return (-1);
5038360efbdSAlfred Perlstein 		}
5048360efbdSAlfred Perlstein 
5058360efbdSAlfred Perlstein 		/* We have some data now */
5068360efbdSAlfred Perlstein 		do {
5078360efbdSAlfred Perlstein 			if (errno == EINTR) {
5088360efbdSAlfred Perlstein 				/*
5098360efbdSAlfred Perlstein 				 * Must make sure errno was not already
5108360efbdSAlfred Perlstein 				 * EINTR in case _recvfrom() returns -1.
5118360efbdSAlfred Perlstein 				 */
5128360efbdSAlfred Perlstein 				errno = 0;
5138360efbdSAlfred Perlstein 			}
5148360efbdSAlfred Perlstein 			recvlen = _recvfrom(cu->cu_fd, cu->cu_inbuf,
515a9d09e93SIan Dowse 			    cu->cu_recvsz, 0, NULL, NULL);
5168360efbdSAlfred Perlstein 		} while (recvlen < 0 && errno == EINTR);
5178360efbdSAlfred Perlstein 		if (recvlen < 0) {
5188360efbdSAlfred Perlstein 			if (errno == EWOULDBLOCK)
5198360efbdSAlfred Perlstein 				continue;
5208360efbdSAlfred Perlstein 			cu->cu_error.re_errno = errno;
5218360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
5228360efbdSAlfred Perlstein 			return (cu->cu_error.re_status = RPC_CANTRECV);
5238360efbdSAlfred Perlstein 		}
5248360efbdSAlfred Perlstein 		if (recvlen < sizeof (u_int32_t))
5258360efbdSAlfred Perlstein 			continue;
5268360efbdSAlfred Perlstein 		/* see if reply transaction id matches sent id */
52765d3c627SBill Paul 		if (cu->cu_async == FALSE &&
52865d3c627SBill Paul 		    *((u_int32_t *)(void *)(cu->cu_inbuf)) !=
5298360efbdSAlfred Perlstein 		    *((u_int32_t *)(void *)(cu->cu_outbuf)))
5308360efbdSAlfred Perlstein 			continue;
5318360efbdSAlfred Perlstein 		/* we now assume we have the proper reply */
5328360efbdSAlfred Perlstein 		break;
5338360efbdSAlfred Perlstein 	}
5348360efbdSAlfred Perlstein 	inlen = (socklen_t)recvlen;
5358360efbdSAlfred Perlstein 
5368360efbdSAlfred Perlstein 	/*
5378360efbdSAlfred Perlstein 	 * now decode and validate the response
5388360efbdSAlfred Perlstein 	 */
5398360efbdSAlfred Perlstein 
5408360efbdSAlfred Perlstein 	xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE);
5418360efbdSAlfred Perlstein 	ok = xdr_replymsg(&reply_xdrs, &reply_msg);
5428360efbdSAlfred Perlstein 	/* XDR_DESTROY(&reply_xdrs);	save a few cycles on noop destroy */
5438360efbdSAlfred Perlstein 	if (ok) {
5448360efbdSAlfred Perlstein 		if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
5458360efbdSAlfred Perlstein 			(reply_msg.acpted_rply.ar_stat == SUCCESS))
5468360efbdSAlfred Perlstein 			cu->cu_error.re_status = RPC_SUCCESS;
5478360efbdSAlfred Perlstein 		else
5488360efbdSAlfred Perlstein 			_seterr_reply(&reply_msg, &(cu->cu_error));
5498360efbdSAlfred Perlstein 
5508360efbdSAlfred Perlstein 		if (cu->cu_error.re_status == RPC_SUCCESS) {
5518360efbdSAlfred Perlstein 			if (! AUTH_VALIDATE(cl->cl_auth,
5528360efbdSAlfred Perlstein 					    &reply_msg.acpted_rply.ar_verf)) {
5538360efbdSAlfred Perlstein 				cu->cu_error.re_status = RPC_AUTHERROR;
5548360efbdSAlfred Perlstein 				cu->cu_error.re_why = AUTH_INVALIDRESP;
5558360efbdSAlfred Perlstein 			}
5568360efbdSAlfred Perlstein 			if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
5578360efbdSAlfred Perlstein 				xdrs->x_op = XDR_FREE;
5588360efbdSAlfred Perlstein 				(void) xdr_opaque_auth(xdrs,
5598360efbdSAlfred Perlstein 					&(reply_msg.acpted_rply.ar_verf));
5608360efbdSAlfred Perlstein 			}
5618360efbdSAlfred Perlstein 		}		/* end successful completion */
5628360efbdSAlfred Perlstein 		/*
5638360efbdSAlfred Perlstein 		 * If unsuccesful AND error is an authentication error
5648360efbdSAlfred Perlstein 		 * then refresh credentials and try again, else break
5658360efbdSAlfred Perlstein 		 */
5668360efbdSAlfred Perlstein 		else if (cu->cu_error.re_status == RPC_AUTHERROR)
5678360efbdSAlfred Perlstein 			/* maybe our credentials need to be refreshed ... */
5688360efbdSAlfred Perlstein 			if (nrefreshes > 0 &&
5698360efbdSAlfred Perlstein 			    AUTH_REFRESH(cl->cl_auth, &reply_msg)) {
5708360efbdSAlfred Perlstein 				nrefreshes--;
5718360efbdSAlfred Perlstein 				goto call_again;
5728360efbdSAlfred Perlstein 			}
5738360efbdSAlfred Perlstein 		/* end of unsuccessful completion */
5748360efbdSAlfred Perlstein 	}	/* end of valid reply message */
5758360efbdSAlfred Perlstein 	else {
5768360efbdSAlfred Perlstein 		cu->cu_error.re_status = RPC_CANTDECODERES;
5778360efbdSAlfred Perlstein 
5788360efbdSAlfred Perlstein 	}
5798360efbdSAlfred Perlstein 	release_fd_lock(cu->cu_fd, mask);
5808360efbdSAlfred Perlstein 	return (cu->cu_error.re_status);
5818360efbdSAlfred Perlstein }
5828360efbdSAlfred Perlstein 
5838360efbdSAlfred Perlstein static void
5848360efbdSAlfred Perlstein clnt_dg_geterr(cl, errp)
5858360efbdSAlfred Perlstein 	CLIENT *cl;
5868360efbdSAlfred Perlstein 	struct rpc_err *errp;
5878360efbdSAlfred Perlstein {
5888360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
5898360efbdSAlfred Perlstein 
5908360efbdSAlfred Perlstein 	*errp = cu->cu_error;
5918360efbdSAlfred Perlstein }
5928360efbdSAlfred Perlstein 
5938360efbdSAlfred Perlstein static bool_t
5948360efbdSAlfred Perlstein clnt_dg_freeres(cl, xdr_res, res_ptr)
5958360efbdSAlfred Perlstein 	CLIENT *cl;
5968360efbdSAlfred Perlstein 	xdrproc_t xdr_res;
597f249dbccSDag-Erling Smørgrav 	void *res_ptr;
5988360efbdSAlfred Perlstein {
5998360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
6008360efbdSAlfred Perlstein 	XDR *xdrs = &(cu->cu_outxdrs);
6018360efbdSAlfred Perlstein 	bool_t dummy;
6028360efbdSAlfred Perlstein 	sigset_t mask;
6038360efbdSAlfred Perlstein 	sigset_t newmask;
6048360efbdSAlfred Perlstein 
6058360efbdSAlfred Perlstein 	sigfillset(&newmask);
6068360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
6078360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
6088360efbdSAlfred Perlstein 	while (dg_fd_locks[cu->cu_fd])
6098360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
6108360efbdSAlfred Perlstein 	xdrs->x_op = XDR_FREE;
6118360efbdSAlfred Perlstein 	dummy = (*xdr_res)(xdrs, res_ptr);
6128360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
6138360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &mask, NULL);
6148360efbdSAlfred Perlstein 	cond_signal(&dg_cv[cu->cu_fd]);
6158360efbdSAlfred Perlstein 	return (dummy);
6168360efbdSAlfred Perlstein }
6178360efbdSAlfred Perlstein 
6188360efbdSAlfred Perlstein /*ARGSUSED*/
6198360efbdSAlfred Perlstein static void
6208360efbdSAlfred Perlstein clnt_dg_abort(h)
6218360efbdSAlfred Perlstein 	CLIENT *h;
6228360efbdSAlfred Perlstein {
6238360efbdSAlfred Perlstein }
6248360efbdSAlfred Perlstein 
6258360efbdSAlfred Perlstein static bool_t
6268360efbdSAlfred Perlstein clnt_dg_control(cl, request, info)
6278360efbdSAlfred Perlstein 	CLIENT *cl;
6288360efbdSAlfred Perlstein 	u_int request;
6298360efbdSAlfred Perlstein 	char *info;
6308360efbdSAlfred Perlstein {
6318360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
6328360efbdSAlfred Perlstein 	struct netbuf *addr;
6338360efbdSAlfred Perlstein 	sigset_t mask;
6348360efbdSAlfred Perlstein 	sigset_t newmask;
6358360efbdSAlfred Perlstein 	int rpc_lock_value;
6368360efbdSAlfred Perlstein 
6378360efbdSAlfred Perlstein 	sigfillset(&newmask);
6388360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
6398360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
6408360efbdSAlfred Perlstein 	while (dg_fd_locks[cu->cu_fd])
6418360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
6428360efbdSAlfred Perlstein 	if (__isthreaded)
6438360efbdSAlfred Perlstein                 rpc_lock_value = 1;
6448360efbdSAlfred Perlstein         else
6458360efbdSAlfred Perlstein                 rpc_lock_value = 0;
6468360efbdSAlfred Perlstein 	dg_fd_locks[cu->cu_fd] = rpc_lock_value;
6478360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
6488360efbdSAlfred Perlstein 	switch (request) {
6498360efbdSAlfred Perlstein 	case CLSET_FD_CLOSE:
6508360efbdSAlfred Perlstein 		cu->cu_closeit = TRUE;
6518360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
6528360efbdSAlfred Perlstein 		return (TRUE);
6538360efbdSAlfred Perlstein 	case CLSET_FD_NCLOSE:
6548360efbdSAlfred Perlstein 		cu->cu_closeit = FALSE;
6558360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
6568360efbdSAlfred Perlstein 		return (TRUE);
6578360efbdSAlfred Perlstein 	}
6588360efbdSAlfred Perlstein 
6598360efbdSAlfred Perlstein 	/* for other requests which use info */
6608360efbdSAlfred Perlstein 	if (info == NULL) {
6618360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
6628360efbdSAlfred Perlstein 		return (FALSE);
6638360efbdSAlfred Perlstein 	}
6648360efbdSAlfred Perlstein 	switch (request) {
6658360efbdSAlfred Perlstein 	case CLSET_TIMEOUT:
6668360efbdSAlfred Perlstein 		if (time_not_ok((struct timeval *)(void *)info)) {
6678360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
6688360efbdSAlfred Perlstein 			return (FALSE);
6698360efbdSAlfred Perlstein 		}
6708360efbdSAlfred Perlstein 		cu->cu_total = *(struct timeval *)(void *)info;
6718360efbdSAlfred Perlstein 		break;
6728360efbdSAlfred Perlstein 	case CLGET_TIMEOUT:
6738360efbdSAlfred Perlstein 		*(struct timeval *)(void *)info = cu->cu_total;
6748360efbdSAlfred Perlstein 		break;
6758360efbdSAlfred Perlstein 	case CLGET_SERVER_ADDR:		/* Give him the fd address */
6768360efbdSAlfred Perlstein 		/* Now obsolete. Only for backward compatibility */
6778360efbdSAlfred Perlstein 		(void) memcpy(info, &cu->cu_raddr, (size_t)cu->cu_rlen);
6788360efbdSAlfred Perlstein 		break;
6798360efbdSAlfred Perlstein 	case CLSET_RETRY_TIMEOUT:
6808360efbdSAlfred Perlstein 		if (time_not_ok((struct timeval *)(void *)info)) {
6818360efbdSAlfred Perlstein 			release_fd_lock(cu->cu_fd, mask);
6828360efbdSAlfred Perlstein 			return (FALSE);
6838360efbdSAlfred Perlstein 		}
6848360efbdSAlfred Perlstein 		cu->cu_wait = *(struct timeval *)(void *)info;
6858360efbdSAlfred Perlstein 		break;
6868360efbdSAlfred Perlstein 	case CLGET_RETRY_TIMEOUT:
6878360efbdSAlfred Perlstein 		*(struct timeval *)(void *)info = cu->cu_wait;
6888360efbdSAlfred Perlstein 		break;
6898360efbdSAlfred Perlstein 	case CLGET_FD:
6908360efbdSAlfred Perlstein 		*(int *)(void *)info = cu->cu_fd;
6918360efbdSAlfred Perlstein 		break;
6928360efbdSAlfred Perlstein 	case CLGET_SVC_ADDR:
6938360efbdSAlfred Perlstein 		addr = (struct netbuf *)(void *)info;
6948360efbdSAlfred Perlstein 		addr->buf = &cu->cu_raddr;
6958360efbdSAlfred Perlstein 		addr->len = cu->cu_rlen;
6968360efbdSAlfred Perlstein 		addr->maxlen = sizeof cu->cu_raddr;
6978360efbdSAlfred Perlstein 		break;
6988360efbdSAlfred Perlstein 	case CLSET_SVC_ADDR:		/* set to new address */
6998360efbdSAlfred Perlstein 		addr = (struct netbuf *)(void *)info;
700cd517469SIan Dowse 		if (addr->len < sizeof cu->cu_raddr) {
701cd517469SIan Dowse 			release_fd_lock(cu->cu_fd, mask);
7028360efbdSAlfred Perlstein 			return (FALSE);
703cd517469SIan Dowse 		}
7048360efbdSAlfred Perlstein 		(void) memcpy(&cu->cu_raddr, addr->buf, addr->len);
7058360efbdSAlfred Perlstein 		cu->cu_rlen = addr->len;
7068360efbdSAlfred Perlstein 		break;
7078360efbdSAlfred Perlstein 	case CLGET_XID:
7088360efbdSAlfred Perlstein 		/*
7098360efbdSAlfred Perlstein 		 * use the knowledge that xid is the
7108360efbdSAlfred Perlstein 		 * first element in the call structure *.
7118360efbdSAlfred Perlstein 		 * This will get the xid of the PREVIOUS call
7128360efbdSAlfred Perlstein 		 */
7138360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)info =
7148360efbdSAlfred Perlstein 		    ntohl(*(u_int32_t *)(void *)cu->cu_outbuf);
7158360efbdSAlfred Perlstein 		break;
7168360efbdSAlfred Perlstein 
7178360efbdSAlfred Perlstein 	case CLSET_XID:
7188360efbdSAlfred Perlstein 		/* This will set the xid of the NEXT call */
7198360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)cu->cu_outbuf =
7208360efbdSAlfred Perlstein 		    htonl(*(u_int32_t *)(void *)info - 1);
7218360efbdSAlfred Perlstein 		/* decrement by 1 as clnt_dg_call() increments once */
7228360efbdSAlfred Perlstein 		break;
7238360efbdSAlfred Perlstein 
7248360efbdSAlfred Perlstein 	case CLGET_VERS:
7258360efbdSAlfred Perlstein 		/*
7268360efbdSAlfred Perlstein 		 * This RELIES on the information that, in the call body,
7278360efbdSAlfred Perlstein 		 * the version number field is the fifth field from the
7288360efbdSAlfred Perlstein 		 * begining of the RPC header. MUST be changed if the
7298360efbdSAlfred Perlstein 		 * call_struct is changed
7308360efbdSAlfred Perlstein 		 */
7318360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)info =
7328360efbdSAlfred Perlstein 		    ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf +
7338360efbdSAlfred Perlstein 		    4 * BYTES_PER_XDR_UNIT));
7348360efbdSAlfred Perlstein 		break;
7358360efbdSAlfred Perlstein 
7368360efbdSAlfred Perlstein 	case CLSET_VERS:
7378360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT)
7388360efbdSAlfred Perlstein 			= htonl(*(u_int32_t *)(void *)info);
7398360efbdSAlfred Perlstein 		break;
7408360efbdSAlfred Perlstein 
7418360efbdSAlfred Perlstein 	case CLGET_PROG:
7428360efbdSAlfred Perlstein 		/*
7438360efbdSAlfred Perlstein 		 * This RELIES on the information that, in the call body,
7448360efbdSAlfred Perlstein 		 * the program number field is the fourth field from the
7458360efbdSAlfred Perlstein 		 * begining of the RPC header. MUST be changed if the
7468360efbdSAlfred Perlstein 		 * call_struct is changed
7478360efbdSAlfred Perlstein 		 */
7488360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)info =
7498360efbdSAlfred Perlstein 		    ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf +
7508360efbdSAlfred Perlstein 		    3 * BYTES_PER_XDR_UNIT));
7518360efbdSAlfred Perlstein 		break;
7528360efbdSAlfred Perlstein 
7538360efbdSAlfred Perlstein 	case CLSET_PROG:
7548360efbdSAlfred Perlstein 		*(u_int32_t *)(void *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT)
7558360efbdSAlfred Perlstein 			= htonl(*(u_int32_t *)(void *)info);
7568360efbdSAlfred Perlstein 		break;
75765d3c627SBill Paul 	case CLSET_ASYNC:
75865d3c627SBill Paul 		cu->cu_async = *(int *)(void *)info;
75965d3c627SBill Paul 		break;
76032de72d2SIan Dowse 	case CLSET_CONNECT:
76132de72d2SIan Dowse 		cu->cu_connect = *(int *)(void *)info;
76232de72d2SIan Dowse 		break;
7638360efbdSAlfred Perlstein 	default:
7648360efbdSAlfred Perlstein 		release_fd_lock(cu->cu_fd, mask);
7658360efbdSAlfred Perlstein 		return (FALSE);
7668360efbdSAlfred Perlstein 	}
7678360efbdSAlfred Perlstein 	release_fd_lock(cu->cu_fd, mask);
7688360efbdSAlfred Perlstein 	return (TRUE);
7698360efbdSAlfred Perlstein }
7708360efbdSAlfred Perlstein 
7718360efbdSAlfred Perlstein static void
7728360efbdSAlfred Perlstein clnt_dg_destroy(cl)
7738360efbdSAlfred Perlstein 	CLIENT *cl;
7748360efbdSAlfred Perlstein {
7758360efbdSAlfred Perlstein 	struct cu_data *cu = (struct cu_data *)cl->cl_private;
7768360efbdSAlfred Perlstein 	int cu_fd = cu->cu_fd;
7778360efbdSAlfred Perlstein 	sigset_t mask;
7788360efbdSAlfred Perlstein 	sigset_t newmask;
7798360efbdSAlfred Perlstein 
7808360efbdSAlfred Perlstein 	sigfillset(&newmask);
7818360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
7828360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
7838360efbdSAlfred Perlstein 	while (dg_fd_locks[cu_fd])
7848360efbdSAlfred Perlstein 		cond_wait(&dg_cv[cu_fd], &clnt_fd_lock);
7858360efbdSAlfred Perlstein 	if (cu->cu_closeit)
7868360efbdSAlfred Perlstein 		(void)_close(cu_fd);
7878360efbdSAlfred Perlstein 	XDR_DESTROY(&(cu->cu_outxdrs));
7888360efbdSAlfred Perlstein 	mem_free(cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
7898360efbdSAlfred Perlstein 	if (cl->cl_netid && cl->cl_netid[0])
7908360efbdSAlfred Perlstein 		mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
7918360efbdSAlfred Perlstein 	if (cl->cl_tp && cl->cl_tp[0])
7928360efbdSAlfred Perlstein 		mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
7938360efbdSAlfred Perlstein 	mem_free(cl, sizeof (CLIENT));
7948360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
7958360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &mask, NULL);
7968360efbdSAlfred Perlstein 	cond_signal(&dg_cv[cu_fd]);
7978360efbdSAlfred Perlstein }
7988360efbdSAlfred Perlstein 
7998360efbdSAlfred Perlstein static struct clnt_ops *
8008360efbdSAlfred Perlstein clnt_dg_ops()
8018360efbdSAlfred Perlstein {
8028360efbdSAlfred Perlstein 	static struct clnt_ops ops;
8038360efbdSAlfred Perlstein 	extern mutex_t	ops_lock;
8048360efbdSAlfred Perlstein 	sigset_t mask;
8058360efbdSAlfred Perlstein 	sigset_t newmask;
8068360efbdSAlfred Perlstein 
8078360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY ops_lock: ops */
8088360efbdSAlfred Perlstein 
8098360efbdSAlfred Perlstein 	sigfillset(&newmask);
8108360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
8118360efbdSAlfred Perlstein 	mutex_lock(&ops_lock);
8128360efbdSAlfred Perlstein 	if (ops.cl_call == NULL) {
8138360efbdSAlfred Perlstein 		ops.cl_call = clnt_dg_call;
8148360efbdSAlfred Perlstein 		ops.cl_abort = clnt_dg_abort;
8158360efbdSAlfred Perlstein 		ops.cl_geterr = clnt_dg_geterr;
8168360efbdSAlfred Perlstein 		ops.cl_freeres = clnt_dg_freeres;
8178360efbdSAlfred Perlstein 		ops.cl_destroy = clnt_dg_destroy;
8188360efbdSAlfred Perlstein 		ops.cl_control = clnt_dg_control;
8198360efbdSAlfred Perlstein 	}
8208360efbdSAlfred Perlstein 	mutex_unlock(&ops_lock);
8218360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &mask, NULL);
8228360efbdSAlfred Perlstein 	return (&ops);
8238360efbdSAlfred Perlstein }
8248360efbdSAlfred Perlstein 
8258360efbdSAlfred Perlstein /*
8268360efbdSAlfred Perlstein  * Make sure that the time is not garbage.  -1 value is allowed.
8278360efbdSAlfred Perlstein  */
8288360efbdSAlfred Perlstein static bool_t
8298360efbdSAlfred Perlstein time_not_ok(t)
8308360efbdSAlfred Perlstein 	struct timeval *t;
8318360efbdSAlfred Perlstein {
8328360efbdSAlfred Perlstein 	return (t->tv_sec < -1 || t->tv_sec > 100000000 ||
8338360efbdSAlfred Perlstein 		t->tv_usec < -1 || t->tv_usec > 1000000);
8348360efbdSAlfred Perlstein }
8358360efbdSAlfred Perlstein 
8368360efbdSAlfred Perlstein 
8378360efbdSAlfred Perlstein /*
8388360efbdSAlfred Perlstein  *	Convert from timevals (used by select) to milliseconds (used by poll).
8398360efbdSAlfred Perlstein  */
8408360efbdSAlfred Perlstein static int
8418360efbdSAlfred Perlstein __rpc_timeval_to_msec(t)
8428360efbdSAlfred Perlstein 	struct timeval	*t;
8438360efbdSAlfred Perlstein {
8448360efbdSAlfred Perlstein 	int	t1, tmp;
8458360efbdSAlfred Perlstein 
8468360efbdSAlfred Perlstein 	/*
8478360efbdSAlfred Perlstein 	 *	We're really returning t->tv_sec * 1000 + (t->tv_usec / 1000)
8488360efbdSAlfred Perlstein 	 *	but try to do so efficiently.  Note:  1000 = 1024 - 16 - 8.
8498360efbdSAlfred Perlstein 	 */
8508360efbdSAlfred Perlstein 	tmp = (int)t->tv_sec << 3;
8518360efbdSAlfred Perlstein 	t1 = -tmp;
8528360efbdSAlfred Perlstein 	t1 += t1 << 1;
8538360efbdSAlfred Perlstein 	t1 += tmp << 7;
8548360efbdSAlfred Perlstein 	if (t->tv_usec)
8558360efbdSAlfred Perlstein 		t1 += (int)(t->tv_usec / 1000);
8568360efbdSAlfred Perlstein 
8578360efbdSAlfred Perlstein 	return (t1);
8588360efbdSAlfred Perlstein }
859