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