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/types.h> 50d7cd6ba3SIan Dowse #include <sys/event.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 *); 76cffc0b57SAlfred Perlstein static bool_t clnt_dg_control(CLIENT *, u_int, void *); 77c05ac53bSDavid E. O'Brien static void clnt_dg_destroy(CLIENT *); 788360efbdSAlfred Perlstein 798360efbdSAlfred Perlstein 808360efbdSAlfred Perlstein 818360efbdSAlfred Perlstein 828360efbdSAlfred Perlstein /* 838360efbdSAlfred Perlstein * This machinery implements per-fd locks for MT-safety. It is not 848360efbdSAlfred Perlstein * sufficient to do per-CLIENT handle locks for MT-safety because a 858360efbdSAlfred Perlstein * user may create more than one CLIENT handle with the same fd behind 868360efbdSAlfred Perlstein * it. Therfore, we allocate an array of flags (dg_fd_locks), protected 878360efbdSAlfred Perlstein * by the clnt_fd_lock mutex, and an array (dg_cv) of condition variables 888360efbdSAlfred Perlstein * similarly protected. Dg_fd_lock[fd] == 1 => a call is activte on some 898360efbdSAlfred Perlstein * CLIENT handle created for that fd. 908360efbdSAlfred Perlstein * The current implementation holds locks across the entire RPC and reply, 918360efbdSAlfred Perlstein * including retransmissions. Yes, this is silly, and as soon as this 928360efbdSAlfred Perlstein * code is proven to work, this should be the first thing fixed. One step 938360efbdSAlfred Perlstein * at a time. 948360efbdSAlfred Perlstein */ 958360efbdSAlfred Perlstein static int *dg_fd_locks; 968360efbdSAlfred Perlstein extern mutex_t clnt_fd_lock; 978360efbdSAlfred Perlstein static cond_t *dg_cv; 988360efbdSAlfred Perlstein #define release_fd_lock(fd, mask) { \ 998360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); \ 1008360efbdSAlfred Perlstein dg_fd_locks[fd] = 0; \ 1018360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); \ 102d7cd6ba3SIan Dowse thr_sigsetmask(SIG_SETMASK, &(mask), NULL); \ 1038360efbdSAlfred Perlstein cond_signal(&dg_cv[fd]); \ 1048360efbdSAlfred Perlstein } 1058360efbdSAlfred Perlstein 1068360efbdSAlfred Perlstein static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory"; 1078360efbdSAlfred Perlstein 1088360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY clnt_fd_lock: dg_fd_locks, dg_cv */ 1098360efbdSAlfred Perlstein 1108360efbdSAlfred Perlstein /* 1118360efbdSAlfred Perlstein * Private data kept per client handle 1128360efbdSAlfred Perlstein */ 1138360efbdSAlfred Perlstein struct cu_data { 1148360efbdSAlfred Perlstein int cu_fd; /* connections fd */ 1158360efbdSAlfred Perlstein bool_t cu_closeit; /* opened by library */ 1168360efbdSAlfred Perlstein struct sockaddr_storage cu_raddr; /* remote address */ 1178360efbdSAlfred Perlstein int cu_rlen; 1188360efbdSAlfred Perlstein struct timeval cu_wait; /* retransmit interval */ 1198360efbdSAlfred Perlstein struct timeval cu_total; /* total time for the call */ 1208360efbdSAlfred Perlstein struct rpc_err cu_error; 1218360efbdSAlfred Perlstein XDR cu_outxdrs; 1228360efbdSAlfred Perlstein u_int cu_xdrpos; 1238360efbdSAlfred Perlstein u_int cu_sendsz; /* send size */ 1248360efbdSAlfred Perlstein char *cu_outbuf; 1258360efbdSAlfred Perlstein u_int cu_recvsz; /* recv size */ 12665d3c627SBill Paul int cu_async; 12732de72d2SIan Dowse int cu_connect; /* Use connect(). */ 12832de72d2SIan Dowse int cu_connected; /* Have done connect(). */ 129d7cd6ba3SIan Dowse struct kevent cu_kin; 130d7cd6ba3SIan Dowse int cu_kq; 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; 276d7cd6ba3SIan Dowse cu->cu_kq = -1; 277d7cd6ba3SIan Dowse EV_SET(&cu->cu_kin, cu->cu_fd, EVFILT_READ, EV_ADD, 0, 0, 0); 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; 304d7cd6ba3SIan Dowse size_t outlen = 0; 3058360efbdSAlfred Perlstein struct rpc_msg reply_msg; 3068360efbdSAlfred Perlstein XDR reply_xdrs; 3078360efbdSAlfred Perlstein bool_t ok; 3088360efbdSAlfred Perlstein int nrefreshes = 2; /* number of times to refresh cred */ 3098360efbdSAlfred Perlstein struct timeval timeout; 3108360efbdSAlfred Perlstein struct timeval retransmit_time; 311d7cd6ba3SIan Dowse struct timeval next_sendtime, starttime, time_waited, tv; 312d7cd6ba3SIan Dowse struct timespec ts; 313d7cd6ba3SIan Dowse struct kevent kv; 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; 319d7cd6ba3SIan Dowse int kin_len, n, 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 cu->cu_error.re_errno = errno; 344d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_CANTSEND; 345d7cd6ba3SIan Dowse goto out; 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; 358d7cd6ba3SIan Dowse retransmit_time = next_sendtime = cu->cu_wait; 359d7cd6ba3SIan Dowse gettimeofday(&starttime, NULL); 360d7cd6ba3SIan Dowse 361d7cd6ba3SIan Dowse /* Clean up in case the last call ended in a longjmp(3) call. */ 362d7cd6ba3SIan Dowse if (cu->cu_kq >= 0) 363d7cd6ba3SIan Dowse _close(cu->cu_kq); 364d7cd6ba3SIan Dowse if ((cu->cu_kq = kqueue()) < 0) { 365d7cd6ba3SIan Dowse cu->cu_error.re_errno = errno; 366d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_CANTSEND; 367d7cd6ba3SIan Dowse goto out; 368d7cd6ba3SIan Dowse } 369d7cd6ba3SIan Dowse kin_len = 1; 3708360efbdSAlfred Perlstein 3718360efbdSAlfred Perlstein call_again: 3728360efbdSAlfred Perlstein xdrs = &(cu->cu_outxdrs); 37365d3c627SBill Paul if (cu->cu_async == TRUE && xargs == NULL) 37465d3c627SBill Paul goto get_reply; 3758360efbdSAlfred Perlstein xdrs->x_op = XDR_ENCODE; 3768360efbdSAlfred Perlstein XDR_SETPOS(xdrs, cu->cu_xdrpos); 3778360efbdSAlfred Perlstein /* 3788360efbdSAlfred Perlstein * the transaction is the first thing in the out buffer 37965d3c627SBill Paul * XXX Yes, and it's in network byte order, so we should to 38065d3c627SBill Paul * be careful when we increment it, shouldn't we. 3818360efbdSAlfred Perlstein */ 38265d3c627SBill Paul xid = ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf)); 38365d3c627SBill Paul xid++; 38465d3c627SBill Paul *(u_int32_t *)(void *)(cu->cu_outbuf) = htonl(xid); 38565d3c627SBill Paul 3868360efbdSAlfred Perlstein if ((! XDR_PUTINT32(xdrs, &proc)) || 3878360efbdSAlfred Perlstein (! AUTH_MARSHALL(cl->cl_auth, xdrs)) || 3888360efbdSAlfred Perlstein (! (*xargs)(xdrs, argsp))) { 389d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_CANTENCODEARGS; 390d7cd6ba3SIan Dowse goto out; 3918360efbdSAlfred Perlstein } 3928360efbdSAlfred Perlstein outlen = (size_t)XDR_GETPOS(xdrs); 3938360efbdSAlfred Perlstein 3948360efbdSAlfred Perlstein send_again: 39532de72d2SIan Dowse if (_sendto(cu->cu_fd, cu->cu_outbuf, outlen, 0, sa, salen) != outlen) { 3968360efbdSAlfred Perlstein cu->cu_error.re_errno = errno; 397d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_CANTSEND; 398d7cd6ba3SIan Dowse goto out; 3998360efbdSAlfred Perlstein } 4008360efbdSAlfred Perlstein 4018360efbdSAlfred Perlstein /* 4028360efbdSAlfred Perlstein * Hack to provide rpc-based message passing 4038360efbdSAlfred Perlstein */ 4048360efbdSAlfred Perlstein if (timeout.tv_sec == 0 && timeout.tv_usec == 0) { 405d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_TIMEDOUT; 406d7cd6ba3SIan Dowse goto out; 4078360efbdSAlfred Perlstein } 40865d3c627SBill Paul 40965d3c627SBill Paul get_reply: 41065d3c627SBill Paul 4118360efbdSAlfred Perlstein /* 4128360efbdSAlfred Perlstein * sub-optimal code appears here because we have 4138360efbdSAlfred Perlstein * some clock time to spare while the packets are in flight. 4148360efbdSAlfred Perlstein * (We assume that this is actually only executed once.) 4158360efbdSAlfred Perlstein */ 4168360efbdSAlfred Perlstein reply_msg.acpted_rply.ar_verf = _null_auth; 4178360efbdSAlfred Perlstein reply_msg.acpted_rply.ar_results.where = resultsp; 4188360efbdSAlfred Perlstein reply_msg.acpted_rply.ar_results.proc = xresults; 4198360efbdSAlfred Perlstein 4208360efbdSAlfred Perlstein for (;;) { 421d7cd6ba3SIan Dowse /* Decide how long to wait. */ 422d7cd6ba3SIan Dowse if (timercmp(&next_sendtime, &timeout, <)) 423d7cd6ba3SIan Dowse timersub(&next_sendtime, &time_waited, &tv); 424d7cd6ba3SIan Dowse else 425d7cd6ba3SIan Dowse timersub(&timeout, &time_waited, &tv); 426d7cd6ba3SIan Dowse if (tv.tv_sec < 0 || tv.tv_usec < 0) 427d7cd6ba3SIan Dowse tv.tv_sec = tv.tv_usec = 0; 428d7cd6ba3SIan Dowse TIMEVAL_TO_TIMESPEC(&tv, &ts); 4298360efbdSAlfred Perlstein 430d7cd6ba3SIan Dowse n = _kevent(cu->cu_kq, &cu->cu_kin, kin_len, &kv, 1, &ts); 431d7cd6ba3SIan Dowse /* We don't need to register the event again. */ 432d7cd6ba3SIan Dowse kin_len = 0; 4338360efbdSAlfred Perlstein 434d7cd6ba3SIan Dowse if (n == 1) { 435d7cd6ba3SIan Dowse if (kv.flags & EV_ERROR) { 436d7cd6ba3SIan Dowse cu->cu_error.re_errno = kv.data; 4378360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_CANTRECV; 438d7cd6ba3SIan Dowse goto out; 4398360efbdSAlfred Perlstein } 4408360efbdSAlfred Perlstein /* We have some data now */ 4418360efbdSAlfred Perlstein do { 4428360efbdSAlfred Perlstein recvlen = _recvfrom(cu->cu_fd, cu->cu_inbuf, 443a9d09e93SIan Dowse cu->cu_recvsz, 0, NULL, NULL); 4448360efbdSAlfred Perlstein } while (recvlen < 0 && errno == EINTR); 445d7cd6ba3SIan Dowse if (recvlen < 0 && errno != EWOULDBLOCK) { 4468360efbdSAlfred Perlstein cu->cu_error.re_errno = errno; 447d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_CANTRECV; 448d7cd6ba3SIan Dowse goto out; 4498360efbdSAlfred Perlstein } 450d7cd6ba3SIan Dowse if (recvlen >= sizeof(u_int32_t) && 451d7cd6ba3SIan Dowse (cu->cu_async == TRUE || 452d7cd6ba3SIan Dowse *((u_int32_t *)(void *)(cu->cu_inbuf)) == 453d7cd6ba3SIan Dowse *((u_int32_t *)(void *)(cu->cu_outbuf)))) { 454d7cd6ba3SIan Dowse /* We now assume we have the proper reply. */ 4558360efbdSAlfred Perlstein break; 4568360efbdSAlfred Perlstein } 457d7cd6ba3SIan Dowse } 458d7cd6ba3SIan Dowse if (n == -1 && errno != EINTR) { 459d7cd6ba3SIan Dowse cu->cu_error.re_errno = errno; 460d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_CANTRECV; 461d7cd6ba3SIan Dowse goto out; 462d7cd6ba3SIan Dowse } 463d7cd6ba3SIan Dowse gettimeofday(&tv, NULL); 464d7cd6ba3SIan Dowse timersub(&tv, &starttime, &time_waited); 465d7cd6ba3SIan Dowse 466d7cd6ba3SIan Dowse /* Check for timeout. */ 467d7cd6ba3SIan Dowse if (timercmp(&time_waited, &timeout, >)) { 468d7cd6ba3SIan Dowse cu->cu_error.re_status = RPC_TIMEDOUT; 469d7cd6ba3SIan Dowse goto out; 470d7cd6ba3SIan Dowse } 471d7cd6ba3SIan Dowse 472d7cd6ba3SIan Dowse /* Retransmit if necessary. */ 473d7cd6ba3SIan Dowse if (timercmp(&time_waited, &next_sendtime, >)) { 474d7cd6ba3SIan Dowse /* update retransmit_time */ 475d7cd6ba3SIan Dowse if (retransmit_time.tv_sec < RPC_MAX_BACKOFF) 476d7cd6ba3SIan Dowse timeradd(&retransmit_time, &retransmit_time, 477d7cd6ba3SIan Dowse &retransmit_time); 478d7cd6ba3SIan Dowse timeradd(&next_sendtime, &retransmit_time, 479d7cd6ba3SIan Dowse &next_sendtime); 480d7cd6ba3SIan Dowse goto send_again; 481d7cd6ba3SIan Dowse } 482d7cd6ba3SIan Dowse } 4838360efbdSAlfred Perlstein inlen = (socklen_t)recvlen; 4848360efbdSAlfred Perlstein 4858360efbdSAlfred Perlstein /* 4868360efbdSAlfred Perlstein * now decode and validate the response 4878360efbdSAlfred Perlstein */ 4888360efbdSAlfred Perlstein 489f4a180ccSMartin Blapp xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)recvlen, XDR_DECODE); 4908360efbdSAlfred Perlstein ok = xdr_replymsg(&reply_xdrs, &reply_msg); 4918360efbdSAlfred Perlstein /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */ 4928360efbdSAlfred Perlstein if (ok) { 4938360efbdSAlfred Perlstein if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) && 4948360efbdSAlfred Perlstein (reply_msg.acpted_rply.ar_stat == SUCCESS)) 4958360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_SUCCESS; 4968360efbdSAlfred Perlstein else 4978360efbdSAlfred Perlstein _seterr_reply(&reply_msg, &(cu->cu_error)); 4988360efbdSAlfred Perlstein 4998360efbdSAlfred Perlstein if (cu->cu_error.re_status == RPC_SUCCESS) { 5008360efbdSAlfred Perlstein if (! AUTH_VALIDATE(cl->cl_auth, 5018360efbdSAlfred Perlstein &reply_msg.acpted_rply.ar_verf)) { 5028360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_AUTHERROR; 5038360efbdSAlfred Perlstein cu->cu_error.re_why = AUTH_INVALIDRESP; 5048360efbdSAlfred Perlstein } 5058360efbdSAlfred Perlstein if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) { 5068360efbdSAlfred Perlstein xdrs->x_op = XDR_FREE; 5078360efbdSAlfred Perlstein (void) xdr_opaque_auth(xdrs, 5088360efbdSAlfred Perlstein &(reply_msg.acpted_rply.ar_verf)); 5098360efbdSAlfred Perlstein } 5108360efbdSAlfred Perlstein } /* end successful completion */ 5118360efbdSAlfred Perlstein /* 5128360efbdSAlfred Perlstein * If unsuccesful AND error is an authentication error 5138360efbdSAlfred Perlstein * then refresh credentials and try again, else break 5148360efbdSAlfred Perlstein */ 5158360efbdSAlfred Perlstein else if (cu->cu_error.re_status == RPC_AUTHERROR) 5168360efbdSAlfred Perlstein /* maybe our credentials need to be refreshed ... */ 5178360efbdSAlfred Perlstein if (nrefreshes > 0 && 5188360efbdSAlfred Perlstein AUTH_REFRESH(cl->cl_auth, &reply_msg)) { 5198360efbdSAlfred Perlstein nrefreshes--; 5208360efbdSAlfred Perlstein goto call_again; 5218360efbdSAlfred Perlstein } 5228360efbdSAlfred Perlstein /* end of unsuccessful completion */ 5238360efbdSAlfred Perlstein } /* end of valid reply message */ 5248360efbdSAlfred Perlstein else { 5258360efbdSAlfred Perlstein cu->cu_error.re_status = RPC_CANTDECODERES; 5268360efbdSAlfred Perlstein 5278360efbdSAlfred Perlstein } 528d7cd6ba3SIan Dowse out: 529d7cd6ba3SIan Dowse if (cu->cu_kq >= 0) 530d7cd6ba3SIan Dowse _close(cu->cu_kq); 531d7cd6ba3SIan Dowse cu->cu_kq = -1; 5328360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 5338360efbdSAlfred Perlstein return (cu->cu_error.re_status); 5348360efbdSAlfred Perlstein } 5358360efbdSAlfred Perlstein 5368360efbdSAlfred Perlstein static void 5378360efbdSAlfred Perlstein clnt_dg_geterr(cl, errp) 5388360efbdSAlfred Perlstein CLIENT *cl; 5398360efbdSAlfred Perlstein struct rpc_err *errp; 5408360efbdSAlfred Perlstein { 5418360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 5428360efbdSAlfred Perlstein 5438360efbdSAlfred Perlstein *errp = cu->cu_error; 5448360efbdSAlfred Perlstein } 5458360efbdSAlfred Perlstein 5468360efbdSAlfred Perlstein static bool_t 5478360efbdSAlfred Perlstein clnt_dg_freeres(cl, xdr_res, res_ptr) 5488360efbdSAlfred Perlstein CLIENT *cl; 5498360efbdSAlfred Perlstein xdrproc_t xdr_res; 550f249dbccSDag-Erling Smørgrav void *res_ptr; 5518360efbdSAlfred Perlstein { 5528360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 5538360efbdSAlfred Perlstein XDR *xdrs = &(cu->cu_outxdrs); 5548360efbdSAlfred Perlstein bool_t dummy; 5558360efbdSAlfred Perlstein sigset_t mask; 5568360efbdSAlfred Perlstein sigset_t newmask; 5578360efbdSAlfred Perlstein 5588360efbdSAlfred Perlstein sigfillset(&newmask); 5598360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 5608360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 5618360efbdSAlfred Perlstein while (dg_fd_locks[cu->cu_fd]) 5628360efbdSAlfred Perlstein cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 5638360efbdSAlfred Perlstein xdrs->x_op = XDR_FREE; 5648360efbdSAlfred Perlstein dummy = (*xdr_res)(xdrs, res_ptr); 5658360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 5668360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &mask, NULL); 5678360efbdSAlfred Perlstein cond_signal(&dg_cv[cu->cu_fd]); 5688360efbdSAlfred Perlstein return (dummy); 5698360efbdSAlfred Perlstein } 5708360efbdSAlfred Perlstein 5718360efbdSAlfred Perlstein /*ARGSUSED*/ 5728360efbdSAlfred Perlstein static void 5738360efbdSAlfred Perlstein clnt_dg_abort(h) 5748360efbdSAlfred Perlstein CLIENT *h; 5758360efbdSAlfred Perlstein { 5768360efbdSAlfred Perlstein } 5778360efbdSAlfred Perlstein 5788360efbdSAlfred Perlstein static bool_t 5798360efbdSAlfred Perlstein clnt_dg_control(cl, request, info) 5808360efbdSAlfred Perlstein CLIENT *cl; 5818360efbdSAlfred Perlstein u_int request; 582cffc0b57SAlfred Perlstein void *info; 5838360efbdSAlfred Perlstein { 5848360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 5858360efbdSAlfred Perlstein struct netbuf *addr; 5868360efbdSAlfred Perlstein sigset_t mask; 5878360efbdSAlfred Perlstein sigset_t newmask; 5888360efbdSAlfred Perlstein int rpc_lock_value; 5898360efbdSAlfred Perlstein 5908360efbdSAlfred Perlstein sigfillset(&newmask); 5918360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 5928360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 5938360efbdSAlfred Perlstein while (dg_fd_locks[cu->cu_fd]) 5948360efbdSAlfred Perlstein cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 5958360efbdSAlfred Perlstein if (__isthreaded) 5968360efbdSAlfred Perlstein rpc_lock_value = 1; 5978360efbdSAlfred Perlstein else 5988360efbdSAlfred Perlstein rpc_lock_value = 0; 5998360efbdSAlfred Perlstein dg_fd_locks[cu->cu_fd] = rpc_lock_value; 6008360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 6018360efbdSAlfred Perlstein switch (request) { 6028360efbdSAlfred Perlstein case CLSET_FD_CLOSE: 6038360efbdSAlfred Perlstein cu->cu_closeit = TRUE; 6048360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6058360efbdSAlfred Perlstein return (TRUE); 6068360efbdSAlfred Perlstein case CLSET_FD_NCLOSE: 6078360efbdSAlfred Perlstein cu->cu_closeit = FALSE; 6088360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6098360efbdSAlfred Perlstein return (TRUE); 6108360efbdSAlfred Perlstein } 6118360efbdSAlfred Perlstein 6128360efbdSAlfred Perlstein /* for other requests which use info */ 6138360efbdSAlfred Perlstein if (info == NULL) { 6148360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6158360efbdSAlfred Perlstein return (FALSE); 6168360efbdSAlfred Perlstein } 6178360efbdSAlfred Perlstein switch (request) { 6188360efbdSAlfred Perlstein case CLSET_TIMEOUT: 619cffc0b57SAlfred Perlstein if (time_not_ok((struct timeval *)info)) { 6208360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6218360efbdSAlfred Perlstein return (FALSE); 6228360efbdSAlfred Perlstein } 623cffc0b57SAlfred Perlstein cu->cu_total = *(struct timeval *)info; 6248360efbdSAlfred Perlstein break; 6258360efbdSAlfred Perlstein case CLGET_TIMEOUT: 626cffc0b57SAlfred Perlstein *(struct timeval *)info = cu->cu_total; 6278360efbdSAlfred Perlstein break; 6288360efbdSAlfred Perlstein case CLGET_SERVER_ADDR: /* Give him the fd address */ 6298360efbdSAlfred Perlstein /* Now obsolete. Only for backward compatibility */ 6308360efbdSAlfred Perlstein (void) memcpy(info, &cu->cu_raddr, (size_t)cu->cu_rlen); 6318360efbdSAlfred Perlstein break; 6328360efbdSAlfred Perlstein case CLSET_RETRY_TIMEOUT: 633cffc0b57SAlfred Perlstein if (time_not_ok((struct timeval *)info)) { 6348360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 6358360efbdSAlfred Perlstein return (FALSE); 6368360efbdSAlfred Perlstein } 637cffc0b57SAlfred Perlstein cu->cu_wait = *(struct timeval *)info; 6388360efbdSAlfred Perlstein break; 6398360efbdSAlfred Perlstein case CLGET_RETRY_TIMEOUT: 640cffc0b57SAlfred Perlstein *(struct timeval *)info = cu->cu_wait; 6418360efbdSAlfred Perlstein break; 6428360efbdSAlfred Perlstein case CLGET_FD: 643cffc0b57SAlfred Perlstein *(int *)info = cu->cu_fd; 6448360efbdSAlfred Perlstein break; 6458360efbdSAlfred Perlstein case CLGET_SVC_ADDR: 646cffc0b57SAlfred Perlstein addr = (struct netbuf *)info; 6478360efbdSAlfred Perlstein addr->buf = &cu->cu_raddr; 6488360efbdSAlfred Perlstein addr->len = cu->cu_rlen; 6498360efbdSAlfred Perlstein addr->maxlen = sizeof cu->cu_raddr; 6508360efbdSAlfred Perlstein break; 6518360efbdSAlfred Perlstein case CLSET_SVC_ADDR: /* set to new address */ 652cffc0b57SAlfred Perlstein addr = (struct netbuf *)info; 653cd517469SIan Dowse if (addr->len < sizeof cu->cu_raddr) { 654cd517469SIan Dowse release_fd_lock(cu->cu_fd, mask); 6558360efbdSAlfred Perlstein return (FALSE); 656cd517469SIan Dowse } 6578360efbdSAlfred Perlstein (void) memcpy(&cu->cu_raddr, addr->buf, addr->len); 6588360efbdSAlfred Perlstein cu->cu_rlen = addr->len; 6598360efbdSAlfred Perlstein break; 6608360efbdSAlfred Perlstein case CLGET_XID: 6618360efbdSAlfred Perlstein /* 6628360efbdSAlfred Perlstein * use the knowledge that xid is the 6638360efbdSAlfred Perlstein * first element in the call structure *. 6648360efbdSAlfred Perlstein * This will get the xid of the PREVIOUS call 6658360efbdSAlfred Perlstein */ 666cffc0b57SAlfred Perlstein *(u_int32_t *)info = 6678360efbdSAlfred Perlstein ntohl(*(u_int32_t *)(void *)cu->cu_outbuf); 6688360efbdSAlfred Perlstein break; 6698360efbdSAlfred Perlstein 6708360efbdSAlfred Perlstein case CLSET_XID: 6718360efbdSAlfred Perlstein /* This will set the xid of the NEXT call */ 6728360efbdSAlfred Perlstein *(u_int32_t *)(void *)cu->cu_outbuf = 673cffc0b57SAlfred Perlstein htonl(*(u_int32_t *)info - 1); 6748360efbdSAlfred Perlstein /* decrement by 1 as clnt_dg_call() increments once */ 6758360efbdSAlfred Perlstein break; 6768360efbdSAlfred Perlstein 6778360efbdSAlfred Perlstein case CLGET_VERS: 6788360efbdSAlfred Perlstein /* 6798360efbdSAlfred Perlstein * This RELIES on the information that, in the call body, 6808360efbdSAlfred Perlstein * the version number field is the fifth field from the 6818360efbdSAlfred Perlstein * begining of the RPC header. MUST be changed if the 6828360efbdSAlfred Perlstein * call_struct is changed 6838360efbdSAlfred Perlstein */ 684cffc0b57SAlfred Perlstein *(u_int32_t *)info = 6858360efbdSAlfred Perlstein ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf + 6868360efbdSAlfred Perlstein 4 * BYTES_PER_XDR_UNIT)); 6878360efbdSAlfred Perlstein break; 6888360efbdSAlfred Perlstein 6898360efbdSAlfred Perlstein case CLSET_VERS: 6908360efbdSAlfred Perlstein *(u_int32_t *)(void *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT) 691cffc0b57SAlfred Perlstein = htonl(*(u_int32_t *)info); 6928360efbdSAlfred Perlstein break; 6938360efbdSAlfred Perlstein 6948360efbdSAlfred Perlstein case CLGET_PROG: 6958360efbdSAlfred Perlstein /* 6968360efbdSAlfred Perlstein * This RELIES on the information that, in the call body, 6978360efbdSAlfred Perlstein * the program number field is the fourth field from the 6988360efbdSAlfred Perlstein * begining of the RPC header. MUST be changed if the 6998360efbdSAlfred Perlstein * call_struct is changed 7008360efbdSAlfred Perlstein */ 701cffc0b57SAlfred Perlstein *(u_int32_t *)info = 7028360efbdSAlfred Perlstein ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf + 7038360efbdSAlfred Perlstein 3 * BYTES_PER_XDR_UNIT)); 7048360efbdSAlfred Perlstein break; 7058360efbdSAlfred Perlstein 7068360efbdSAlfred Perlstein case CLSET_PROG: 7078360efbdSAlfred Perlstein *(u_int32_t *)(void *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT) 708cffc0b57SAlfred Perlstein = htonl(*(u_int32_t *)info); 7098360efbdSAlfred Perlstein break; 71065d3c627SBill Paul case CLSET_ASYNC: 711cffc0b57SAlfred Perlstein cu->cu_async = *(int *)info; 71265d3c627SBill Paul break; 71332de72d2SIan Dowse case CLSET_CONNECT: 714cffc0b57SAlfred Perlstein cu->cu_connect = *(int *)info; 71532de72d2SIan Dowse break; 7168360efbdSAlfred Perlstein default: 7178360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 7188360efbdSAlfred Perlstein return (FALSE); 7198360efbdSAlfred Perlstein } 7208360efbdSAlfred Perlstein release_fd_lock(cu->cu_fd, mask); 7218360efbdSAlfred Perlstein return (TRUE); 7228360efbdSAlfred Perlstein } 7238360efbdSAlfred Perlstein 7248360efbdSAlfred Perlstein static void 7258360efbdSAlfred Perlstein clnt_dg_destroy(cl) 7268360efbdSAlfred Perlstein CLIENT *cl; 7278360efbdSAlfred Perlstein { 7288360efbdSAlfred Perlstein struct cu_data *cu = (struct cu_data *)cl->cl_private; 7298360efbdSAlfred Perlstein int cu_fd = cu->cu_fd; 7308360efbdSAlfred Perlstein sigset_t mask; 7318360efbdSAlfred Perlstein sigset_t newmask; 7328360efbdSAlfred Perlstein 7338360efbdSAlfred Perlstein sigfillset(&newmask); 7348360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 7358360efbdSAlfred Perlstein mutex_lock(&clnt_fd_lock); 7368360efbdSAlfred Perlstein while (dg_fd_locks[cu_fd]) 7378360efbdSAlfred Perlstein cond_wait(&dg_cv[cu_fd], &clnt_fd_lock); 7388360efbdSAlfred Perlstein if (cu->cu_closeit) 7398360efbdSAlfred Perlstein (void)_close(cu_fd); 740d7cd6ba3SIan Dowse if (cu->cu_kq >= 0) 741d7cd6ba3SIan Dowse _close(cu->cu_kq); 7428360efbdSAlfred Perlstein XDR_DESTROY(&(cu->cu_outxdrs)); 7438360efbdSAlfred Perlstein mem_free(cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz)); 7448360efbdSAlfred Perlstein if (cl->cl_netid && cl->cl_netid[0]) 7458360efbdSAlfred Perlstein mem_free(cl->cl_netid, strlen(cl->cl_netid) +1); 7468360efbdSAlfred Perlstein if (cl->cl_tp && cl->cl_tp[0]) 7478360efbdSAlfred Perlstein mem_free(cl->cl_tp, strlen(cl->cl_tp) +1); 7488360efbdSAlfred Perlstein mem_free(cl, sizeof (CLIENT)); 7498360efbdSAlfred Perlstein mutex_unlock(&clnt_fd_lock); 7508360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &mask, NULL); 7518360efbdSAlfred Perlstein cond_signal(&dg_cv[cu_fd]); 7528360efbdSAlfred Perlstein } 7538360efbdSAlfred Perlstein 7548360efbdSAlfred Perlstein static struct clnt_ops * 7558360efbdSAlfred Perlstein clnt_dg_ops() 7568360efbdSAlfred Perlstein { 7578360efbdSAlfred Perlstein static struct clnt_ops ops; 7588360efbdSAlfred Perlstein extern mutex_t ops_lock; 7598360efbdSAlfred Perlstein sigset_t mask; 7608360efbdSAlfred Perlstein sigset_t newmask; 7618360efbdSAlfred Perlstein 7628360efbdSAlfred Perlstein /* VARIABLES PROTECTED BY ops_lock: ops */ 7638360efbdSAlfred Perlstein 7648360efbdSAlfred Perlstein sigfillset(&newmask); 7658360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 7668360efbdSAlfred Perlstein mutex_lock(&ops_lock); 7678360efbdSAlfred Perlstein if (ops.cl_call == NULL) { 7688360efbdSAlfred Perlstein ops.cl_call = clnt_dg_call; 7698360efbdSAlfred Perlstein ops.cl_abort = clnt_dg_abort; 7708360efbdSAlfred Perlstein ops.cl_geterr = clnt_dg_geterr; 7718360efbdSAlfred Perlstein ops.cl_freeres = clnt_dg_freeres; 7728360efbdSAlfred Perlstein ops.cl_destroy = clnt_dg_destroy; 7738360efbdSAlfred Perlstein ops.cl_control = clnt_dg_control; 7748360efbdSAlfred Perlstein } 7758360efbdSAlfred Perlstein mutex_unlock(&ops_lock); 7768360efbdSAlfred Perlstein thr_sigsetmask(SIG_SETMASK, &mask, NULL); 7778360efbdSAlfred Perlstein return (&ops); 7788360efbdSAlfred Perlstein } 7798360efbdSAlfred Perlstein 7808360efbdSAlfred Perlstein /* 7818360efbdSAlfred Perlstein * Make sure that the time is not garbage. -1 value is allowed. 7828360efbdSAlfred Perlstein */ 7838360efbdSAlfred Perlstein static bool_t 7848360efbdSAlfred Perlstein time_not_ok(t) 7858360efbdSAlfred Perlstein struct timeval *t; 7868360efbdSAlfred Perlstein { 7878360efbdSAlfred Perlstein return (t->tv_sec < -1 || t->tv_sec > 100000000 || 7888360efbdSAlfred Perlstein t->tv_usec < -1 || t->tv_usec > 1000000); 7898360efbdSAlfred Perlstein } 7908360efbdSAlfred Perlstein 791