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