18360efbdSAlfred Perlstein /* $NetBSD: clnt_dg.c,v 1.4 2000/07/14 08:40:41 fvdl Exp $ */ 28360efbdSAlfred Perlstein /* $FreeBSD$ */ 38360efbdSAlfred Perlstein 48360efbdSAlfred Perlstein /* 58360efbdSAlfred Perlstein * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 68360efbdSAlfred Perlstein * unrestricted use provided that this legend is included on all tape 78360efbdSAlfred Perlstein * media and as a part of the software program in whole or part. Users 88360efbdSAlfred Perlstein * may copy or modify Sun RPC without charge, but are not authorized 98360efbdSAlfred Perlstein * to license or distribute it to anyone else except as part of a product or 108360efbdSAlfred Perlstein * program developed by the user. 118360efbdSAlfred Perlstein * 128360efbdSAlfred Perlstein * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 138360efbdSAlfred Perlstein * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 148360efbdSAlfred Perlstein * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 158360efbdSAlfred Perlstein * 168360efbdSAlfred Perlstein * Sun RPC is provided with no support and without any obligation on the 178360efbdSAlfred Perlstein * part of Sun Microsystems, Inc. to assist in its use, correction, 188360efbdSAlfred Perlstein * modification or enhancement. 198360efbdSAlfred Perlstein * 208360efbdSAlfred Perlstein * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 218360efbdSAlfred Perlstein * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 228360efbdSAlfred Perlstein * OR ANY PART THEREOF. 238360efbdSAlfred Perlstein * 248360efbdSAlfred Perlstein * In no event will Sun Microsystems, Inc. be liable for any lost revenue 258360efbdSAlfred Perlstein * or profits or other special, indirect and consequential damages, even if 268360efbdSAlfred Perlstein * Sun has been advised of the possibility of such damages. 278360efbdSAlfred Perlstein * 288360efbdSAlfred Perlstein * Sun Microsystems, Inc. 298360efbdSAlfred Perlstein * 2550 Garcia Avenue 308360efbdSAlfred Perlstein * Mountain View, California 94043 318360efbdSAlfred Perlstein */ 328360efbdSAlfred Perlstein /* 338360efbdSAlfred Perlstein * Copyright (c) 1986-1991 by Sun Microsystems Inc. 348360efbdSAlfred Perlstein */ 358360efbdSAlfred Perlstein 368360efbdSAlfred Perlstein /* #ident "@(#)clnt_dg.c 1.23 94/04/22 SMI" */ 378360efbdSAlfred Perlstein 388360efbdSAlfred Perlstein #if 0 398360efbdSAlfred Perlstein #if !defined(lint) && defined(SCCSIDS) 408360efbdSAlfred Perlstein static char sccsid[] = "@(#)clnt_dg.c 1.19 89/03/16 Copyr 1988 Sun Micro"; 418360efbdSAlfred Perlstein #endif 428360efbdSAlfred Perlstein #endif 438360efbdSAlfred Perlstein 448360efbdSAlfred Perlstein /* 458360efbdSAlfred Perlstein * Implements a connectionless client side RPC. 468360efbdSAlfred Perlstein */ 478360efbdSAlfred Perlstein 488360efbdSAlfred Perlstein #include "reentrant.h" 498360efbdSAlfred Perlstein #include "namespace.h" 508360efbdSAlfred Perlstein #include <sys/poll.h> 518360efbdSAlfred Perlstein #include <sys/types.h> 528360efbdSAlfred Perlstein #include <sys/time.h> 538360efbdSAlfred Perlstein #include <sys/socket.h> 548360efbdSAlfred Perlstein #include <sys/ioctl.h> 558360efbdSAlfred Perlstein #include <rpc/rpc.h> 568360efbdSAlfred Perlstein #include <errno.h> 578360efbdSAlfred Perlstein #include <stdlib.h> 588360efbdSAlfred Perlstein #include <string.h> 598360efbdSAlfred Perlstein #include <signal.h> 608360efbdSAlfred Perlstein #include <unistd.h> 618360efbdSAlfred Perlstein #include <err.h> 628360efbdSAlfred Perlstein #include "un-namespace.h" 638360efbdSAlfred Perlstein #include "rpc_com.h" 648360efbdSAlfred Perlstein 658360efbdSAlfred Perlstein 668360efbdSAlfred Perlstein #define RPC_MAX_BACKOFF 30 /* seconds */ 678360efbdSAlfred Perlstein 688360efbdSAlfred Perlstein 698360efbdSAlfred Perlstein static struct clnt_ops *clnt_dg_ops __P((void)); 708360efbdSAlfred Perlstein static bool_t time_not_ok __P((struct timeval *)); 718360efbdSAlfred Perlstein static enum clnt_stat clnt_dg_call __P((CLIENT *, rpcproc_t, xdrproc_t, caddr_t, 728360efbdSAlfred Perlstein xdrproc_t, caddr_t, struct timeval)); 738360efbdSAlfred Perlstein static void clnt_dg_geterr __P((CLIENT *, struct rpc_err *)); 748360efbdSAlfred Perlstein static bool_t clnt_dg_freeres __P((CLIENT *, xdrproc_t, caddr_t)); 758360efbdSAlfred Perlstein static void clnt_dg_abort __P((CLIENT *)); 768360efbdSAlfred Perlstein static bool_t clnt_dg_control __P((CLIENT *, u_int, char *)); 778360efbdSAlfred Perlstein static void clnt_dg_destroy __P((CLIENT *)); 788360efbdSAlfred Perlstein static int __rpc_timeval_to_msec __P((struct timeval *)); 798360efbdSAlfred Perlstein 808360efbdSAlfred Perlstein 818360efbdSAlfred Perlstein 828360efbdSAlfred Perlstein 838360efbdSAlfred Perlstein /* 848360efbdSAlfred Perlstein * This machinery implements per-fd locks for MT-safety. It is not 858360efbdSAlfred Perlstein * sufficient to do per-CLIENT handle locks for MT-safety because a 868360efbdSAlfred Perlstein * user may create more than one CLIENT handle with the same fd behind 878360efbdSAlfred Perlstein * it. Therfore, we allocate an array of flags (dg_fd_locks), protected 888360efbdSAlfred Perlstein * by the clnt_fd_lock mutex, and an array (dg_cv) of condition variables 898360efbdSAlfred Perlstein * similarly protected. Dg_fd_lock[fd] == 1 => a call is activte on some 908360efbdSAlfred Perlstein * CLIENT handle created for that fd. 918360efbdSAlfred Perlstein * The current implementation holds locks across the entire RPC and reply, 928360efbdSAlfred Perlstein * including retransmissions. Yes, this is silly, and as soon as this 938360efbdSAlfred Perlstein * code is proven to work, this should be the first thing fixed. One step 948360efbdSAlfred Perlstein * at a time. 958360efbdSAlfred Perlstein */ 968360efbdSAlfred Perlstein static int *dg_fd_locks; 978360efbdSAlfred Perlstein extern mutex_t clnt_fd_lock; 988360efbdSAlfred Perlstein static cond_t *dg_cv; 998360efbdSAlfred Perlstein #define release_fd_lock(fd, mask) { \ 1008360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); \ 1018360efbdSAlfred Perlstein if (__isthreaded) \ 1028360efbdSAlfred Perlstein dg_fd_locks[fd] = 0; \ 1038360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); \ 1048360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &(mask), (sigset_t *) NULL); \ 1058360efbdSAlfred Perlstein cond_signal(&dg_cv[fd]); \ 1068360efbdSAlfred Perlstein } 1078360efbdSAlfred Perlstein 1088360efbdSAlfred Perlstein static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory"; 1098360efbdSAlfred Perlstein 1108360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY clnt_fd_lock: dg_fd_locks, dg_cv */ 1118360efbdSAlfred Perlstein 1128360efbdSAlfred Perlstein /* 1138360efbdSAlfred Perlstein * Private data kept per client handle 1148360efbdSAlfred Perlstein */ 1158360efbdSAlfred Perlstein struct cu_data { 1168360efbdSAlfred Perlstein int cu_fd; /* connections fd */ 1178360efbdSAlfred Perlstein bool_t cu_closeit; /* opened by library */ 1188360efbdSAlfred Perlstein struct sockaddr_storage cu_raddr; /* remote address */ 1198360efbdSAlfred Perlstein int cu_rlen; 1208360efbdSAlfred Perlstein struct timeval cu_wait; /* retransmit interval */ 1218360efbdSAlfred Perlstein struct timeval cu_total; /* total time for the call */ 1228360efbdSAlfred Perlstein struct rpc_err cu_error; 1238360efbdSAlfred Perlstein XDR cu_outxdrs; 1248360efbdSAlfred Perlstein u_int cu_xdrpos; 1258360efbdSAlfred Perlstein u_int cu_sendsz; /* send size */ 1268360efbdSAlfred Perlstein char *cu_outbuf; 1278360efbdSAlfred Perlstein u_int cu_recvsz; /* recv size */ 1288360efbdSAlfred Perlstein struct pollfd pfdp; 12965d3c627SBill Paul int cu_async; 1308360efbdSAlfred Perlstein char cu_inbuf[1]; 1318360efbdSAlfred Perlstein }; 1328360efbdSAlfred Perlstein 1338360efbdSAlfred Perlstein /* 1348360efbdSAlfred Perlstein * Connection less client creation returns with client handle parameters. 1358360efbdSAlfred Perlstein * Default options are set, which the user can change using clnt_control(). 1368360efbdSAlfred Perlstein * fd should be open and bound. 1378360efbdSAlfred Perlstein * NB: The rpch->cl_auth is initialized to null authentication. 1388360efbdSAlfred Perlstein * Caller may wish to set this something more useful. 1398360efbdSAlfred Perlstein * 1408360efbdSAlfred Perlstein * sendsz and recvsz are the maximum allowable packet sizes that can be 1418360efbdSAlfred Perlstein * sent and received. Normally they are the same, but they can be 1428360efbdSAlfred Perlstein * changed to improve the program efficiency and buffer allocation. 1438360efbdSAlfred Perlstein * If they are 0, use the transport default. 1448360efbdSAlfred Perlstein * 1458360efbdSAlfred Perlstein * If svcaddr is NULL, returns NULL. 1468360efbdSAlfred Perlstein */ 1478360efbdSAlfred Perlstein CLIENT * 1488360efbdSAlfred Perlstein clnt_dg_create(fd, svcaddr, program, version, sendsz, recvsz) 1498360efbdSAlfred Perlstein int fd; /* open file descriptor */ 1508360efbdSAlfred Perlstein const struct netbuf *svcaddr; /* servers address */ 1518360efbdSAlfred Perlstein rpcprog_t program; /* program number */ 1528360efbdSAlfred Perlstein rpcvers_t version; /* version number */ 1538360efbdSAlfred Perlstein u_int sendsz; /* buffer recv size */ 1548360efbdSAlfred Perlstein u_int recvsz; /* buffer send size */ 1558360efbdSAlfred Perlstein { 1568360efbdSAlfred Perlstein CLIENT *cl = NULL; /* client handle */ 1578360efbdSAlfred Perlstein struct cu_data *cu = NULL; /* private data */ 1588360efbdSAlfred Perlstein struct timeval now; 1598360efbdSAlfred Perlstein struct rpc_msg call_msg; 1608360efbdSAlfred Perlstein sigset_t mask; 1618360efbdSAlfred Perlstein sigset_t newmask; 1628360efbdSAlfred Perlstein struct __rpc_sockinfo si; 1638360efbdSAlfred Perlstein int one = 1; 1648360efbdSAlfred Perlstein 1658360efbdSAlfred Perlstein sigfillset(&newmask); 1668360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 1678360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 1688360efbdSAlfred Perlstein if (dg_fd_locks == (int *) NULL) { 1698360efbdSAlfred Perlstein int cv_allocsz; 1708360efbdSAlfred Perlstein size_t fd_allocsz; 1718360efbdSAlfred Perlstein int dtbsize = __rpc_dtbsize(); 1728360efbdSAlfred Perlstein 1738360efbdSAlfred Perlstein fd_allocsz = dtbsize * sizeof (int); 1748360efbdSAlfred Perlstein dg_fd_locks = (int *) mem_alloc(fd_allocsz); 1758360efbdSAlfred Perlstein if (dg_fd_locks == (int *) NULL) { 1768360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 1778360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 1788360efbdSAlfred Perlstein goto err1; 1798360efbdSAlfred Perlstein } else 1808360efbdSAlfred Perlstein memset(dg_fd_locks, '\0', fd_allocsz); 1818360efbdSAlfred Perlstein 1828360efbdSAlfred Perlstein cv_allocsz = dtbsize * sizeof (cond_t); 1838360efbdSAlfred Perlstein dg_cv = (cond_t *) mem_alloc(cv_allocsz); 1848360efbdSAlfred Perlstein if (dg_cv == (cond_t *) NULL) { 1858360efbdSAlfred Perlstein mem_free(dg_fd_locks, fd_allocsz); 1868360efbdSAlfred Perlstein dg_fd_locks = (int *) NULL; 1878360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 1888360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 1898360efbdSAlfred Perlstein goto err1; 1908360efbdSAlfred Perlstein } else { 1918360efbdSAlfred Perlstein int i; 1928360efbdSAlfred Perlstein 1938360efbdSAlfred Perlstein for (i = 0; i < dtbsize; i++) 1948360efbdSAlfred Perlstein cond_init(&dg_cv[i], 0, (void *) 0); 1958360efbdSAlfred Perlstein } 1968360efbdSAlfred Perlstein } 1978360efbdSAlfred Perlstein 1988360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 1998360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 2008360efbdSAlfred Perlstein 2018360efbdSAlfred Perlstein if (svcaddr == NULL) { 2028360efbdSAlfred Perlstein rpc_createerr.cf_stat = RPC_UNKNOWNADDR; 2038360efbdSAlfred Perlstein return (NULL); 2048360efbdSAlfred Perlstein } 2058360efbdSAlfred Perlstein 2068360efbdSAlfred Perlstein if (!__rpc_fd2sockinfo(fd, &si)) { 2078360efbdSAlfred Perlstein rpc_createerr.cf_stat = RPC_TLIERROR; 2088360efbdSAlfred Perlstein rpc_createerr.cf_error.re_errno = 0; 2098360efbdSAlfred Perlstein return (NULL); 2108360efbdSAlfred Perlstein } 2118360efbdSAlfred Perlstein /* 2128360efbdSAlfred Perlstein * Find the receive and the send size 2138360efbdSAlfred Perlstein */ 2148360efbdSAlfred Perlstein sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz); 2158360efbdSAlfred Perlstein recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz); 2168360efbdSAlfred Perlstein if ((sendsz == 0) || (recvsz == 0)) { 2178360efbdSAlfred Perlstein rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */ 2188360efbdSAlfred Perlstein rpc_createerr.cf_error.re_errno = 0; 2198360efbdSAlfred Perlstein return (NULL); 2208360efbdSAlfred Perlstein } 2218360efbdSAlfred Perlstein 2228360efbdSAlfred Perlstein if ((cl = mem_alloc(sizeof (CLIENT))) == NULL) 2238360efbdSAlfred Perlstein goto err1; 2248360efbdSAlfred Perlstein /* 2258360efbdSAlfred Perlstein * Should be multiple of 4 for XDR. 2268360efbdSAlfred Perlstein */ 2278360efbdSAlfred Perlstein sendsz = ((sendsz + 3) / 4) * 4; 2288360efbdSAlfred Perlstein recvsz = ((recvsz + 3) / 4) * 4; 2298360efbdSAlfred Perlstein cu = mem_alloc(sizeof (*cu) + sendsz + recvsz); 2308360efbdSAlfred Perlstein if (cu == NULL) 2318360efbdSAlfred Perlstein goto err1; 2328360efbdSAlfred Perlstein (void) memcpy(&cu->cu_raddr, svcaddr->buf, (size_t)svcaddr->len); 2338360efbdSAlfred Perlstein cu->cu_rlen = svcaddr->len; 2348360efbdSAlfred Perlstein cu->cu_outbuf = &cu->cu_inbuf[recvsz]; 2358360efbdSAlfred Perlstein /* Other values can also be set through clnt_control() */ 2368360efbdSAlfred Perlstein cu->cu_wait.tv_sec = 15; /* heuristically chosen */ 2378360efbdSAlfred Perlstein cu->cu_wait.tv_usec = 0; 2388360efbdSAlfred Perlstein cu->cu_total.tv_sec = -1; 2398360efbdSAlfred Perlstein cu->cu_total.tv_usec = -1; 2408360efbdSAlfred Perlstein cu->cu_sendsz = sendsz; 2418360efbdSAlfred Perlstein cu->cu_recvsz = recvsz; 24265d3c627SBill Paul cu->cu_async = FALSE; 2438360efbdSAlfred Perlstein (void) gettimeofday(&now, NULL); 2448360efbdSAlfred Perlstein call_msg.rm_xid = __RPC_GETXID(&now); 2458360efbdSAlfred Perlstein call_msg.rm_call.cb_prog = program; 2468360efbdSAlfred Perlstein call_msg.rm_call.cb_vers = version; 2478360efbdSAlfred Perlstein xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE); 2488360efbdSAlfred Perlstein if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) { 2498360efbdSAlfred Perlstein rpc_createerr.cf_stat = RPC_CANTENCODEARGS; /* XXX */ 2508360efbdSAlfred Perlstein rpc_createerr.cf_error.re_errno = 0; 2518360efbdSAlfred Perlstein goto err2; 2528360efbdSAlfred Perlstein } 2538360efbdSAlfred Perlstein cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs)); 2548360efbdSAlfred Perlstein 2558360efbdSAlfred Perlstein /* XXX fvdl - do we still want this? */ 2568360efbdSAlfred Perlstein #if 0 2578360efbdSAlfred Perlstein (void)bindresvport_sa(fd, (struct sockaddr *)svcaddr->buf); 2588360efbdSAlfred Perlstein #endif 2598360efbdSAlfred Perlstein _ioctl(fd, FIONBIO, (char *)(void *)&one); 2608360efbdSAlfred Perlstein 2618360efbdSAlfred Perlstein /* 2628360efbdSAlfred Perlstein * By default, closeit is always FALSE. It is users responsibility 2638360efbdSAlfred Perlstein * to do a close on it, else the user may use clnt_control 2648360efbdSAlfred Perlstein * to let clnt_destroy do it for him/her. 2658360efbdSAlfred Perlstein */ 2668360efbdSAlfred Perlstein cu->cu_closeit = FALSE; 2678360efbdSAlfred Perlstein cu->cu_fd = fd; 2688360efbdSAlfred Perlstein cl->cl_ops = clnt_dg_ops(); 2698360efbdSAlfred Perlstein cl->cl_private = (caddr_t)(void *)cu; 2708360efbdSAlfred Perlstein cl->cl_auth = authnone_create(); 2718360efbdSAlfred Perlstein cl->cl_tp = NULL; 2728360efbdSAlfred Perlstein cl->cl_netid = NULL; 2738360efbdSAlfred Perlstein cu->pfdp.fd = cu->cu_fd; 2748360efbdSAlfred Perlstein cu->pfdp.events = POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND; 2758360efbdSAlfred Perlstein return (cl); 2768360efbdSAlfred Perlstein err1: 2778360efbdSAlfred Perlstein warnx(mem_err_clnt_dg); 2788360efbdSAlfred Perlstein rpc_createerr.cf_stat = RPC_SYSTEMERROR; 2798360efbdSAlfred Perlstein rpc_createerr.cf_error.re_errno = errno; 2808360efbdSAlfred Perlstein err2: 2818360efbdSAlfred Perlstein if (cl) { 2828360efbdSAlfred Perlstein mem_free(cl, sizeof (CLIENT)); 2838360efbdSAlfred Perlstein if (cu) 2848360efbdSAlfred Perlstein mem_free(cu, sizeof (*cu) + sendsz + recvsz); 2858360efbdSAlfred Perlstein } 2868360efbdSAlfred Perlstein return (NULL); 2878360efbdSAlfred Perlstein } 2888360efbdSAlfred Perlstein 2898360efbdSAlfred Perlstein static enum clnt_stat 2908360efbdSAlfred Perlstein clnt_dg_call(cl, proc, xargs, argsp, xresults, resultsp, utimeout) 2918360efbdSAlfred Perlstein CLIENT *cl; /* client handle */ 2928360efbdSAlfred Perlstein rpcproc_t proc; /* procedure number */ 2938360efbdSAlfred Perlstein xdrproc_t xargs; /* xdr routine for args */ 2948360efbdSAlfred Perlstein caddr_t argsp; /* pointer to args */ 2958360efbdSAlfred Perlstein xdrproc_t xresults; /* xdr routine for results */ 2968360efbdSAlfred Perlstein caddr_t resultsp; /* pointer to results */ 2978360efbdSAlfred Perlstein struct timeval utimeout; /* seconds to wait before giving up */ 2988360efbdSAlfred Perlstein { 2998360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 3008360efbdSAlfred Perlstein XDR *xdrs; 3018360efbdSAlfred Perlstein size_t outlen; 3028360efbdSAlfred Perlstein struct rpc_msg reply_msg; 3038360efbdSAlfred Perlstein XDR reply_xdrs; 3048360efbdSAlfred Perlstein struct timeval time_waited; 3058360efbdSAlfred Perlstein bool_t ok; 3068360efbdSAlfred Perlstein int nrefreshes = 2; /* number of times to refresh cred */ 3078360efbdSAlfred Perlstein struct timeval timeout; 3088360efbdSAlfred Perlstein struct timeval retransmit_time; 3098360efbdSAlfred Perlstein struct timeval startime, curtime; 3108360efbdSAlfred Perlstein int firsttimeout = 1; 3118360efbdSAlfred Perlstein int dtbsize = __rpc_dtbsize(); 3128360efbdSAlfred Perlstein sigset_t mask; 3138360efbdSAlfred Perlstein sigset_t newmask; 3148360efbdSAlfred Perlstein socklen_t fromlen, inlen; 3158360efbdSAlfred Perlstein ssize_t recvlen = 0; 3168360efbdSAlfred Perlstein int rpc_lock_value; 31765d3c627SBill Paul u_int32_t xid; 3188360efbdSAlfred Perlstein 3198360efbdSAlfred Perlstein sigfillset(&newmask); 3208360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 3218360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 3228360efbdSAlfred Perlstein while (dg_fd_locks[cu->cu_fd]) 3238360efbdSAlfred Perlstein cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 3248360efbdSAlfred Perlstein if (__isthreaded) 3258360efbdSAlfred Perlstein rpc_lock_value = 1; 3268360efbdSAlfred Perlstein else 3278360efbdSAlfred Perlstein rpc_lock_value = 0; 3288360efbdSAlfred Perlstein dg_fd_locks[cu->cu_fd] = rpc_lock_value; 3298360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 3308360efbdSAlfred Perlstein if (cu->cu_total.tv_usec == -1) { 3318360efbdSAlfred Perlstein timeout = utimeout; /* use supplied timeout */ 3328360efbdSAlfred Perlstein } else { 3338360efbdSAlfred Perlstein timeout = cu->cu_total; /* use default timeout */ 3348360efbdSAlfred Perlstein } 3358360efbdSAlfred Perlstein 3368360efbdSAlfred Perlstein time_waited.tv_sec = 0; 3378360efbdSAlfred Perlstein time_waited.tv_usec = 0; 3388360efbdSAlfred Perlstein retransmit_time = cu->cu_wait; 3398360efbdSAlfred Perlstein 3408360efbdSAlfred Perlstein call_again: 3418360efbdSAlfred Perlstein xdrs = &(cu->cu_outxdrs); 34265d3c627SBill Paul if (cu->cu_async == TRUE && xargs == NULL) 34365d3c627SBill Paul goto get_reply; 3448360efbdSAlfred Perlstein xdrs->x_op = XDR_ENCODE; 3458360efbdSAlfred Perlstein XDR_SETPOS(xdrs, cu->cu_xdrpos); 3468360efbdSAlfred Perlstein /* 3478360efbdSAlfred Perlstein * the transaction is the first thing in the out buffer 34865d3c627SBill Paul * XXX Yes, and it's in network byte order, so we should to 34965d3c627SBill Paul * be careful when we increment it, shouldn't we. 3508360efbdSAlfred Perlstein */ 35165d3c627SBill Paul xid = ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf)); 35265d3c627SBill Paul xid++; 35365d3c627SBill Paul *(u_int32_t *)(void *)(cu->cu_outbuf) = htonl(xid); 35465d3c627SBill Paul 3558360efbdSAlfred Perlstein if ((! XDR_PUTINT32(xdrs, &proc)) || 3568360efbdSAlfred Perlstein (! AUTH_MARSHALL(cl->cl_auth, xdrs)) || 3578360efbdSAlfred Perlstein (! (*xargs)(xdrs, argsp))) { 3588360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 3598360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_CANTENCODEARGS); 3608360efbdSAlfred Perlstein } 3618360efbdSAlfred Perlstein outlen = (size_t)XDR_GETPOS(xdrs); 3628360efbdSAlfred Perlstein 3638360efbdSAlfred Perlstein send_again: 3648360efbdSAlfred Perlstein if (_sendto(cu->cu_fd, cu->cu_outbuf, outlen, 0, 3658360efbdSAlfred Perlstein (struct sockaddr *)(void *)&cu->cu_raddr, (socklen_t)cu->cu_rlen) 3668360efbdSAlfred Perlstein != outlen) { 3678360efbdSAlfred Perlstein cu->cu_error.re_errno = errno; 3688360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 3698360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_CANTSEND); 3708360efbdSAlfred Perlstein } 3718360efbdSAlfred Perlstein 3728360efbdSAlfred Perlstein /* 3738360efbdSAlfred Perlstein * Hack to provide rpc-based message passing 3748360efbdSAlfred Perlstein */ 3758360efbdSAlfred Perlstein if (timeout.tv_sec == 0 && timeout.tv_usec == 0) { 3768360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 3778360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_TIMEDOUT); 3788360efbdSAlfred Perlstein } 37965d3c627SBill Paul 38065d3c627SBill Paul get_reply: 38165d3c627SBill Paul 3828360efbdSAlfred Perlstein /* 3838360efbdSAlfred Perlstein * sub-optimal code appears here because we have 3848360efbdSAlfred Perlstein * some clock time to spare while the packets are in flight. 3858360efbdSAlfred Perlstein * (We assume that this is actually only executed once.) 3868360efbdSAlfred Perlstein */ 3878360efbdSAlfred Perlstein reply_msg.acpted_rply.ar_verf = _null_auth; 3888360efbdSAlfred Perlstein reply_msg.acpted_rply.ar_results.where = resultsp; 3898360efbdSAlfred Perlstein reply_msg.acpted_rply.ar_results.proc = xresults; 3908360efbdSAlfred Perlstein 3918360efbdSAlfred Perlstein 3928360efbdSAlfred Perlstein for (;;) { 3938360efbdSAlfred Perlstein switch (_poll(&cu->pfdp, 1, 3948360efbdSAlfred Perlstein __rpc_timeval_to_msec(&retransmit_time))) { 3958360efbdSAlfred Perlstein case 0: 3968360efbdSAlfred Perlstein time_waited.tv_sec += retransmit_time.tv_sec; 3978360efbdSAlfred Perlstein time_waited.tv_usec += retransmit_time.tv_usec; 3988360efbdSAlfred Perlstein while (time_waited.tv_usec >= 1000000) { 3998360efbdSAlfred Perlstein time_waited.tv_sec++; 4008360efbdSAlfred Perlstein time_waited.tv_usec -= 1000000; 4018360efbdSAlfred Perlstein } 4028360efbdSAlfred Perlstein /* update retransmit_time */ 4038360efbdSAlfred Perlstein if (retransmit_time.tv_sec < RPC_MAX_BACKOFF) { 4048360efbdSAlfred Perlstein retransmit_time.tv_usec *= 2; 4058360efbdSAlfred Perlstein retransmit_time.tv_sec *= 2; 4068360efbdSAlfred Perlstein while (retransmit_time.tv_usec >= 1000000) { 4078360efbdSAlfred Perlstein retransmit_time.tv_sec++; 4088360efbdSAlfred Perlstein retransmit_time.tv_usec -= 1000000; 4098360efbdSAlfred Perlstein } 4108360efbdSAlfred Perlstein } 4118360efbdSAlfred Perlstein 4128360efbdSAlfred Perlstein if ((time_waited.tv_sec < timeout.tv_sec) || 4138360efbdSAlfred Perlstein ((time_waited.tv_sec == timeout.tv_sec) && 4148360efbdSAlfred Perlstein (time_waited.tv_usec < timeout.tv_usec))) 4158360efbdSAlfred Perlstein goto send_again; 4168360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 4178360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_TIMEDOUT); 4188360efbdSAlfred Perlstein 4198360efbdSAlfred Perlstein case -1: 4208360efbdSAlfred Perlstein if (errno == EBADF) { 4218360efbdSAlfred Perlstein cu->cu_error.re_errno = errno; 4228360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 4238360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_CANTRECV); 4248360efbdSAlfred Perlstein } 4258360efbdSAlfred Perlstein if (errno != EINTR) { 4268360efbdSAlfred Perlstein errno = 0; /* reset it */ 4278360efbdSAlfred Perlstein continue; 4288360efbdSAlfred Perlstein } 4298360efbdSAlfred Perlstein /* interrupted by another signal, update time_waited */ 4308360efbdSAlfred Perlstein if (firsttimeout) { 4318360efbdSAlfred Perlstein /* 4328360efbdSAlfred Perlstein * Could have done gettimeofday before clnt_call 4338360efbdSAlfred Perlstein * but that means 1 more system call per each 4348360efbdSAlfred Perlstein * clnt_call, so do it after first time out 4358360efbdSAlfred Perlstein */ 4368360efbdSAlfred Perlstein if (gettimeofday(&startime, 4378360efbdSAlfred Perlstein (struct timezone *) NULL) == -1) { 4388360efbdSAlfred Perlstein errno = 0; 4398360efbdSAlfred Perlstein continue; 4408360efbdSAlfred Perlstein } 4418360efbdSAlfred Perlstein firsttimeout = 0; 4428360efbdSAlfred Perlstein errno = 0; 4438360efbdSAlfred Perlstein continue; 4448360efbdSAlfred Perlstein }; 4458360efbdSAlfred Perlstein if (gettimeofday(&curtime, 4468360efbdSAlfred Perlstein (struct timezone *) NULL) == -1) { 4478360efbdSAlfred Perlstein errno = 0; 4488360efbdSAlfred Perlstein continue; 4498360efbdSAlfred Perlstein }; 4508360efbdSAlfred Perlstein time_waited.tv_sec += curtime.tv_sec - startime.tv_sec; 4518360efbdSAlfred Perlstein time_waited.tv_usec += curtime.tv_usec - 4528360efbdSAlfred Perlstein startime.tv_usec; 4538360efbdSAlfred Perlstein while (time_waited.tv_usec < 0) { 4548360efbdSAlfred Perlstein time_waited.tv_sec--; 4558360efbdSAlfred Perlstein time_waited.tv_usec += 1000000; 4568360efbdSAlfred Perlstein }; 4578360efbdSAlfred Perlstein while (time_waited.tv_usec >= 1000000) { 4588360efbdSAlfred Perlstein time_waited.tv_sec++; 4598360efbdSAlfred Perlstein time_waited.tv_usec -= 1000000; 4608360efbdSAlfred Perlstein } 4618360efbdSAlfred Perlstein startime.tv_sec = curtime.tv_sec; 4628360efbdSAlfred Perlstein startime.tv_usec = curtime.tv_usec; 4638360efbdSAlfred Perlstein if ((time_waited.tv_sec > timeout.tv_sec) || 4648360efbdSAlfred Perlstein ((time_waited.tv_sec == timeout.tv_sec) && 4658360efbdSAlfred Perlstein (time_waited.tv_usec > timeout.tv_usec))) { 4668360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 4678360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_TIMEDOUT); 4688360efbdSAlfred Perlstein } 4698360efbdSAlfred Perlstein errno = 0; /* reset it */ 4708360efbdSAlfred Perlstein continue; 4718360efbdSAlfred Perlstein }; 4728360efbdSAlfred Perlstein 4738360efbdSAlfred Perlstein if (cu->pfdp.revents & POLLNVAL || (cu->pfdp.revents == 0)) { 4748360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_CANTRECV; 4758360efbdSAlfred Perlstein /* 4768360efbdSAlfred Perlstein * Note: we're faking errno here because we 4778360efbdSAlfred Perlstein * previously would have expected _poll() to 4788360efbdSAlfred Perlstein * return -1 with errno EBADF. Poll(BA_OS) 4798360efbdSAlfred Perlstein * returns 0 and sets the POLLNVAL revents flag 4808360efbdSAlfred Perlstein * instead. 4818360efbdSAlfred Perlstein */ 4828360efbdSAlfred Perlstein cu->cu_error.re_errno = errno = EBADF; 4838360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 4848360efbdSAlfred Perlstein return (-1); 4858360efbdSAlfred Perlstein } 4868360efbdSAlfred Perlstein 4878360efbdSAlfred Perlstein /* We have some data now */ 4888360efbdSAlfred Perlstein do { 4898360efbdSAlfred Perlstein if (errno == EINTR) { 4908360efbdSAlfred Perlstein /* 4918360efbdSAlfred Perlstein * Must make sure errno was not already 4928360efbdSAlfred Perlstein * EINTR in case _recvfrom() returns -1. 4938360efbdSAlfred Perlstein */ 4948360efbdSAlfred Perlstein errno = 0; 4958360efbdSAlfred Perlstein } 4968360efbdSAlfred Perlstein fromlen = sizeof (struct sockaddr_storage); 4978360efbdSAlfred Perlstein recvlen = _recvfrom(cu->cu_fd, cu->cu_inbuf, 4988360efbdSAlfred Perlstein cu->cu_recvsz, 0, (struct sockaddr *)(void *)&cu->cu_raddr, 4998360efbdSAlfred Perlstein &fromlen); 5008360efbdSAlfred Perlstein } while (recvlen < 0 && errno == EINTR); 5018360efbdSAlfred Perlstein if (recvlen < 0) { 5028360efbdSAlfred Perlstein if (errno == EWOULDBLOCK) 5038360efbdSAlfred Perlstein continue; 5048360efbdSAlfred Perlstein cu->cu_error.re_errno = errno; 5058360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 5068360efbdSAlfred Perlstein return (cu->cu_error.re_status = RPC_CANTRECV); 5078360efbdSAlfred Perlstein } 5088360efbdSAlfred Perlstein if (recvlen < sizeof (u_int32_t)) 5098360efbdSAlfred Perlstein continue; 5108360efbdSAlfred Perlstein /* see if reply transaction id matches sent id */ 51165d3c627SBill Paul if (cu->cu_async == FALSE && 51265d3c627SBill Paul *((u_int32_t *)(void *)(cu->cu_inbuf)) != 5138360efbdSAlfred Perlstein *((u_int32_t *)(void *)(cu->cu_outbuf))) 5148360efbdSAlfred Perlstein continue; 5158360efbdSAlfred Perlstein /* we now assume we have the proper reply */ 5168360efbdSAlfred Perlstein break; 5178360efbdSAlfred Perlstein } 5188360efbdSAlfred Perlstein inlen = (socklen_t)recvlen; 5198360efbdSAlfred Perlstein 5208360efbdSAlfred Perlstein /* 5218360efbdSAlfred Perlstein * now decode and validate the response 5228360efbdSAlfred Perlstein */ 5238360efbdSAlfred Perlstein 5248360efbdSAlfred Perlstein xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE); 5258360efbdSAlfred Perlstein ok = xdr_replymsg(&reply_xdrs, &reply_msg); 5268360efbdSAlfred Perlstein /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */ 5278360efbdSAlfred Perlstein if (ok) { 5288360efbdSAlfred Perlstein if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) && 5298360efbdSAlfred Perlstein (reply_msg.acpted_rply.ar_stat == SUCCESS)) 5308360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_SUCCESS; 5318360efbdSAlfred Perlstein else 5328360efbdSAlfred Perlstein _seterr_reply(&reply_msg, &(cu->cu_error)); 5338360efbdSAlfred Perlstein 5348360efbdSAlfred Perlstein if (cu->cu_error.re_status == RPC_SUCCESS) { 5358360efbdSAlfred Perlstein if (! AUTH_VALIDATE(cl->cl_auth, 5368360efbdSAlfred Perlstein &reply_msg.acpted_rply.ar_verf)) { 5378360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_AUTHERROR; 5388360efbdSAlfred Perlstein cu->cu_error.re_why = AUTH_INVALIDRESP; 5398360efbdSAlfred Perlstein } 5408360efbdSAlfred Perlstein if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) { 5418360efbdSAlfred Perlstein xdrs->x_op = XDR_FREE; 5428360efbdSAlfred Perlstein (void) xdr_opaque_auth(xdrs, 5438360efbdSAlfred Perlstein &(reply_msg.acpted_rply.ar_verf)); 5448360efbdSAlfred Perlstein } 5458360efbdSAlfred Perlstein } /* end successful completion */ 5468360efbdSAlfred Perlstein /* 5478360efbdSAlfred Perlstein * If unsuccesful AND error is an authentication error 5488360efbdSAlfred Perlstein * then refresh credentials and try again, else break 5498360efbdSAlfred Perlstein */ 5508360efbdSAlfred Perlstein else if (cu->cu_error.re_status == RPC_AUTHERROR) 5518360efbdSAlfred Perlstein /* maybe our credentials need to be refreshed ... */ 5528360efbdSAlfred Perlstein if (nrefreshes > 0 && 5538360efbdSAlfred Perlstein AUTH_REFRESH(cl->cl_auth, &reply_msg)) { 5548360efbdSAlfred Perlstein nrefreshes--; 5558360efbdSAlfred Perlstein goto call_again; 5568360efbdSAlfred Perlstein } 5578360efbdSAlfred Perlstein /* end of unsuccessful completion */ 5588360efbdSAlfred Perlstein } /* end of valid reply message */ 5598360efbdSAlfred Perlstein else { 5608360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_CANTDECODERES; 5618360efbdSAlfred Perlstein 5628360efbdSAlfred Perlstein } 5638360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 5648360efbdSAlfred Perlstein return (cu->cu_error.re_status); 5658360efbdSAlfred Perlstein } 5668360efbdSAlfred Perlstein 5678360efbdSAlfred Perlstein static void 5688360efbdSAlfred Perlstein clnt_dg_geterr(cl, errp) 5698360efbdSAlfred Perlstein CLIENT *cl; 5708360efbdSAlfred Perlstein struct rpc_err *errp; 5718360efbdSAlfred Perlstein { 5728360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 5738360efbdSAlfred Perlstein 5748360efbdSAlfred Perlstein *errp = cu->cu_error; 5758360efbdSAlfred Perlstein } 5768360efbdSAlfred Perlstein 5778360efbdSAlfred Perlstein static bool_t 5788360efbdSAlfred Perlstein clnt_dg_freeres(cl, xdr_res, res_ptr) 5798360efbdSAlfred Perlstein CLIENT *cl; 5808360efbdSAlfred Perlstein xdrproc_t xdr_res; 5818360efbdSAlfred Perlstein caddr_t res_ptr; 5828360efbdSAlfred Perlstein { 5838360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 5848360efbdSAlfred Perlstein XDR *xdrs = &(cu->cu_outxdrs); 5858360efbdSAlfred Perlstein bool_t dummy; 5868360efbdSAlfred Perlstein sigset_t mask; 5878360efbdSAlfred Perlstein sigset_t newmask; 5888360efbdSAlfred Perlstein 5898360efbdSAlfred Perlstein sigfillset(&newmask); 5908360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 5918360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 5928360efbdSAlfred Perlstein while (dg_fd_locks[cu->cu_fd]) 5938360efbdSAlfred Perlstein cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 5948360efbdSAlfred Perlstein xdrs->x_op = XDR_FREE; 5958360efbdSAlfred Perlstein dummy = (*xdr_res)(xdrs, res_ptr); 5968360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 5978360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &mask, NULL); 5988360efbdSAlfred Perlstein cond_signal(&dg_cv[cu->cu_fd]); 5998360efbdSAlfred Perlstein return (dummy); 6008360efbdSAlfred Perlstein } 6018360efbdSAlfred Perlstein 6028360efbdSAlfred Perlstein /*ARGSUSED*/ 6038360efbdSAlfred Perlstein static void 6048360efbdSAlfred Perlstein clnt_dg_abort(h) 6058360efbdSAlfred Perlstein CLIENT *h; 6068360efbdSAlfred Perlstein { 6078360efbdSAlfred Perlstein } 6088360efbdSAlfred Perlstein 6098360efbdSAlfred Perlstein static bool_t 6108360efbdSAlfred Perlstein clnt_dg_control(cl, request, info) 6118360efbdSAlfred Perlstein CLIENT *cl; 6128360efbdSAlfred Perlstein u_int request; 6138360efbdSAlfred Perlstein char *info; 6148360efbdSAlfred Perlstein { 6158360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 6168360efbdSAlfred Perlstein struct netbuf *addr; 6178360efbdSAlfred Perlstein sigset_t mask; 6188360efbdSAlfred Perlstein sigset_t newmask; 6198360efbdSAlfred Perlstein int rpc_lock_value; 6208360efbdSAlfred Perlstein 6218360efbdSAlfred Perlstein sigfillset(&newmask); 6228360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 6238360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 6248360efbdSAlfred Perlstein while (dg_fd_locks[cu->cu_fd]) 6258360efbdSAlfred Perlstein cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 6268360efbdSAlfred Perlstein if (__isthreaded) 6278360efbdSAlfred Perlstein rpc_lock_value = 1; 6288360efbdSAlfred Perlstein else 6298360efbdSAlfred Perlstein rpc_lock_value = 0; 6308360efbdSAlfred Perlstein dg_fd_locks[cu->cu_fd] = rpc_lock_value; 6318360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 6328360efbdSAlfred Perlstein switch (request) { 6338360efbdSAlfred Perlstein case CLSET_FD_CLOSE: 6348360efbdSAlfred Perlstein cu->cu_closeit = TRUE; 6358360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6368360efbdSAlfred Perlstein return (TRUE); 6378360efbdSAlfred Perlstein case CLSET_FD_NCLOSE: 6388360efbdSAlfred Perlstein cu->cu_closeit = FALSE; 6398360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6408360efbdSAlfred Perlstein return (TRUE); 6418360efbdSAlfred Perlstein } 6428360efbdSAlfred Perlstein 6438360efbdSAlfred Perlstein /* for other requests which use info */ 6448360efbdSAlfred Perlstein if (info == NULL) { 6458360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6468360efbdSAlfred Perlstein return (FALSE); 6478360efbdSAlfred Perlstein } 6488360efbdSAlfred Perlstein switch (request) { 6498360efbdSAlfred Perlstein case CLSET_TIMEOUT: 6508360efbdSAlfred Perlstein if (time_not_ok((struct timeval *)(void *)info)) { 6518360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6528360efbdSAlfred Perlstein return (FALSE); 6538360efbdSAlfred Perlstein } 6548360efbdSAlfred Perlstein cu->cu_total = *(struct timeval *)(void *)info; 6558360efbdSAlfred Perlstein break; 6568360efbdSAlfred Perlstein case CLGET_TIMEOUT: 6578360efbdSAlfred Perlstein *(struct timeval *)(void *)info = cu->cu_total; 6588360efbdSAlfred Perlstein break; 6598360efbdSAlfred Perlstein case CLGET_SERVER_ADDR: /* Give him the fd address */ 6608360efbdSAlfred Perlstein /* Now obsolete. Only for backward compatibility */ 6618360efbdSAlfred Perlstein (void) memcpy(info, &cu->cu_raddr, (size_t)cu->cu_rlen); 6628360efbdSAlfred Perlstein break; 6638360efbdSAlfred Perlstein case CLSET_RETRY_TIMEOUT: 6648360efbdSAlfred Perlstein if (time_not_ok((struct timeval *)(void *)info)) { 6658360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6668360efbdSAlfred Perlstein return (FALSE); 6678360efbdSAlfred Perlstein } 6688360efbdSAlfred Perlstein cu->cu_wait = *(struct timeval *)(void *)info; 6698360efbdSAlfred Perlstein break; 6708360efbdSAlfred Perlstein case CLGET_RETRY_TIMEOUT: 6718360efbdSAlfred Perlstein *(struct timeval *)(void *)info = cu->cu_wait; 6728360efbdSAlfred Perlstein break; 6738360efbdSAlfred Perlstein case CLGET_FD: 6748360efbdSAlfred Perlstein *(int *)(void *)info = cu->cu_fd; 6758360efbdSAlfred Perlstein break; 6768360efbdSAlfred Perlstein case CLGET_SVC_ADDR: 6778360efbdSAlfred Perlstein addr = (struct netbuf *)(void *)info; 6788360efbdSAlfred Perlstein addr->buf = &cu->cu_raddr; 6798360efbdSAlfred Perlstein addr->len = cu->cu_rlen; 6808360efbdSAlfred Perlstein addr->maxlen = sizeof cu->cu_raddr; 6818360efbdSAlfred Perlstein break; 6828360efbdSAlfred Perlstein case CLSET_SVC_ADDR: /* set to new address */ 6838360efbdSAlfred Perlstein addr = (struct netbuf *)(void *)info; 6848360efbdSAlfred Perlstein if (addr->len < sizeof cu->cu_raddr) 6858360efbdSAlfred Perlstein return (FALSE); 6868360efbdSAlfred Perlstein (void) memcpy(&cu->cu_raddr, addr->buf, addr->len); 6878360efbdSAlfred Perlstein cu->cu_rlen = addr->len; 6888360efbdSAlfred Perlstein break; 6898360efbdSAlfred Perlstein case CLGET_XID: 6908360efbdSAlfred Perlstein /* 6918360efbdSAlfred Perlstein * use the knowledge that xid is the 6928360efbdSAlfred Perlstein * first element in the call structure *. 6938360efbdSAlfred Perlstein * This will get the xid of the PREVIOUS call 6948360efbdSAlfred Perlstein */ 6958360efbdSAlfred Perlstein *(u_int32_t *)(void *)info = 6968360efbdSAlfred Perlstein ntohl(*(u_int32_t *)(void *)cu->cu_outbuf); 6978360efbdSAlfred Perlstein break; 6988360efbdSAlfred Perlstein 6998360efbdSAlfred Perlstein case CLSET_XID: 7008360efbdSAlfred Perlstein /* This will set the xid of the NEXT call */ 7018360efbdSAlfred Perlstein *(u_int32_t *)(void *)cu->cu_outbuf = 7028360efbdSAlfred Perlstein htonl(*(u_int32_t *)(void *)info - 1); 7038360efbdSAlfred Perlstein /* decrement by 1 as clnt_dg_call() increments once */ 7048360efbdSAlfred Perlstein break; 7058360efbdSAlfred Perlstein 7068360efbdSAlfred Perlstein case CLGET_VERS: 7078360efbdSAlfred Perlstein /* 7088360efbdSAlfred Perlstein * This RELIES on the information that, in the call body, 7098360efbdSAlfred Perlstein * the version number field is the fifth field from the 7108360efbdSAlfred Perlstein * begining of the RPC header. MUST be changed if the 7118360efbdSAlfred Perlstein * call_struct is changed 7128360efbdSAlfred Perlstein */ 7138360efbdSAlfred Perlstein *(u_int32_t *)(void *)info = 7148360efbdSAlfred Perlstein ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf + 7158360efbdSAlfred Perlstein 4 * BYTES_PER_XDR_UNIT)); 7168360efbdSAlfred Perlstein break; 7178360efbdSAlfred Perlstein 7188360efbdSAlfred Perlstein case CLSET_VERS: 7198360efbdSAlfred Perlstein *(u_int32_t *)(void *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT) 7208360efbdSAlfred Perlstein = htonl(*(u_int32_t *)(void *)info); 7218360efbdSAlfred Perlstein break; 7228360efbdSAlfred Perlstein 7238360efbdSAlfred Perlstein case CLGET_PROG: 7248360efbdSAlfred Perlstein /* 7258360efbdSAlfred Perlstein * This RELIES on the information that, in the call body, 7268360efbdSAlfred Perlstein * the program number field is the fourth field from the 7278360efbdSAlfred Perlstein * begining of the RPC header. MUST be changed if the 7288360efbdSAlfred Perlstein * call_struct is changed 7298360efbdSAlfred Perlstein */ 7308360efbdSAlfred Perlstein *(u_int32_t *)(void *)info = 7318360efbdSAlfred Perlstein ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf + 7328360efbdSAlfred Perlstein 3 * BYTES_PER_XDR_UNIT)); 7338360efbdSAlfred Perlstein break; 7348360efbdSAlfred Perlstein 7358360efbdSAlfred Perlstein case CLSET_PROG: 7368360efbdSAlfred Perlstein *(u_int32_t *)(void *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT) 7378360efbdSAlfred Perlstein = htonl(*(u_int32_t *)(void *)info); 7388360efbdSAlfred Perlstein break; 73965d3c627SBill Paul case CLSET_ASYNC: 74065d3c627SBill Paul cu->cu_async = *(int *)(void *)info; 74165d3c627SBill Paul break; 7428360efbdSAlfred Perlstein default: 7438360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 7448360efbdSAlfred Perlstein return (FALSE); 7458360efbdSAlfred Perlstein } 7468360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 7478360efbdSAlfred Perlstein return (TRUE); 7488360efbdSAlfred Perlstein } 7498360efbdSAlfred Perlstein 7508360efbdSAlfred Perlstein static void 7518360efbdSAlfred Perlstein clnt_dg_destroy(cl) 7528360efbdSAlfred Perlstein CLIENT *cl; 7538360efbdSAlfred Perlstein { 7548360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 7558360efbdSAlfred Perlstein int cu_fd = cu->cu_fd; 7568360efbdSAlfred Perlstein sigset_t mask; 7578360efbdSAlfred Perlstein sigset_t newmask; 7588360efbdSAlfred Perlstein 7598360efbdSAlfred Perlstein sigfillset(&newmask); 7608360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 7618360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 7628360efbdSAlfred Perlstein while (dg_fd_locks[cu_fd]) 7638360efbdSAlfred Perlstein cond_wait(&dg_cv[cu_fd], &clnt_fd_lock); 7648360efbdSAlfred Perlstein if (cu->cu_closeit) 7658360efbdSAlfred Perlstein (void)_close(cu_fd); 7668360efbdSAlfred Perlstein XDR_DESTROY(&(cu->cu_outxdrs)); 7678360efbdSAlfred Perlstein mem_free(cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz)); 7688360efbdSAlfred Perlstein if (cl->cl_netid && cl->cl_netid[0]) 7698360efbdSAlfred Perlstein mem_free(cl->cl_netid, strlen(cl->cl_netid) +1); 7708360efbdSAlfred Perlstein if (cl->cl_tp && cl->cl_tp[0]) 7718360efbdSAlfred Perlstein mem_free(cl->cl_tp, strlen(cl->cl_tp) +1); 7728360efbdSAlfred Perlstein mem_free(cl, sizeof (CLIENT)); 7738360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 7748360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &mask, NULL); 7758360efbdSAlfred Perlstein cond_signal(&dg_cv[cu_fd]); 7768360efbdSAlfred Perlstein } 7778360efbdSAlfred Perlstein 7788360efbdSAlfred Perlstein static struct clnt_ops * 7798360efbdSAlfred Perlstein clnt_dg_ops() 7808360efbdSAlfred Perlstein { 7818360efbdSAlfred Perlstein static struct clnt_ops ops; 7828360efbdSAlfred Perlstein extern mutex_t ops_lock; 7838360efbdSAlfred Perlstein sigset_t mask; 7848360efbdSAlfred Perlstein sigset_t newmask; 7858360efbdSAlfred Perlstein 7868360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY ops_lock: ops */ 7878360efbdSAlfred Perlstein 7888360efbdSAlfred Perlstein sigfillset(&newmask); 7898360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 7908360efbdSAlfred Perlstein mutex_lock(&ops_lock); 7918360efbdSAlfred Perlstein if (ops.cl_call == NULL) { 7928360efbdSAlfred Perlstein ops.cl_call = clnt_dg_call; 7938360efbdSAlfred Perlstein ops.cl_abort = clnt_dg_abort; 7948360efbdSAlfred Perlstein ops.cl_geterr = clnt_dg_geterr; 7958360efbdSAlfred Perlstein ops.cl_freeres = clnt_dg_freeres; 7968360efbdSAlfred Perlstein ops.cl_destroy = clnt_dg_destroy; 7978360efbdSAlfred Perlstein ops.cl_control = clnt_dg_control; 7988360efbdSAlfred Perlstein } 7998360efbdSAlfred Perlstein mutex_unlock(&ops_lock); 8008360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &mask, NULL); 8018360efbdSAlfred Perlstein return (&ops); 8028360efbdSAlfred Perlstein } 8038360efbdSAlfred Perlstein 8048360efbdSAlfred Perlstein /* 8058360efbdSAlfred Perlstein * Make sure that the time is not garbage. -1 value is allowed. 8068360efbdSAlfred Perlstein */ 8078360efbdSAlfred Perlstein static bool_t 8088360efbdSAlfred Perlstein time_not_ok(t) 8098360efbdSAlfred Perlstein struct timeval *t; 8108360efbdSAlfred Perlstein { 8118360efbdSAlfred Perlstein return (t->tv_sec < -1 || t->tv_sec > 100000000 || 8128360efbdSAlfred Perlstein t->tv_usec < -1 || t->tv_usec > 1000000); 8138360efbdSAlfred Perlstein } 8148360efbdSAlfred Perlstein 8158360efbdSAlfred Perlstein 8168360efbdSAlfred Perlstein /* 8178360efbdSAlfred Perlstein * Convert from timevals (used by select) to milliseconds (used by poll). 8188360efbdSAlfred Perlstein */ 8198360efbdSAlfred Perlstein static int 8208360efbdSAlfred Perlstein __rpc_timeval_to_msec(t) 8218360efbdSAlfred Perlstein struct timeval *t; 8228360efbdSAlfred Perlstein { 8238360efbdSAlfred Perlstein int t1, tmp; 8248360efbdSAlfred Perlstein 8258360efbdSAlfred Perlstein /* 8268360efbdSAlfred Perlstein * We're really returning t->tv_sec * 1000 + (t->tv_usec / 1000) 8278360efbdSAlfred Perlstein * but try to do so efficiently. Note: 1000 = 1024 - 16 - 8. 8288360efbdSAlfred Perlstein */ 8298360efbdSAlfred Perlstein tmp = (int)t->tv_sec << 3; 8308360efbdSAlfred Perlstein t1 = -tmp; 8318360efbdSAlfred Perlstein t1 += t1 << 1; 8328360efbdSAlfred Perlstein t1 += tmp << 7; 8338360efbdSAlfred Perlstein if (t->tv_usec) 8348360efbdSAlfred Perlstein t1 += (int)(t->tv_usec / 1000); 8358360efbdSAlfred Perlstein 8368360efbdSAlfred Perlstein return (t1); 8378360efbdSAlfred Perlstein } 838