xref: /freebsd/lib/libc/rpc/clnt_vc.c (revision 32223c1b7dea9bcf5ccb35a6462fb6a29a344910)
18360efbdSAlfred Perlstein /*	$NetBSD: clnt_vc.c,v 1.4 2000/07/14 08:40:42 fvdl Exp $	*/
28360efbdSAlfred Perlstein 
32e322d37SHiroki Sato /*-
42e322d37SHiroki Sato  * Copyright (c) 2009, Sun Microsystems, Inc.
52e322d37SHiroki Sato  * All rights reserved.
68360efbdSAlfred Perlstein  *
72e322d37SHiroki Sato  * Redistribution and use in source and binary forms, with or without
82e322d37SHiroki Sato  * modification, are permitted provided that the following conditions are met:
92e322d37SHiroki Sato  * - Redistributions of source code must retain the above copyright notice,
102e322d37SHiroki Sato  *   this list of conditions and the following disclaimer.
112e322d37SHiroki Sato  * - Redistributions in binary form must reproduce the above copyright notice,
122e322d37SHiroki Sato  *   this list of conditions and the following disclaimer in the documentation
132e322d37SHiroki Sato  *   and/or other materials provided with the distribution.
142e322d37SHiroki Sato  * - Neither the name of Sun Microsystems, Inc. nor the names of its
152e322d37SHiroki Sato  *   contributors may be used to endorse or promote products derived
162e322d37SHiroki Sato  *   from this software without specific prior written permission.
178360efbdSAlfred Perlstein  *
182e322d37SHiroki Sato  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
192e322d37SHiroki Sato  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
202e322d37SHiroki Sato  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
212e322d37SHiroki Sato  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
222e322d37SHiroki Sato  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
232e322d37SHiroki Sato  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
242e322d37SHiroki Sato  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
252e322d37SHiroki Sato  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
262e322d37SHiroki Sato  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
272e322d37SHiroki Sato  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
282e322d37SHiroki Sato  * POSSIBILITY OF SUCH DAMAGE.
298360efbdSAlfred Perlstein  */
308360efbdSAlfred Perlstein 
318360efbdSAlfred Perlstein #if defined(LIBC_SCCS) && !defined(lint)
32a986ef57SDavid E. O'Brien static char *sccsid2 = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro";
338360efbdSAlfred Perlstein static char *sccsid = "@(#)clnt_tcp.c	2.2 88/08/01 4.0 RPCSRC";
34a986ef57SDavid E. O'Brien static char sccsid3[] = "@(#)clnt_vc.c 1.19 89/03/16 Copyr 1988 Sun Micro";
358360efbdSAlfred Perlstein #endif
36d3d20c82SDavid E. O'Brien #include <sys/cdefs.h>
37d3d20c82SDavid E. O'Brien __FBSDID("$FreeBSD$");
388360efbdSAlfred Perlstein 
398360efbdSAlfred Perlstein /*
408360efbdSAlfred Perlstein  * clnt_tcp.c, Implements a TCP/IP based, client side RPC.
418360efbdSAlfred Perlstein  *
428360efbdSAlfred Perlstein  * Copyright (C) 1984, Sun Microsystems, Inc.
438360efbdSAlfred Perlstein  *
448360efbdSAlfred Perlstein  * TCP based RPC supports 'batched calls'.
458360efbdSAlfred Perlstein  * A sequence of calls may be batched-up in a send buffer.  The rpc call
468360efbdSAlfred Perlstein  * return immediately to the client even though the call was not necessarily
478360efbdSAlfred Perlstein  * sent.  The batching occurs if the results' xdr routine is NULL (0) AND
488360efbdSAlfred Perlstein  * the rpc timeout value is zero (see clnt.h, rpc).
498360efbdSAlfred Perlstein  *
508360efbdSAlfred Perlstein  * Clients should NOT casually batch calls that in fact return results; that is,
518360efbdSAlfred Perlstein  * the server side should be aware that a call is batched and not produce any
528360efbdSAlfred Perlstein  * return message.  Batched calls that produce many result messages can
538360efbdSAlfred Perlstein  * deadlock (netlock) the client and the server....
548360efbdSAlfred Perlstein  *
558360efbdSAlfred Perlstein  * Now go hang yourself.
568360efbdSAlfred Perlstein  */
578360efbdSAlfred Perlstein 
588360efbdSAlfred Perlstein #include "namespace.h"
599f5afc13SIan Dowse #include "reentrant.h"
608360efbdSAlfred Perlstein #include <sys/types.h>
618360efbdSAlfred Perlstein #include <sys/poll.h>
628360efbdSAlfred Perlstein #include <sys/syslog.h>
638360efbdSAlfred Perlstein #include <sys/socket.h>
648360efbdSAlfred Perlstein #include <sys/un.h>
658360efbdSAlfred Perlstein #include <sys/uio.h>
668360efbdSAlfred Perlstein 
67fd8e4ebcSMike Barcroft #include <arpa/inet.h>
688360efbdSAlfred Perlstein #include <assert.h>
698360efbdSAlfred Perlstein #include <err.h>
708360efbdSAlfred Perlstein #include <errno.h>
718360efbdSAlfred Perlstein #include <netdb.h>
728360efbdSAlfred Perlstein #include <stdio.h>
738360efbdSAlfred Perlstein #include <stdlib.h>
748360efbdSAlfred Perlstein #include <string.h>
758360efbdSAlfred Perlstein #include <unistd.h>
768360efbdSAlfred Perlstein #include <signal.h>
778360efbdSAlfred Perlstein 
788360efbdSAlfred Perlstein #include <rpc/rpc.h>
798f55a568SDoug Rabson #include <rpc/rpcsec_gss.h>
808360efbdSAlfred Perlstein #include "un-namespace.h"
818360efbdSAlfred Perlstein #include "rpc_com.h"
82235baf26SDaniel Eischen #include "mt_misc.h"
838360efbdSAlfred Perlstein 
848360efbdSAlfred Perlstein #define MCALL_MSG_SIZE 24
858360efbdSAlfred Perlstein 
86392df6bcSAlfred Perlstein struct cmessage {
87392df6bcSAlfred Perlstein         struct cmsghdr cmsg;
88392df6bcSAlfred Perlstein         struct cmsgcred cmcred;
89392df6bcSAlfred Perlstein };
90392df6bcSAlfred Perlstein 
91f249dbccSDag-Erling Smørgrav static enum clnt_stat clnt_vc_call(CLIENT *, rpcproc_t, xdrproc_t, void *,
92f249dbccSDag-Erling Smørgrav     xdrproc_t, void *, struct timeval);
93c05ac53bSDavid E. O'Brien static void clnt_vc_geterr(CLIENT *, struct rpc_err *);
94f249dbccSDag-Erling Smørgrav static bool_t clnt_vc_freeres(CLIENT *, xdrproc_t, void *);
95c05ac53bSDavid E. O'Brien static void clnt_vc_abort(CLIENT *);
96cffc0b57SAlfred Perlstein static bool_t clnt_vc_control(CLIENT *, u_int, void *);
97c05ac53bSDavid E. O'Brien static void clnt_vc_destroy(CLIENT *);
98c05ac53bSDavid E. O'Brien static struct clnt_ops *clnt_vc_ops(void);
99c05ac53bSDavid E. O'Brien static bool_t time_not_ok(struct timeval *);
100f249dbccSDag-Erling Smørgrav static int read_vc(void *, void *, int);
101f249dbccSDag-Erling Smørgrav static int write_vc(void *, void *, int);
1028360efbdSAlfred Perlstein static int __msgwrite(int, void *, size_t);
1038360efbdSAlfred Perlstein static int __msgread(int, void *, size_t);
1048360efbdSAlfred Perlstein 
1058360efbdSAlfred Perlstein struct ct_data {
1068360efbdSAlfred Perlstein 	int		ct_fd;		/* connection's fd */
1078360efbdSAlfred Perlstein 	bool_t		ct_closeit;	/* close it on destroy */
1088360efbdSAlfred Perlstein 	struct timeval	ct_wait;	/* wait interval in milliseconds */
1098360efbdSAlfred Perlstein 	bool_t          ct_waitset;	/* wait set by clnt_control? */
1108360efbdSAlfred Perlstein 	struct netbuf	ct_addr;	/* remote addr */
1118360efbdSAlfred Perlstein 	struct rpc_err	ct_error;
1128360efbdSAlfred Perlstein 	union {
1138360efbdSAlfred Perlstein 		char	ct_mcallc[MCALL_MSG_SIZE];	/* marshalled callmsg */
1148360efbdSAlfred Perlstein 		u_int32_t ct_mcalli;
1158360efbdSAlfred Perlstein 	} ct_u;
1168360efbdSAlfred Perlstein 	u_int		ct_mpos;	/* pos after marshal */
1178360efbdSAlfred Perlstein 	XDR		ct_xdrs;	/* XDR stream */
1188360efbdSAlfred Perlstein };
1198360efbdSAlfred Perlstein 
1208360efbdSAlfred Perlstein /*
1218360efbdSAlfred Perlstein  *      This machinery implements per-fd locks for MT-safety.  It is not
1228360efbdSAlfred Perlstein  *      sufficient to do per-CLIENT handle locks for MT-safety because a
1238360efbdSAlfred Perlstein  *      user may create more than one CLIENT handle with the same fd behind
1248360efbdSAlfred Perlstein  *      it.  Therfore, we allocate an array of flags (vc_fd_locks), protected
1258360efbdSAlfred Perlstein  *      by the clnt_fd_lock mutex, and an array (vc_cv) of condition variables
1268360efbdSAlfred Perlstein  *      similarly protected.  Vc_fd_lock[fd] == 1 => a call is activte on some
1278360efbdSAlfred Perlstein  *      CLIENT handle created for that fd.
1288360efbdSAlfred Perlstein  *      The current implementation holds locks across the entire RPC and reply.
1298360efbdSAlfred Perlstein  *      Yes, this is silly, and as soon as this code is proven to work, this
1308360efbdSAlfred Perlstein  *      should be the first thing fixed.  One step at a time.
1318360efbdSAlfred Perlstein  */
1328360efbdSAlfred Perlstein static int      *vc_fd_locks;
1338360efbdSAlfred Perlstein static cond_t   *vc_cv;
1348360efbdSAlfred Perlstein #define release_fd_lock(fd, mask) {	\
1358360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);	\
1368360efbdSAlfred Perlstein 	vc_fd_locks[fd] = 0;		\
1378360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);	\
1388360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &(mask), (sigset_t *) NULL);	\
1398360efbdSAlfred Perlstein 	cond_signal(&vc_cv[fd]);	\
1408360efbdSAlfred Perlstein }
1418360efbdSAlfred Perlstein 
1428360efbdSAlfred Perlstein static const char clnt_vc_errstr[] = "%s : %s";
1438360efbdSAlfred Perlstein static const char clnt_vc_str[] = "clnt_vc_create";
1448360efbdSAlfred Perlstein static const char __no_mem_str[] = "out of memory";
1458360efbdSAlfred Perlstein 
1468360efbdSAlfred Perlstein /*
1478360efbdSAlfred Perlstein  * Create a client handle for a connection.
1488360efbdSAlfred Perlstein  * Default options are set, which the user can change using clnt_control()'s.
1498360efbdSAlfred Perlstein  * The rpc/vc package does buffering similar to stdio, so the client
1508360efbdSAlfred Perlstein  * must pick send and receive buffer sizes, 0 => use the default.
1518360efbdSAlfred Perlstein  * NB: fd is copied into a private area.
1528360efbdSAlfred Perlstein  * NB: The rpch->cl_auth is set null authentication. Caller may wish to
1538360efbdSAlfred Perlstein  * set this something more useful.
1548360efbdSAlfred Perlstein  *
1558360efbdSAlfred Perlstein  * fd should be an open socket
156587cf682SCraig Rodrigues  *
157587cf682SCraig Rodrigues  * fd - open file descriptor
158587cf682SCraig Rodrigues  * raddr - servers address
159587cf682SCraig Rodrigues  * prog  - program number
160587cf682SCraig Rodrigues  * vers  - version number
161587cf682SCraig Rodrigues  * sendsz - buffer send size
162587cf682SCraig Rodrigues  * recvsz - buffer recv size
1638360efbdSAlfred Perlstein  */
1648360efbdSAlfred Perlstein CLIENT *
165587cf682SCraig Rodrigues clnt_vc_create(int fd, const struct netbuf *raddr, const rpcprog_t prog,
166587cf682SCraig Rodrigues     const rpcvers_t vers, u_int sendsz, u_int recvsz)
1678360efbdSAlfred Perlstein {
1688360efbdSAlfred Perlstein 	CLIENT *cl;			/* client handle */
1698360efbdSAlfred Perlstein 	struct ct_data *ct = NULL;	/* client handle */
1708360efbdSAlfred Perlstein 	struct timeval now;
1718360efbdSAlfred Perlstein 	struct rpc_msg call_msg;
1728360efbdSAlfred Perlstein 	static u_int32_t disrupt;
1738360efbdSAlfred Perlstein 	sigset_t mask;
1748360efbdSAlfred Perlstein 	sigset_t newmask;
1758360efbdSAlfred Perlstein 	struct sockaddr_storage ss;
1768360efbdSAlfred Perlstein 	socklen_t slen;
1778360efbdSAlfred Perlstein 	struct __rpc_sockinfo si;
1788360efbdSAlfred Perlstein 
1798360efbdSAlfred Perlstein 	if (disrupt == 0)
1808360efbdSAlfred Perlstein 		disrupt = (u_int32_t)(long)raddr;
1818360efbdSAlfred Perlstein 
1828360efbdSAlfred Perlstein 	cl = (CLIENT *)mem_alloc(sizeof (*cl));
1838360efbdSAlfred Perlstein 	ct = (struct ct_data *)mem_alloc(sizeof (*ct));
1848360efbdSAlfred Perlstein 	if ((cl == (CLIENT *)NULL) || (ct == (struct ct_data *)NULL)) {
1858360efbdSAlfred Perlstein 		(void) syslog(LOG_ERR, clnt_vc_errstr,
1868360efbdSAlfred Perlstein 		    clnt_vc_str, __no_mem_str);
1878360efbdSAlfred Perlstein 		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
1888360efbdSAlfred Perlstein 		rpc_createerr.cf_error.re_errno = errno;
1898360efbdSAlfred Perlstein 		goto err;
1908360efbdSAlfred Perlstein 	}
1918360efbdSAlfred Perlstein 	ct->ct_addr.buf = NULL;
1928360efbdSAlfred Perlstein 	sigfillset(&newmask);
1938360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
1948360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
1958360efbdSAlfred Perlstein 	if (vc_fd_locks == (int *) NULL) {
1968360efbdSAlfred Perlstein 		int cv_allocsz, fd_allocsz;
1978360efbdSAlfred Perlstein 		int dtbsize = __rpc_dtbsize();
1988360efbdSAlfred Perlstein 
1998360efbdSAlfred Perlstein 		fd_allocsz = dtbsize * sizeof (int);
2008360efbdSAlfred Perlstein 		vc_fd_locks = (int *) mem_alloc(fd_allocsz);
2018360efbdSAlfred Perlstein 		if (vc_fd_locks == (int *) NULL) {
2028360efbdSAlfred Perlstein 			mutex_unlock(&clnt_fd_lock);
2038360efbdSAlfred Perlstein 			thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
2048360efbdSAlfred Perlstein 			goto err;
2058360efbdSAlfred Perlstein 		} else
2068360efbdSAlfred Perlstein 			memset(vc_fd_locks, '\0', fd_allocsz);
2078360efbdSAlfred Perlstein 
2088360efbdSAlfred Perlstein 		assert(vc_cv == (cond_t *) NULL);
2098360efbdSAlfred Perlstein 		cv_allocsz = dtbsize * sizeof (cond_t);
2108360efbdSAlfred Perlstein 		vc_cv = (cond_t *) mem_alloc(cv_allocsz);
2118360efbdSAlfred Perlstein 		if (vc_cv == (cond_t *) NULL) {
2128360efbdSAlfred Perlstein 			mem_free(vc_fd_locks, fd_allocsz);
2138360efbdSAlfred Perlstein 			vc_fd_locks = (int *) NULL;
2148360efbdSAlfred Perlstein 			mutex_unlock(&clnt_fd_lock);
2158360efbdSAlfred Perlstein 			thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
2168360efbdSAlfred Perlstein 			goto err;
2178360efbdSAlfred Perlstein 		} else {
2188360efbdSAlfred Perlstein 			int i;
2198360efbdSAlfred Perlstein 
2208360efbdSAlfred Perlstein 			for (i = 0; i < dtbsize; i++)
2218360efbdSAlfred Perlstein 				cond_init(&vc_cv[i], 0, (void *) 0);
2228360efbdSAlfred Perlstein 		}
2238360efbdSAlfred Perlstein 	} else
2248360efbdSAlfred Perlstein 		assert(vc_cv != (cond_t *) NULL);
2258360efbdSAlfred Perlstein 
2268360efbdSAlfred Perlstein 	/*
2278360efbdSAlfred Perlstein 	 * XXX - fvdl connecting while holding a mutex?
2288360efbdSAlfred Perlstein 	 */
2298360efbdSAlfred Perlstein 	slen = sizeof ss;
2308360efbdSAlfred Perlstein 	if (_getpeername(fd, (struct sockaddr *)(void *)&ss, &slen) < 0) {
2318360efbdSAlfred Perlstein 		if (errno != ENOTCONN) {
2328360efbdSAlfred Perlstein 			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
2338360efbdSAlfred Perlstein 			rpc_createerr.cf_error.re_errno = errno;
2348360efbdSAlfred Perlstein 			mutex_unlock(&clnt_fd_lock);
235cd517469SIan Dowse 			thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
2368360efbdSAlfred Perlstein 			goto err;
2378360efbdSAlfred Perlstein 		}
2388360efbdSAlfred Perlstein 		if (_connect(fd, (struct sockaddr *)raddr->buf, raddr->len) < 0){
2398360efbdSAlfred Perlstein 			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
2408360efbdSAlfred Perlstein 			rpc_createerr.cf_error.re_errno = errno;
2418360efbdSAlfred Perlstein 			mutex_unlock(&clnt_fd_lock);
242cd517469SIan Dowse 			thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
2438360efbdSAlfred Perlstein 			goto err;
2448360efbdSAlfred Perlstein 		}
2458360efbdSAlfred Perlstein 	}
2468360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
247b0eb405dSMartin Blapp 	thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
2488360efbdSAlfred Perlstein 	if (!__rpc_fd2sockinfo(fd, &si))
2498360efbdSAlfred Perlstein 		goto err;
2508360efbdSAlfred Perlstein 
2518360efbdSAlfred Perlstein 	ct->ct_closeit = FALSE;
2528360efbdSAlfred Perlstein 
2538360efbdSAlfred Perlstein 	/*
2548360efbdSAlfred Perlstein 	 * Set up private data struct
2558360efbdSAlfred Perlstein 	 */
2568360efbdSAlfred Perlstein 	ct->ct_fd = fd;
2578360efbdSAlfred Perlstein 	ct->ct_wait.tv_usec = 0;
2588360efbdSAlfred Perlstein 	ct->ct_waitset = FALSE;
2598360efbdSAlfred Perlstein 	ct->ct_addr.buf = malloc(raddr->maxlen);
2608360efbdSAlfred Perlstein 	if (ct->ct_addr.buf == NULL)
2618360efbdSAlfred Perlstein 		goto err;
262a8634a00SIan Dowse 	memcpy(ct->ct_addr.buf, raddr->buf, raddr->len);
2635ee74037SKevin Lo 	ct->ct_addr.len = raddr->len;
2648360efbdSAlfred Perlstein 	ct->ct_addr.maxlen = raddr->maxlen;
2658360efbdSAlfred Perlstein 
2668360efbdSAlfred Perlstein 	/*
2678360efbdSAlfred Perlstein 	 * Initialize call message
2688360efbdSAlfred Perlstein 	 */
2698360efbdSAlfred Perlstein 	(void)gettimeofday(&now, NULL);
2708360efbdSAlfred Perlstein 	call_msg.rm_xid = ((u_int32_t)++disrupt) ^ __RPC_GETXID(&now);
2718360efbdSAlfred Perlstein 	call_msg.rm_direction = CALL;
2728360efbdSAlfred Perlstein 	call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
2738360efbdSAlfred Perlstein 	call_msg.rm_call.cb_prog = (u_int32_t)prog;
2748360efbdSAlfred Perlstein 	call_msg.rm_call.cb_vers = (u_int32_t)vers;
2758360efbdSAlfred Perlstein 
2768360efbdSAlfred Perlstein 	/*
2778360efbdSAlfred Perlstein 	 * pre-serialize the static part of the call msg and stash it away
2788360efbdSAlfred Perlstein 	 */
2798360efbdSAlfred Perlstein 	xdrmem_create(&(ct->ct_xdrs), ct->ct_u.ct_mcallc, MCALL_MSG_SIZE,
2808360efbdSAlfred Perlstein 	    XDR_ENCODE);
2818360efbdSAlfred Perlstein 	if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) {
2828360efbdSAlfred Perlstein 		if (ct->ct_closeit) {
2838360efbdSAlfred Perlstein 			(void)_close(fd);
2848360efbdSAlfred Perlstein 		}
2858360efbdSAlfred Perlstein 		goto err;
2868360efbdSAlfred Perlstein 	}
2878360efbdSAlfred Perlstein 	ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs));
2888360efbdSAlfred Perlstein 	XDR_DESTROY(&(ct->ct_xdrs));
2898f55a568SDoug Rabson 	assert(ct->ct_mpos + sizeof(uint32_t) <= MCALL_MSG_SIZE);
2908360efbdSAlfred Perlstein 
2918360efbdSAlfred Perlstein 	/*
2928360efbdSAlfred Perlstein 	 * Create a client handle which uses xdrrec for serialization
2938360efbdSAlfred Perlstein 	 * and authnone for authentication.
2948360efbdSAlfred Perlstein 	 */
2958360efbdSAlfred Perlstein 	cl->cl_ops = clnt_vc_ops();
2968360efbdSAlfred Perlstein 	cl->cl_private = ct;
2978360efbdSAlfred Perlstein 	cl->cl_auth = authnone_create();
2988360efbdSAlfred Perlstein 	sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz);
2998360efbdSAlfred Perlstein 	recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz);
3008360efbdSAlfred Perlstein 	xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz,
3018360efbdSAlfred Perlstein 	    cl->cl_private, read_vc, write_vc);
3028360efbdSAlfred Perlstein 	return (cl);
3038360efbdSAlfred Perlstein 
3048360efbdSAlfred Perlstein err:
3058360efbdSAlfred Perlstein 	if (ct) {
3068360efbdSAlfred Perlstein 		if (ct->ct_addr.len)
3078360efbdSAlfred Perlstein 			mem_free(ct->ct_addr.buf, ct->ct_addr.len);
308f249dbccSDag-Erling Smørgrav 		mem_free(ct, sizeof (struct ct_data));
3098360efbdSAlfred Perlstein 	}
3108360efbdSAlfred Perlstein 	if (cl)
311f249dbccSDag-Erling Smørgrav 		mem_free(cl, sizeof (CLIENT));
3128360efbdSAlfred Perlstein 	return ((CLIENT *)NULL);
3138360efbdSAlfred Perlstein }
3148360efbdSAlfred Perlstein 
3158360efbdSAlfred Perlstein static enum clnt_stat
316587cf682SCraig Rodrigues clnt_vc_call(CLIENT *cl, rpcproc_t proc, xdrproc_t xdr_args, void *args_ptr,
317587cf682SCraig Rodrigues     xdrproc_t xdr_results, void *results_ptr, struct timeval timeout)
3188360efbdSAlfred Perlstein {
3198360efbdSAlfred Perlstein 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
3208360efbdSAlfred Perlstein 	XDR *xdrs = &(ct->ct_xdrs);
3218360efbdSAlfred Perlstein 	struct rpc_msg reply_msg;
3228360efbdSAlfred Perlstein 	u_int32_t x_id;
3238360efbdSAlfred Perlstein 	u_int32_t *msg_x_id = &ct->ct_u.ct_mcalli;    /* yuk */
3248360efbdSAlfred Perlstein 	bool_t shipnow;
3258360efbdSAlfred Perlstein 	int refreshes = 2;
3268360efbdSAlfred Perlstein 	sigset_t mask, newmask;
3278360efbdSAlfred Perlstein 	int rpc_lock_value;
3288f55a568SDoug Rabson 	bool_t reply_stat;
3298360efbdSAlfred Perlstein 
3308360efbdSAlfred Perlstein 	assert(cl != NULL);
3318360efbdSAlfred Perlstein 
3328360efbdSAlfred Perlstein 	sigfillset(&newmask);
3338360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
3348360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
3358360efbdSAlfred Perlstein 	while (vc_fd_locks[ct->ct_fd])
3368360efbdSAlfred Perlstein 		cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock);
3378360efbdSAlfred Perlstein 	if (__isthreaded)
3388360efbdSAlfred Perlstein                 rpc_lock_value = 1;
3398360efbdSAlfred Perlstein         else
3408360efbdSAlfred Perlstein                 rpc_lock_value = 0;
3418360efbdSAlfred Perlstein 	vc_fd_locks[ct->ct_fd] = rpc_lock_value;
3428360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
3438360efbdSAlfred Perlstein 	if (!ct->ct_waitset) {
3448360efbdSAlfred Perlstein 		/* If time is not within limits, we ignore it. */
3458360efbdSAlfred Perlstein 		if (time_not_ok(&timeout) == FALSE)
3468360efbdSAlfred Perlstein 			ct->ct_wait = timeout;
3478360efbdSAlfred Perlstein 	}
3488360efbdSAlfred Perlstein 
3498360efbdSAlfred Perlstein 	shipnow =
3508360efbdSAlfred Perlstein 	    (xdr_results == NULL && timeout.tv_sec == 0
3518360efbdSAlfred Perlstein 	    && timeout.tv_usec == 0) ? FALSE : TRUE;
3528360efbdSAlfred Perlstein 
3538360efbdSAlfred Perlstein call_again:
3548360efbdSAlfred Perlstein 	xdrs->x_op = XDR_ENCODE;
3558360efbdSAlfred Perlstein 	ct->ct_error.re_status = RPC_SUCCESS;
3568360efbdSAlfred Perlstein 	x_id = ntohl(--(*msg_x_id));
3578360efbdSAlfred Perlstein 
3588f55a568SDoug Rabson 	if (cl->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) {
3598360efbdSAlfred Perlstein 		if ((! XDR_PUTBYTES(xdrs, ct->ct_u.ct_mcallc, ct->ct_mpos)) ||
3608360efbdSAlfred Perlstein 		    (! XDR_PUTINT32(xdrs, &proc)) ||
3618360efbdSAlfred Perlstein 		    (! AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
3628360efbdSAlfred Perlstein 		    (! (*xdr_args)(xdrs, args_ptr))) {
3638360efbdSAlfred Perlstein 			if (ct->ct_error.re_status == RPC_SUCCESS)
3648360efbdSAlfred Perlstein 				ct->ct_error.re_status = RPC_CANTENCODEARGS;
3658360efbdSAlfred Perlstein 			(void)xdrrec_endofrecord(xdrs, TRUE);
3668360efbdSAlfred Perlstein 			release_fd_lock(ct->ct_fd, mask);
3678360efbdSAlfred Perlstein 			return (ct->ct_error.re_status);
3688360efbdSAlfred Perlstein 		}
3698f55a568SDoug Rabson 	} else {
3708f55a568SDoug Rabson 		*(uint32_t *) &ct->ct_u.ct_mcallc[ct->ct_mpos] = htonl(proc);
3718f55a568SDoug Rabson 		if (! __rpc_gss_wrap(cl->cl_auth, ct->ct_u.ct_mcallc,
3728f55a568SDoug Rabson 			ct->ct_mpos + sizeof(uint32_t),
3738f55a568SDoug Rabson 			xdrs, xdr_args, args_ptr)) {
3748f55a568SDoug Rabson 			if (ct->ct_error.re_status == RPC_SUCCESS)
3758f55a568SDoug Rabson 				ct->ct_error.re_status = RPC_CANTENCODEARGS;
3768f55a568SDoug Rabson 			(void)xdrrec_endofrecord(xdrs, TRUE);
3778f55a568SDoug Rabson 			release_fd_lock(ct->ct_fd, mask);
3788f55a568SDoug Rabson 			return (ct->ct_error.re_status);
3798f55a568SDoug Rabson 		}
3808f55a568SDoug Rabson 	}
3818360efbdSAlfred Perlstein 	if (! xdrrec_endofrecord(xdrs, shipnow)) {
3828360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
3838360efbdSAlfred Perlstein 		return (ct->ct_error.re_status = RPC_CANTSEND);
3848360efbdSAlfred Perlstein 	}
3858360efbdSAlfred Perlstein 	if (! shipnow) {
3868360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
3878360efbdSAlfred Perlstein 		return (RPC_SUCCESS);
3888360efbdSAlfred Perlstein 	}
3898360efbdSAlfred Perlstein 	/*
3908360efbdSAlfred Perlstein 	 * Hack to provide rpc-based message passing
3918360efbdSAlfred Perlstein 	 */
3928360efbdSAlfred Perlstein 	if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
3938360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
3948360efbdSAlfred Perlstein 		return(ct->ct_error.re_status = RPC_TIMEDOUT);
3958360efbdSAlfred Perlstein 	}
3968360efbdSAlfred Perlstein 
3978360efbdSAlfred Perlstein 
3988360efbdSAlfred Perlstein 	/*
3998360efbdSAlfred Perlstein 	 * Keep receiving until we get a valid transaction id
4008360efbdSAlfred Perlstein 	 */
4018360efbdSAlfred Perlstein 	xdrs->x_op = XDR_DECODE;
4028360efbdSAlfred Perlstein 	while (TRUE) {
4038360efbdSAlfred Perlstein 		reply_msg.acpted_rply.ar_verf = _null_auth;
4048360efbdSAlfred Perlstein 		reply_msg.acpted_rply.ar_results.where = NULL;
4058360efbdSAlfred Perlstein 		reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
4068360efbdSAlfred Perlstein 		if (! xdrrec_skiprecord(xdrs)) {
4078360efbdSAlfred Perlstein 			release_fd_lock(ct->ct_fd, mask);
4088360efbdSAlfred Perlstein 			return (ct->ct_error.re_status);
4098360efbdSAlfred Perlstein 		}
4108360efbdSAlfred Perlstein 		/* now decode and validate the response header */
4118360efbdSAlfred Perlstein 		if (! xdr_replymsg(xdrs, &reply_msg)) {
4128360efbdSAlfred Perlstein 			if (ct->ct_error.re_status == RPC_SUCCESS)
4138360efbdSAlfred Perlstein 				continue;
4148360efbdSAlfred Perlstein 			release_fd_lock(ct->ct_fd, mask);
4158360efbdSAlfred Perlstein 			return (ct->ct_error.re_status);
4168360efbdSAlfred Perlstein 		}
4178360efbdSAlfred Perlstein 		if (reply_msg.rm_xid == x_id)
4188360efbdSAlfred Perlstein 			break;
4198360efbdSAlfred Perlstein 	}
4208360efbdSAlfred Perlstein 
4218360efbdSAlfred Perlstein 	/*
4228360efbdSAlfred Perlstein 	 * process header
4238360efbdSAlfred Perlstein 	 */
4248360efbdSAlfred Perlstein 	_seterr_reply(&reply_msg, &(ct->ct_error));
4258360efbdSAlfred Perlstein 	if (ct->ct_error.re_status == RPC_SUCCESS) {
4268360efbdSAlfred Perlstein 		if (! AUTH_VALIDATE(cl->cl_auth,
4278360efbdSAlfred Perlstein 		    &reply_msg.acpted_rply.ar_verf)) {
4288360efbdSAlfred Perlstein 			ct->ct_error.re_status = RPC_AUTHERROR;
4298360efbdSAlfred Perlstein 			ct->ct_error.re_why = AUTH_INVALIDRESP;
4308f55a568SDoug Rabson 		} else {
4318f55a568SDoug Rabson 			if (cl->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) {
4328f55a568SDoug Rabson 				reply_stat = (*xdr_results)(xdrs, results_ptr);
4338f55a568SDoug Rabson 			} else {
4348f55a568SDoug Rabson 				reply_stat = __rpc_gss_unwrap(cl->cl_auth,
4358f55a568SDoug Rabson 				    xdrs, xdr_results, results_ptr);
4368f55a568SDoug Rabson 			}
4378f55a568SDoug Rabson 			if (! reply_stat) {
4388360efbdSAlfred Perlstein 				if (ct->ct_error.re_status == RPC_SUCCESS)
4398f55a568SDoug Rabson 					ct->ct_error.re_status =
4408f55a568SDoug Rabson 						RPC_CANTDECODERES;
4418f55a568SDoug Rabson 			}
4428360efbdSAlfred Perlstein 		}
4438360efbdSAlfred Perlstein 		/* free verifier ... */
4448360efbdSAlfred Perlstein 		if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
4458360efbdSAlfred Perlstein 			xdrs->x_op = XDR_FREE;
4468360efbdSAlfred Perlstein 			(void)xdr_opaque_auth(xdrs,
4478360efbdSAlfred Perlstein 			    &(reply_msg.acpted_rply.ar_verf));
4488360efbdSAlfred Perlstein 		}
4498360efbdSAlfred Perlstein 	}  /* end successful completion */
4508360efbdSAlfred Perlstein 	else {
4518360efbdSAlfred Perlstein 		/* maybe our credentials need to be refreshed ... */
4528360efbdSAlfred Perlstein 		if (refreshes-- && AUTH_REFRESH(cl->cl_auth, &reply_msg))
4538360efbdSAlfred Perlstein 			goto call_again;
4548360efbdSAlfred Perlstein 	}  /* end of unsuccessful completion */
4558360efbdSAlfred Perlstein 	release_fd_lock(ct->ct_fd, mask);
4568360efbdSAlfred Perlstein 	return (ct->ct_error.re_status);
4578360efbdSAlfred Perlstein }
4588360efbdSAlfred Perlstein 
4598360efbdSAlfred Perlstein static void
460587cf682SCraig Rodrigues clnt_vc_geterr(CLIENT *cl, struct rpc_err *errp)
4618360efbdSAlfred Perlstein {
4628360efbdSAlfred Perlstein 	struct ct_data *ct;
4638360efbdSAlfred Perlstein 
4648360efbdSAlfred Perlstein 	assert(cl != NULL);
4658360efbdSAlfred Perlstein 	assert(errp != NULL);
4668360efbdSAlfred Perlstein 
4678360efbdSAlfred Perlstein 	ct = (struct ct_data *) cl->cl_private;
4688360efbdSAlfred Perlstein 	*errp = ct->ct_error;
4698360efbdSAlfred Perlstein }
4708360efbdSAlfred Perlstein 
4718360efbdSAlfred Perlstein static bool_t
472587cf682SCraig Rodrigues clnt_vc_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
4738360efbdSAlfred Perlstein {
4748360efbdSAlfred Perlstein 	struct ct_data *ct;
4758360efbdSAlfred Perlstein 	XDR *xdrs;
4768360efbdSAlfred Perlstein 	bool_t dummy;
4778360efbdSAlfred Perlstein 	sigset_t mask;
4788360efbdSAlfred Perlstein 	sigset_t newmask;
4798360efbdSAlfred Perlstein 
4808360efbdSAlfred Perlstein 	assert(cl != NULL);
4818360efbdSAlfred Perlstein 
4828360efbdSAlfred Perlstein 	ct = (struct ct_data *)cl->cl_private;
4838360efbdSAlfred Perlstein 	xdrs = &(ct->ct_xdrs);
4848360efbdSAlfred Perlstein 
4858360efbdSAlfred Perlstein 	sigfillset(&newmask);
4868360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
4878360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
4888360efbdSAlfred Perlstein 	while (vc_fd_locks[ct->ct_fd])
4898360efbdSAlfred Perlstein 		cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock);
4908360efbdSAlfred Perlstein 	xdrs->x_op = XDR_FREE;
4918360efbdSAlfred Perlstein 	dummy = (*xdr_res)(xdrs, res_ptr);
4928360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
4938360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
4948360efbdSAlfred Perlstein 	cond_signal(&vc_cv[ct->ct_fd]);
4958360efbdSAlfred Perlstein 
4968360efbdSAlfred Perlstein 	return dummy;
4978360efbdSAlfred Perlstein }
4988360efbdSAlfred Perlstein 
4998360efbdSAlfred Perlstein /*ARGSUSED*/
5008360efbdSAlfred Perlstein static void
501587cf682SCraig Rodrigues clnt_vc_abort(CLIENT *cl)
5028360efbdSAlfred Perlstein {
5038360efbdSAlfred Perlstein }
5048360efbdSAlfred Perlstein 
505ef2c4faeSPedro F. Giffuni static __inline void
506ef2c4faeSPedro F. Giffuni htonlp(void *dst, const void *src, uint32_t incr)
507ef2c4faeSPedro F. Giffuni {
508ef2c4faeSPedro F. Giffuni 	/* We are aligned, so we think */
509ef2c4faeSPedro F. Giffuni 	*(uint32_t *)dst = htonl(*(const uint32_t *)src + incr);
510ef2c4faeSPedro F. Giffuni }
511ef2c4faeSPedro F. Giffuni 
512ef2c4faeSPedro F. Giffuni static __inline void
513ef2c4faeSPedro F. Giffuni ntohlp(void *dst, const void *src)
514ef2c4faeSPedro F. Giffuni {
515ef2c4faeSPedro F. Giffuni 	/* We are aligned, so we think */
516ef2c4faeSPedro F. Giffuni 	*(uint32_t *)dst = htonl(*(const uint32_t *)src);
517ef2c4faeSPedro F. Giffuni }
518ef2c4faeSPedro F. Giffuni 
5198360efbdSAlfred Perlstein static bool_t
520587cf682SCraig Rodrigues clnt_vc_control(CLIENT *cl, u_int request, void *info)
5218360efbdSAlfred Perlstein {
5228360efbdSAlfred Perlstein 	struct ct_data *ct;
5238360efbdSAlfred Perlstein 	void *infop = info;
5248360efbdSAlfred Perlstein 	sigset_t mask;
5258360efbdSAlfred Perlstein 	sigset_t newmask;
5268360efbdSAlfred Perlstein 	int rpc_lock_value;
5278360efbdSAlfred Perlstein 
5288360efbdSAlfred Perlstein 	assert(cl != NULL);
5298360efbdSAlfred Perlstein 
5308360efbdSAlfred Perlstein 	ct = (struct ct_data *)cl->cl_private;
5318360efbdSAlfred Perlstein 
5328360efbdSAlfred Perlstein 	sigfillset(&newmask);
5338360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
5348360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
5358360efbdSAlfred Perlstein 	while (vc_fd_locks[ct->ct_fd])
5368360efbdSAlfred Perlstein 		cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock);
5378360efbdSAlfred Perlstein 	if (__isthreaded)
5388360efbdSAlfred Perlstein                 rpc_lock_value = 1;
5398360efbdSAlfred Perlstein         else
5408360efbdSAlfred Perlstein                 rpc_lock_value = 0;
5418360efbdSAlfred Perlstein 	vc_fd_locks[ct->ct_fd] = rpc_lock_value;
5428360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
5438360efbdSAlfred Perlstein 
5448360efbdSAlfred Perlstein 	switch (request) {
5458360efbdSAlfred Perlstein 	case CLSET_FD_CLOSE:
5468360efbdSAlfred Perlstein 		ct->ct_closeit = TRUE;
5478360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
5488360efbdSAlfred Perlstein 		return (TRUE);
5498360efbdSAlfred Perlstein 	case CLSET_FD_NCLOSE:
5508360efbdSAlfred Perlstein 		ct->ct_closeit = FALSE;
5518360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
5528360efbdSAlfred Perlstein 		return (TRUE);
5538360efbdSAlfred Perlstein 	default:
5548360efbdSAlfred Perlstein 		break;
5558360efbdSAlfred Perlstein 	}
5568360efbdSAlfred Perlstein 
5578360efbdSAlfred Perlstein 	/* for other requests which use info */
5588360efbdSAlfred Perlstein 	if (info == NULL) {
5598360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
5608360efbdSAlfred Perlstein 		return (FALSE);
5618360efbdSAlfred Perlstein 	}
5628360efbdSAlfred Perlstein 	switch (request) {
5638360efbdSAlfred Perlstein 	case CLSET_TIMEOUT:
564cffc0b57SAlfred Perlstein 		if (time_not_ok((struct timeval *)info)) {
5658360efbdSAlfred Perlstein 			release_fd_lock(ct->ct_fd, mask);
5668360efbdSAlfred Perlstein 			return (FALSE);
5678360efbdSAlfred Perlstein 		}
5688360efbdSAlfred Perlstein 		ct->ct_wait = *(struct timeval *)infop;
5698360efbdSAlfred Perlstein 		ct->ct_waitset = TRUE;
5708360efbdSAlfred Perlstein 		break;
5718360efbdSAlfred Perlstein 	case CLGET_TIMEOUT:
5728360efbdSAlfred Perlstein 		*(struct timeval *)infop = ct->ct_wait;
5738360efbdSAlfred Perlstein 		break;
5748360efbdSAlfred Perlstein 	case CLGET_SERVER_ADDR:
5758360efbdSAlfred Perlstein 		(void) memcpy(info, ct->ct_addr.buf, (size_t)ct->ct_addr.len);
5768360efbdSAlfred Perlstein 		break;
5778360efbdSAlfred Perlstein 	case CLGET_FD:
578cffc0b57SAlfred Perlstein 		*(int *)info = ct->ct_fd;
5798360efbdSAlfred Perlstein 		break;
5808360efbdSAlfred Perlstein 	case CLGET_SVC_ADDR:
5818360efbdSAlfred Perlstein 		/* The caller should not free this memory area */
582cffc0b57SAlfred Perlstein 		*(struct netbuf *)info = ct->ct_addr;
5838360efbdSAlfred Perlstein 		break;
5848360efbdSAlfred Perlstein 	case CLSET_SVC_ADDR:		/* set to new address */
5858360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
5868360efbdSAlfred Perlstein 		return (FALSE);
5878360efbdSAlfred Perlstein 	case CLGET_XID:
5888360efbdSAlfred Perlstein 		/*
5898360efbdSAlfred Perlstein 		 * use the knowledge that xid is the
5908360efbdSAlfred Perlstein 		 * first element in the call structure
5918360efbdSAlfred Perlstein 		 * This will get the xid of the PREVIOUS call
5928360efbdSAlfred Perlstein 		 */
593ef2c4faeSPedro F. Giffuni 		ntohlp(info, &ct->ct_u.ct_mcalli);
5948360efbdSAlfred Perlstein 		break;
5958360efbdSAlfred Perlstein 	case CLSET_XID:
5968360efbdSAlfred Perlstein 		/* This will set the xid of the NEXT call */
5978360efbdSAlfred Perlstein 		/* increment by 1 as clnt_vc_call() decrements once */
598ef2c4faeSPedro F. Giffuni 		htonlp(&ct->ct_u.ct_mcalli, info, 1);
5998360efbdSAlfred Perlstein 		break;
6008360efbdSAlfred Perlstein 	case CLGET_VERS:
6018360efbdSAlfred Perlstein 		/*
6028360efbdSAlfred Perlstein 		 * This RELIES on the information that, in the call body,
6038360efbdSAlfred Perlstein 		 * the version number field is the fifth field from the
604*32223c1bSPedro F. Giffuni 		 * beginning of the RPC header. MUST be changed if the
6058360efbdSAlfred Perlstein 		 * call_struct is changed
6068360efbdSAlfred Perlstein 		 */
607ef2c4faeSPedro F. Giffuni 		ntohlp(info, ct->ct_u.ct_mcallc + 4 * BYTES_PER_XDR_UNIT);
6088360efbdSAlfred Perlstein 		break;
6098360efbdSAlfred Perlstein 
6108360efbdSAlfred Perlstein 	case CLSET_VERS:
611ef2c4faeSPedro F. Giffuni 		htonlp(ct->ct_u.ct_mcallc + 4 * BYTES_PER_XDR_UNIT, info, 0);
6128360efbdSAlfred Perlstein 		break;
6138360efbdSAlfred Perlstein 
6148360efbdSAlfred Perlstein 	case CLGET_PROG:
6158360efbdSAlfred Perlstein 		/*
6168360efbdSAlfred Perlstein 		 * This RELIES on the information that, in the call body,
6178360efbdSAlfred Perlstein 		 * the program number field is the fourth field from the
618*32223c1bSPedro F. Giffuni 		 * beginning of the RPC header. MUST be changed if the
6198360efbdSAlfred Perlstein 		 * call_struct is changed
6208360efbdSAlfred Perlstein 		 */
621ef2c4faeSPedro F. Giffuni 		ntohlp(info, ct->ct_u.ct_mcallc + 3 * BYTES_PER_XDR_UNIT);
6228360efbdSAlfred Perlstein 		break;
6238360efbdSAlfred Perlstein 
6248360efbdSAlfred Perlstein 	case CLSET_PROG:
625ef2c4faeSPedro F. Giffuni 		htonlp(ct->ct_u.ct_mcallc + 3 * BYTES_PER_XDR_UNIT, info, 0);
6268360efbdSAlfred Perlstein 		break;
6278360efbdSAlfred Perlstein 
6288360efbdSAlfred Perlstein 	default:
6298360efbdSAlfred Perlstein 		release_fd_lock(ct->ct_fd, mask);
6308360efbdSAlfred Perlstein 		return (FALSE);
6318360efbdSAlfred Perlstein 	}
6328360efbdSAlfred Perlstein 	release_fd_lock(ct->ct_fd, mask);
6338360efbdSAlfred Perlstein 	return (TRUE);
6348360efbdSAlfred Perlstein }
6358360efbdSAlfred Perlstein 
6368360efbdSAlfred Perlstein 
6378360efbdSAlfred Perlstein static void
638587cf682SCraig Rodrigues clnt_vc_destroy(CLIENT *cl)
6398360efbdSAlfred Perlstein {
6408360efbdSAlfred Perlstein 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
6418360efbdSAlfred Perlstein 	int ct_fd = ct->ct_fd;
6428360efbdSAlfred Perlstein 	sigset_t mask;
6438360efbdSAlfred Perlstein 	sigset_t newmask;
6448360efbdSAlfred Perlstein 
6458360efbdSAlfred Perlstein 	assert(cl != NULL);
6468360efbdSAlfred Perlstein 
6478360efbdSAlfred Perlstein 	ct = (struct ct_data *) cl->cl_private;
6488360efbdSAlfred Perlstein 
6498360efbdSAlfred Perlstein 	sigfillset(&newmask);
6508360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
6518360efbdSAlfred Perlstein 	mutex_lock(&clnt_fd_lock);
6528360efbdSAlfred Perlstein 	while (vc_fd_locks[ct_fd])
6538360efbdSAlfred Perlstein 		cond_wait(&vc_cv[ct_fd], &clnt_fd_lock);
6548360efbdSAlfred Perlstein 	if (ct->ct_closeit && ct->ct_fd != -1) {
6558360efbdSAlfred Perlstein 		(void)_close(ct->ct_fd);
6568360efbdSAlfred Perlstein 	}
6578360efbdSAlfred Perlstein 	XDR_DESTROY(&(ct->ct_xdrs));
6588360efbdSAlfred Perlstein 	free(ct->ct_addr.buf);
6598360efbdSAlfred Perlstein 	mem_free(ct, sizeof(struct ct_data));
6600c2222baSPedro F. Giffuni 	if (cl->cl_netid && cl->cl_netid[0])
6610c2222baSPedro F. Giffuni 		mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
6620c2222baSPedro F. Giffuni 	if (cl->cl_tp && cl->cl_tp[0])
6630c2222baSPedro F. Giffuni 		mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
6648360efbdSAlfred Perlstein 	mem_free(cl, sizeof(CLIENT));
6658360efbdSAlfred Perlstein 	mutex_unlock(&clnt_fd_lock);
6668360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
6678360efbdSAlfred Perlstein 	cond_signal(&vc_cv[ct_fd]);
6688360efbdSAlfred Perlstein }
6698360efbdSAlfred Perlstein 
6708360efbdSAlfred Perlstein /*
6718360efbdSAlfred Perlstein  * Interface between xdr serializer and tcp connection.
6728360efbdSAlfred Perlstein  * Behaves like the system calls, read & write, but keeps some error state
6738360efbdSAlfred Perlstein  * around for the rpc level.
6748360efbdSAlfred Perlstein  */
6758360efbdSAlfred Perlstein static int
676587cf682SCraig Rodrigues read_vc(void *ctp, void *buf, int len)
6778360efbdSAlfred Perlstein {
6788360efbdSAlfred Perlstein 	struct sockaddr sa;
6798360efbdSAlfred Perlstein 	socklen_t sal;
680f249dbccSDag-Erling Smørgrav 	struct ct_data *ct = (struct ct_data *)ctp;
6818360efbdSAlfred Perlstein 	struct pollfd fd;
6828360efbdSAlfred Perlstein 	int milliseconds = (int)((ct->ct_wait.tv_sec * 1000) +
6838360efbdSAlfred Perlstein 	    (ct->ct_wait.tv_usec / 1000));
6848360efbdSAlfred Perlstein 
6858360efbdSAlfred Perlstein 	if (len == 0)
6868360efbdSAlfred Perlstein 		return (0);
6878360efbdSAlfred Perlstein 	fd.fd = ct->ct_fd;
6888360efbdSAlfred Perlstein 	fd.events = POLLIN;
6898360efbdSAlfred Perlstein 	for (;;) {
6908360efbdSAlfred Perlstein 		switch (_poll(&fd, 1, milliseconds)) {
6918360efbdSAlfred Perlstein 		case 0:
6928360efbdSAlfred Perlstein 			ct->ct_error.re_status = RPC_TIMEDOUT;
6938360efbdSAlfred Perlstein 			return (-1);
6948360efbdSAlfred Perlstein 
6958360efbdSAlfred Perlstein 		case -1:
6968360efbdSAlfred Perlstein 			if (errno == EINTR)
6978360efbdSAlfred Perlstein 				continue;
6988360efbdSAlfred Perlstein 			ct->ct_error.re_status = RPC_CANTRECV;
6998360efbdSAlfred Perlstein 			ct->ct_error.re_errno = errno;
7008360efbdSAlfred Perlstein 			return (-1);
7018360efbdSAlfred Perlstein 		}
7028360efbdSAlfred Perlstein 		break;
7038360efbdSAlfred Perlstein 	}
7048360efbdSAlfred Perlstein 
7058360efbdSAlfred Perlstein 	sal = sizeof(sa);
7068360efbdSAlfred Perlstein 	if ((_getpeername(ct->ct_fd, &sa, &sal) == 0) &&
7078360efbdSAlfred Perlstein 	    (sa.sa_family == AF_LOCAL)) {
7088360efbdSAlfred Perlstein 		len = __msgread(ct->ct_fd, buf, (size_t)len);
7098360efbdSAlfred Perlstein 	} else {
7108360efbdSAlfred Perlstein 		len = _read(ct->ct_fd, buf, (size_t)len);
7118360efbdSAlfred Perlstein 	}
7128360efbdSAlfred Perlstein 
7138360efbdSAlfred Perlstein 	switch (len) {
7148360efbdSAlfred Perlstein 	case 0:
7158360efbdSAlfred Perlstein 		/* premature eof */
7168360efbdSAlfred Perlstein 		ct->ct_error.re_errno = ECONNRESET;
7178360efbdSAlfred Perlstein 		ct->ct_error.re_status = RPC_CANTRECV;
7188360efbdSAlfred Perlstein 		len = -1;  /* it's really an error */
7198360efbdSAlfred Perlstein 		break;
7208360efbdSAlfred Perlstein 
7218360efbdSAlfred Perlstein 	case -1:
7228360efbdSAlfred Perlstein 		ct->ct_error.re_errno = errno;
7238360efbdSAlfred Perlstein 		ct->ct_error.re_status = RPC_CANTRECV;
7248360efbdSAlfred Perlstein 		break;
7258360efbdSAlfred Perlstein 	}
7268360efbdSAlfred Perlstein 	return (len);
7278360efbdSAlfred Perlstein }
7288360efbdSAlfred Perlstein 
7298360efbdSAlfred Perlstein static int
730587cf682SCraig Rodrigues write_vc(void *ctp, void *buf, int len)
7318360efbdSAlfred Perlstein {
7328360efbdSAlfred Perlstein 	struct sockaddr sa;
7338360efbdSAlfred Perlstein 	socklen_t sal;
734f249dbccSDag-Erling Smørgrav 	struct ct_data *ct = (struct ct_data *)ctp;
7358360efbdSAlfred Perlstein 	int i, cnt;
7368360efbdSAlfred Perlstein 
7378360efbdSAlfred Perlstein 	sal = sizeof(sa);
7388360efbdSAlfred Perlstein 	if ((_getpeername(ct->ct_fd, &sa, &sal) == 0) &&
7398360efbdSAlfred Perlstein 	    (sa.sa_family == AF_LOCAL)) {
7401f7d62b3SStefan Farfeleder 		for (cnt = len; cnt > 0; cnt -= i, buf = (char *)buf + i) {
7418360efbdSAlfred Perlstein 			if ((i = __msgwrite(ct->ct_fd, buf,
7428360efbdSAlfred Perlstein 			     (size_t)cnt)) == -1) {
7438360efbdSAlfred Perlstein 				ct->ct_error.re_errno = errno;
7448360efbdSAlfred Perlstein 				ct->ct_error.re_status = RPC_CANTSEND;
7458360efbdSAlfred Perlstein 				return (-1);
7468360efbdSAlfred Perlstein 			}
7478360efbdSAlfred Perlstein 		}
7488360efbdSAlfred Perlstein 	} else {
749361de173SStefan Farfeleder 		for (cnt = len; cnt > 0; cnt -= i, buf = (char *)buf + i) {
7508360efbdSAlfred Perlstein 			if ((i = _write(ct->ct_fd, buf, (size_t)cnt)) == -1) {
7518360efbdSAlfred Perlstein 				ct->ct_error.re_errno = errno;
7528360efbdSAlfred Perlstein 				ct->ct_error.re_status = RPC_CANTSEND;
7538360efbdSAlfred Perlstein 				return (-1);
7548360efbdSAlfred Perlstein 			}
7558360efbdSAlfred Perlstein 		}
7568360efbdSAlfred Perlstein 	}
7578360efbdSAlfred Perlstein 	return (len);
7588360efbdSAlfred Perlstein }
7598360efbdSAlfred Perlstein 
7608360efbdSAlfred Perlstein static struct clnt_ops *
761587cf682SCraig Rodrigues clnt_vc_ops(void)
7628360efbdSAlfred Perlstein {
7638360efbdSAlfred Perlstein 	static struct clnt_ops ops;
7648360efbdSAlfred Perlstein 	sigset_t mask, newmask;
7658360efbdSAlfred Perlstein 
7668360efbdSAlfred Perlstein 	/* VARIABLES PROTECTED BY ops_lock: ops */
7678360efbdSAlfred Perlstein 
7688360efbdSAlfred Perlstein 	sigfillset(&newmask);
7698360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
7708360efbdSAlfred Perlstein 	mutex_lock(&ops_lock);
7718360efbdSAlfred Perlstein 	if (ops.cl_call == NULL) {
7728360efbdSAlfred Perlstein 		ops.cl_call = clnt_vc_call;
7738360efbdSAlfred Perlstein 		ops.cl_abort = clnt_vc_abort;
7748360efbdSAlfred Perlstein 		ops.cl_geterr = clnt_vc_geterr;
7758360efbdSAlfred Perlstein 		ops.cl_freeres = clnt_vc_freeres;
7768360efbdSAlfred Perlstein 		ops.cl_destroy = clnt_vc_destroy;
7778360efbdSAlfred Perlstein 		ops.cl_control = clnt_vc_control;
7788360efbdSAlfred Perlstein 	}
7798360efbdSAlfred Perlstein 	mutex_unlock(&ops_lock);
7808360efbdSAlfred Perlstein 	thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
7818360efbdSAlfred Perlstein 	return (&ops);
7828360efbdSAlfred Perlstein }
7838360efbdSAlfred Perlstein 
7848360efbdSAlfred Perlstein /*
7858360efbdSAlfred Perlstein  * Make sure that the time is not garbage.   -1 value is disallowed.
7868360efbdSAlfred Perlstein  * Note this is different from time_not_ok in clnt_dg.c
7878360efbdSAlfred Perlstein  */
7888360efbdSAlfred Perlstein static bool_t
789587cf682SCraig Rodrigues time_not_ok(struct timeval *t)
7908360efbdSAlfred Perlstein {
7918360efbdSAlfred Perlstein 	return (t->tv_sec <= -1 || t->tv_sec > 100000000 ||
7928360efbdSAlfred Perlstein 		t->tv_usec <= -1 || t->tv_usec > 1000000);
7938360efbdSAlfred Perlstein }
7948360efbdSAlfred Perlstein 
7954ed6d634SAlfred Perlstein static int
796587cf682SCraig Rodrigues __msgread(int sock, void *buf, size_t cnt)
7978360efbdSAlfred Perlstein {
7988360efbdSAlfred Perlstein 	struct iovec iov[1];
7998360efbdSAlfred Perlstein 	struct msghdr msg;
8002bc21ed9SDavid Malone 	union {
8012bc21ed9SDavid Malone 		struct cmsghdr cmsg;
8022bc21ed9SDavid Malone 		char control[CMSG_SPACE(sizeof(struct cmsgcred))];
8032bc21ed9SDavid Malone 	} cm;
8048360efbdSAlfred Perlstein 
8058360efbdSAlfred Perlstein 	bzero((char *)&cm, sizeof(cm));
8068360efbdSAlfred Perlstein 	iov[0].iov_base = buf;
8078360efbdSAlfred Perlstein 	iov[0].iov_len = cnt;
8088360efbdSAlfred Perlstein 
8098360efbdSAlfred Perlstein 	msg.msg_iov = iov;
8108360efbdSAlfred Perlstein 	msg.msg_iovlen = 1;
8118360efbdSAlfred Perlstein 	msg.msg_name = NULL;
8128360efbdSAlfred Perlstein 	msg.msg_namelen = 0;
8138360efbdSAlfred Perlstein 	msg.msg_control = (caddr_t)&cm;
8142bc21ed9SDavid Malone 	msg.msg_controllen = CMSG_SPACE(sizeof(struct cmsgcred));
8158360efbdSAlfred Perlstein 	msg.msg_flags = 0;
8168360efbdSAlfred Perlstein 
8178360efbdSAlfred Perlstein 	return(_recvmsg(sock, &msg, 0));
8188360efbdSAlfred Perlstein }
8198360efbdSAlfred Perlstein 
8208360efbdSAlfred Perlstein static int
821587cf682SCraig Rodrigues __msgwrite(int sock, void *buf, size_t cnt)
8228360efbdSAlfred Perlstein {
8238360efbdSAlfred Perlstein 	struct iovec iov[1];
8248360efbdSAlfred Perlstein 	struct msghdr msg;
8252bc21ed9SDavid Malone 	union {
8262bc21ed9SDavid Malone 		struct cmsghdr cmsg;
8272bc21ed9SDavid Malone 		char control[CMSG_SPACE(sizeof(struct cmsgcred))];
8282bc21ed9SDavid Malone 	} cm;
8298360efbdSAlfred Perlstein 
8308360efbdSAlfred Perlstein 	bzero((char *)&cm, sizeof(cm));
8318360efbdSAlfred Perlstein 	iov[0].iov_base = buf;
8328360efbdSAlfred Perlstein 	iov[0].iov_len = cnt;
8338360efbdSAlfred Perlstein 
8348360efbdSAlfred Perlstein 	cm.cmsg.cmsg_type = SCM_CREDS;
8358360efbdSAlfred Perlstein 	cm.cmsg.cmsg_level = SOL_SOCKET;
8362bc21ed9SDavid Malone 	cm.cmsg.cmsg_len = CMSG_LEN(sizeof(struct cmsgcred));
8378360efbdSAlfred Perlstein 
8388360efbdSAlfred Perlstein 	msg.msg_iov = iov;
8398360efbdSAlfred Perlstein 	msg.msg_iovlen = 1;
8408360efbdSAlfred Perlstein 	msg.msg_name = NULL;
8418360efbdSAlfred Perlstein 	msg.msg_namelen = 0;
8428360efbdSAlfred Perlstein 	msg.msg_control = (caddr_t)&cm;
8432bc21ed9SDavid Malone 	msg.msg_controllen = CMSG_SPACE(sizeof(struct cmsgcred));
8448360efbdSAlfred Perlstein 	msg.msg_flags = 0;
8458360efbdSAlfred Perlstein 
8468360efbdSAlfred Perlstein 	return(_sendmsg(sock, &msg, 0));
8478360efbdSAlfred Perlstein }
848