174462Salfred/* $NetBSD: clnt_vc.c,v 1.4 2000/07/14 08:40:42 fvdl Exp $ */ 274462Salfred 3261057Smav/*- 4261057Smav * Copyright (c) 2009, Sun Microsystems, Inc. 5261057Smav * All rights reserved. 6261057Smav * 7261057Smav * Redistribution and use in source and binary forms, with or without 8261057Smav * modification, are permitted provided that the following conditions are met: 9261057Smav * - Redistributions of source code must retain the above copyright notice, 10261057Smav * this list of conditions and the following disclaimer. 11261057Smav * - Redistributions in binary form must reproduce the above copyright notice, 12261057Smav * this list of conditions and the following disclaimer in the documentation 13261057Smav * and/or other materials provided with the distribution. 14261057Smav * - Neither the name of Sun Microsystems, Inc. nor the names of its 15261057Smav * contributors may be used to endorse or promote products derived 16261057Smav * from this software without specific prior written permission. 1774462Salfred * 18261057Smav * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19261057Smav * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20261057Smav * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21261057Smav * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 22261057Smav * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23261057Smav * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24261057Smav * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25261057Smav * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26261057Smav * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27261057Smav * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28261057Smav * POSSIBILITY OF SUCH DAMAGE. 2974462Salfred */ 3074462Salfred 3174462Salfred#if defined(LIBC_SCCS) && !defined(lint) 32136581Sobrienstatic char *sccsid2 = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro"; 3374462Salfredstatic char *sccsid = "@(#)clnt_tcp.c 2.2 88/08/01 4.0 RPCSRC"; 34136581Sobrienstatic char sccsid3[] = "@(#)clnt_vc.c 1.19 89/03/16 Copyr 1988 Sun Micro"; 3574462Salfred#endif 3692990Sobrien#include <sys/cdefs.h> 3792990Sobrien__FBSDID("$FreeBSD$"); 3874462Salfred 3974462Salfred/* 4074462Salfred * clnt_tcp.c, Implements a TCP/IP based, client side RPC. 4174462Salfred * 4274462Salfred * Copyright (C) 1984, Sun Microsystems, Inc. 4374462Salfred * 4474462Salfred * TCP based RPC supports 'batched calls'. 4574462Salfred * A sequence of calls may be batched-up in a send buffer. The rpc call 4674462Salfred * return immediately to the client even though the call was not necessarily 4774462Salfred * sent. The batching occurs if the results' xdr routine is NULL (0) AND 4874462Salfred * the rpc timeout value is zero (see clnt.h, rpc). 4974462Salfred * 5074462Salfred * Clients should NOT casually batch calls that in fact return results; that is, 5174462Salfred * the server side should be aware that a call is batched and not produce any 5274462Salfred * return message. Batched calls that produce many result messages can 5374462Salfred * deadlock (netlock) the client and the server.... 5474462Salfred * 5574462Salfred * Now go hang yourself. 5674462Salfred */ 5774462Salfred 5875094Siedowse#include "namespace.h" 5974462Salfred#include "reentrant.h" 6074462Salfred#include <sys/types.h> 6174462Salfred#include <sys/poll.h> 6274462Salfred#include <sys/syslog.h> 6374462Salfred#include <sys/socket.h> 6474462Salfred#include <sys/un.h> 6574462Salfred#include <sys/uio.h> 6674462Salfred 6790868Smike#include <arpa/inet.h> 6874462Salfred#include <assert.h> 6974462Salfred#include <err.h> 7074462Salfred#include <errno.h> 7174462Salfred#include <netdb.h> 7274462Salfred#include <stdio.h> 7374462Salfred#include <stdlib.h> 7474462Salfred#include <string.h> 7574462Salfred#include <unistd.h> 7674462Salfred#include <signal.h> 7774462Salfred 7874462Salfred#include <rpc/rpc.h> 79181344Sdfr#include <rpc/rpcsec_gss.h> 8074462Salfred#include "un-namespace.h" 8174462Salfred#include "rpc_com.h" 82156090Sdeischen#include "mt_misc.h" 8374462Salfred 8474462Salfred#define MCALL_MSG_SIZE 24 8574462Salfred 8674660Salfredstruct cmessage { 8774660Salfred struct cmsghdr cmsg; 8874660Salfred struct cmsgcred cmcred; 8974660Salfred}; 9074660Salfred 9195658Sdesstatic enum clnt_stat clnt_vc_call(CLIENT *, rpcproc_t, xdrproc_t, void *, 9295658Sdes xdrproc_t, void *, struct timeval); 9392905Sobrienstatic void clnt_vc_geterr(CLIENT *, struct rpc_err *); 9495658Sdesstatic bool_t clnt_vc_freeres(CLIENT *, xdrproc_t, void *); 9592905Sobrienstatic void clnt_vc_abort(CLIENT *); 9699996Salfredstatic bool_t clnt_vc_control(CLIENT *, u_int, void *); 9792905Sobrienstatic void clnt_vc_destroy(CLIENT *); 9892905Sobrienstatic struct clnt_ops *clnt_vc_ops(void); 9992905Sobrienstatic bool_t time_not_ok(struct timeval *); 10095658Sdesstatic int read_vc(void *, void *, int); 10195658Sdesstatic int write_vc(void *, void *, int); 10274462Salfredstatic int __msgwrite(int, void *, size_t); 10374462Salfredstatic int __msgread(int, void *, size_t); 10474462Salfred 10574462Salfredstruct ct_data { 10674462Salfred int ct_fd; /* connection's fd */ 10774462Salfred bool_t ct_closeit; /* close it on destroy */ 10874462Salfred struct timeval ct_wait; /* wait interval in milliseconds */ 10974462Salfred bool_t ct_waitset; /* wait set by clnt_control? */ 11074462Salfred struct netbuf ct_addr; /* remote addr */ 11174462Salfred struct rpc_err ct_error; 11274462Salfred union { 11374462Salfred char ct_mcallc[MCALL_MSG_SIZE]; /* marshalled callmsg */ 11474462Salfred u_int32_t ct_mcalli; 11574462Salfred } ct_u; 11674462Salfred u_int ct_mpos; /* pos after marshal */ 11774462Salfred XDR ct_xdrs; /* XDR stream */ 11874462Salfred}; 11974462Salfred 12074462Salfred/* 12174462Salfred * This machinery implements per-fd locks for MT-safety. It is not 12274462Salfred * sufficient to do per-CLIENT handle locks for MT-safety because a 12374462Salfred * user may create more than one CLIENT handle with the same fd behind 12474462Salfred * it. Therfore, we allocate an array of flags (vc_fd_locks), protected 12574462Salfred * by the clnt_fd_lock mutex, and an array (vc_cv) of condition variables 12674462Salfred * similarly protected. Vc_fd_lock[fd] == 1 => a call is activte on some 12774462Salfred * CLIENT handle created for that fd. 12874462Salfred * The current implementation holds locks across the entire RPC and reply. 12974462Salfred * Yes, this is silly, and as soon as this code is proven to work, this 13074462Salfred * should be the first thing fixed. One step at a time. 13174462Salfred */ 13274462Salfredstatic int *vc_fd_locks; 13374462Salfredstatic cond_t *vc_cv; 13474462Salfred#define release_fd_lock(fd, mask) { \ 13574462Salfred mutex_lock(&clnt_fd_lock); \ 13675144Siedowse vc_fd_locks[fd] = 0; \ 13774462Salfred mutex_unlock(&clnt_fd_lock); \ 13874462Salfred thr_sigsetmask(SIG_SETMASK, &(mask), (sigset_t *) NULL); \ 13974462Salfred cond_signal(&vc_cv[fd]); \ 14074462Salfred} 14174462Salfred 14274462Salfredstatic const char clnt_vc_errstr[] = "%s : %s"; 14374462Salfredstatic const char clnt_vc_str[] = "clnt_vc_create"; 14474462Salfredstatic const char clnt_read_vc_str[] = "read_vc"; 14574462Salfredstatic const char __no_mem_str[] = "out of memory"; 14674462Salfred 14774462Salfred/* 14874462Salfred * Create a client handle for a connection. 14974462Salfred * Default options are set, which the user can change using clnt_control()'s. 15074462Salfred * The rpc/vc package does buffering similar to stdio, so the client 15174462Salfred * must pick send and receive buffer sizes, 0 => use the default. 15274462Salfred * NB: fd is copied into a private area. 15374462Salfred * NB: The rpch->cl_auth is set null authentication. Caller may wish to 15474462Salfred * set this something more useful. 15574462Salfred * 15674462Salfred * fd should be an open socket 15774462Salfred */ 15874462SalfredCLIENT * 15974462Salfredclnt_vc_create(fd, raddr, prog, vers, sendsz, recvsz) 16074462Salfred int fd; /* open file descriptor */ 16174462Salfred const struct netbuf *raddr; /* servers address */ 162100001Salfred const rpcprog_t prog; /* program number */ 163100001Salfred const rpcvers_t vers; /* version number */ 16474462Salfred u_int sendsz; /* buffer recv size */ 16574462Salfred u_int recvsz; /* buffer send size */ 16674462Salfred{ 16774462Salfred CLIENT *cl; /* client handle */ 16874462Salfred struct ct_data *ct = NULL; /* client handle */ 16974462Salfred struct timeval now; 17074462Salfred struct rpc_msg call_msg; 17174462Salfred static u_int32_t disrupt; 17274462Salfred sigset_t mask; 17374462Salfred sigset_t newmask; 17474462Salfred struct sockaddr_storage ss; 17574462Salfred socklen_t slen; 17674462Salfred struct __rpc_sockinfo si; 17774462Salfred 17874462Salfred if (disrupt == 0) 17974462Salfred disrupt = (u_int32_t)(long)raddr; 18074462Salfred 18174462Salfred cl = (CLIENT *)mem_alloc(sizeof (*cl)); 18274462Salfred ct = (struct ct_data *)mem_alloc(sizeof (*ct)); 18374462Salfred if ((cl == (CLIENT *)NULL) || (ct == (struct ct_data *)NULL)) { 18474462Salfred (void) syslog(LOG_ERR, clnt_vc_errstr, 18574462Salfred clnt_vc_str, __no_mem_str); 18674462Salfred rpc_createerr.cf_stat = RPC_SYSTEMERROR; 18774462Salfred rpc_createerr.cf_error.re_errno = errno; 18874462Salfred goto err; 18974462Salfred } 19074462Salfred ct->ct_addr.buf = NULL; 19174462Salfred sigfillset(&newmask); 19274462Salfred thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 19374462Salfred mutex_lock(&clnt_fd_lock); 19474462Salfred if (vc_fd_locks == (int *) NULL) { 19574462Salfred int cv_allocsz, fd_allocsz; 19674462Salfred int dtbsize = __rpc_dtbsize(); 19774462Salfred 19874462Salfred fd_allocsz = dtbsize * sizeof (int); 19974462Salfred vc_fd_locks = (int *) mem_alloc(fd_allocsz); 20074462Salfred if (vc_fd_locks == (int *) NULL) { 20174462Salfred mutex_unlock(&clnt_fd_lock); 20274462Salfred thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 20374462Salfred goto err; 20474462Salfred } else 20574462Salfred memset(vc_fd_locks, '\0', fd_allocsz); 20674462Salfred 20774462Salfred assert(vc_cv == (cond_t *) NULL); 20874462Salfred cv_allocsz = dtbsize * sizeof (cond_t); 20974462Salfred vc_cv = (cond_t *) mem_alloc(cv_allocsz); 21074462Salfred if (vc_cv == (cond_t *) NULL) { 21174462Salfred mem_free(vc_fd_locks, fd_allocsz); 21274462Salfred vc_fd_locks = (int *) NULL; 21374462Salfred mutex_unlock(&clnt_fd_lock); 21474462Salfred thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 21574462Salfred goto err; 21674462Salfred } else { 21774462Salfred int i; 21874462Salfred 21974462Salfred for (i = 0; i < dtbsize; i++) 22074462Salfred cond_init(&vc_cv[i], 0, (void *) 0); 22174462Salfred } 22274462Salfred } else 22374462Salfred assert(vc_cv != (cond_t *) NULL); 22474462Salfred 22574462Salfred /* 22674462Salfred * XXX - fvdl connecting while holding a mutex? 22774462Salfred */ 22874462Salfred slen = sizeof ss; 22974462Salfred if (_getpeername(fd, (struct sockaddr *)(void *)&ss, &slen) < 0) { 23074462Salfred if (errno != ENOTCONN) { 23174462Salfred rpc_createerr.cf_stat = RPC_SYSTEMERROR; 23274462Salfred rpc_createerr.cf_error.re_errno = errno; 23374462Salfred mutex_unlock(&clnt_fd_lock); 23475097Siedowse thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 23574462Salfred goto err; 23674462Salfred } 23774462Salfred if (_connect(fd, (struct sockaddr *)raddr->buf, raddr->len) < 0){ 23874462Salfred rpc_createerr.cf_stat = RPC_SYSTEMERROR; 23974462Salfred rpc_createerr.cf_error.re_errno = errno; 24074462Salfred mutex_unlock(&clnt_fd_lock); 24175097Siedowse thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 24274462Salfred goto err; 24374462Salfred } 24474462Salfred } 24574462Salfred mutex_unlock(&clnt_fd_lock); 246162190Smbr thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 24774462Salfred if (!__rpc_fd2sockinfo(fd, &si)) 24874462Salfred goto err; 24974462Salfred 25074462Salfred ct->ct_closeit = FALSE; 25174462Salfred 25274462Salfred /* 25374462Salfred * Set up private data struct 25474462Salfred */ 25574462Salfred ct->ct_fd = fd; 25674462Salfred ct->ct_wait.tv_usec = 0; 25774462Salfred ct->ct_waitset = FALSE; 25874462Salfred ct->ct_addr.buf = malloc(raddr->maxlen); 25974462Salfred if (ct->ct_addr.buf == NULL) 26074462Salfred goto err; 26177588Siedowse memcpy(ct->ct_addr.buf, raddr->buf, raddr->len); 26274462Salfred ct->ct_addr.len = raddr->maxlen; 26374462Salfred ct->ct_addr.maxlen = raddr->maxlen; 26474462Salfred 26574462Salfred /* 26674462Salfred * Initialize call message 26774462Salfred */ 26874462Salfred (void)gettimeofday(&now, NULL); 26974462Salfred call_msg.rm_xid = ((u_int32_t)++disrupt) ^ __RPC_GETXID(&now); 27074462Salfred call_msg.rm_direction = CALL; 27174462Salfred call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; 27274462Salfred call_msg.rm_call.cb_prog = (u_int32_t)prog; 27374462Salfred call_msg.rm_call.cb_vers = (u_int32_t)vers; 27474462Salfred 27574462Salfred /* 27674462Salfred * pre-serialize the static part of the call msg and stash it away 27774462Salfred */ 27874462Salfred xdrmem_create(&(ct->ct_xdrs), ct->ct_u.ct_mcallc, MCALL_MSG_SIZE, 27974462Salfred XDR_ENCODE); 28074462Salfred if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) { 28174462Salfred if (ct->ct_closeit) { 28274462Salfred (void)_close(fd); 28374462Salfred } 28474462Salfred goto err; 28574462Salfred } 28674462Salfred ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs)); 28774462Salfred XDR_DESTROY(&(ct->ct_xdrs)); 288181344Sdfr assert(ct->ct_mpos + sizeof(uint32_t) <= MCALL_MSG_SIZE); 28974462Salfred 29074462Salfred /* 29174462Salfred * Create a client handle which uses xdrrec for serialization 29274462Salfred * and authnone for authentication. 29374462Salfred */ 29474462Salfred cl->cl_ops = clnt_vc_ops(); 29574462Salfred cl->cl_private = ct; 29674462Salfred cl->cl_auth = authnone_create(); 29774462Salfred sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz); 29874462Salfred recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz); 29974462Salfred xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz, 30074462Salfred cl->cl_private, read_vc, write_vc); 30174462Salfred return (cl); 30274462Salfred 30374462Salfrederr: 304266245Sbrueffer if (ct) { 305266245Sbrueffer if (ct->ct_addr.len) 306266245Sbrueffer mem_free(ct->ct_addr.buf, ct->ct_addr.len); 307266245Sbrueffer mem_free(ct, sizeof (struct ct_data)); 30874462Salfred } 309266245Sbrueffer if (cl) 310266245Sbrueffer mem_free(cl, sizeof (CLIENT)); 31174462Salfred return ((CLIENT *)NULL); 31274462Salfred} 31374462Salfred 31474462Salfredstatic enum clnt_stat 31574462Salfredclnt_vc_call(cl, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout) 31674462Salfred CLIENT *cl; 31774462Salfred rpcproc_t proc; 31874462Salfred xdrproc_t xdr_args; 31995658Sdes void *args_ptr; 32074462Salfred xdrproc_t xdr_results; 32195658Sdes void *results_ptr; 32274462Salfred struct timeval timeout; 32374462Salfred{ 32474462Salfred struct ct_data *ct = (struct ct_data *) cl->cl_private; 32574462Salfred XDR *xdrs = &(ct->ct_xdrs); 32674462Salfred struct rpc_msg reply_msg; 32774462Salfred u_int32_t x_id; 32874462Salfred u_int32_t *msg_x_id = &ct->ct_u.ct_mcalli; /* yuk */ 32974462Salfred bool_t shipnow; 33074462Salfred int refreshes = 2; 33174462Salfred sigset_t mask, newmask; 33274462Salfred int rpc_lock_value; 333181344Sdfr bool_t reply_stat; 33474462Salfred 33574462Salfred assert(cl != NULL); 33674462Salfred 33774462Salfred sigfillset(&newmask); 33874462Salfred thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 33974462Salfred mutex_lock(&clnt_fd_lock); 34074462Salfred while (vc_fd_locks[ct->ct_fd]) 34174462Salfred cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock); 34274462Salfred if (__isthreaded) 34374462Salfred rpc_lock_value = 1; 34474462Salfred else 34574462Salfred rpc_lock_value = 0; 34674462Salfred vc_fd_locks[ct->ct_fd] = rpc_lock_value; 34774462Salfred mutex_unlock(&clnt_fd_lock); 34874462Salfred if (!ct->ct_waitset) { 34974462Salfred /* If time is not within limits, we ignore it. */ 35074462Salfred if (time_not_ok(&timeout) == FALSE) 35174462Salfred ct->ct_wait = timeout; 35274462Salfred } 35374462Salfred 35474462Salfred shipnow = 35574462Salfred (xdr_results == NULL && timeout.tv_sec == 0 35674462Salfred && timeout.tv_usec == 0) ? FALSE : TRUE; 35774462Salfred 35874462Salfredcall_again: 35974462Salfred xdrs->x_op = XDR_ENCODE; 36074462Salfred ct->ct_error.re_status = RPC_SUCCESS; 36174462Salfred x_id = ntohl(--(*msg_x_id)); 36274462Salfred 363181344Sdfr if (cl->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) { 364181344Sdfr if ((! XDR_PUTBYTES(xdrs, ct->ct_u.ct_mcallc, ct->ct_mpos)) || 365181344Sdfr (! XDR_PUTINT32(xdrs, &proc)) || 366181344Sdfr (! AUTH_MARSHALL(cl->cl_auth, xdrs)) || 367181344Sdfr (! (*xdr_args)(xdrs, args_ptr))) { 368181344Sdfr if (ct->ct_error.re_status == RPC_SUCCESS) 369181344Sdfr ct->ct_error.re_status = RPC_CANTENCODEARGS; 370181344Sdfr (void)xdrrec_endofrecord(xdrs, TRUE); 371181344Sdfr release_fd_lock(ct->ct_fd, mask); 372181344Sdfr return (ct->ct_error.re_status); 373181344Sdfr } 374181344Sdfr } else { 375181344Sdfr *(uint32_t *) &ct->ct_u.ct_mcallc[ct->ct_mpos] = htonl(proc); 376181344Sdfr if (! __rpc_gss_wrap(cl->cl_auth, ct->ct_u.ct_mcallc, 377181344Sdfr ct->ct_mpos + sizeof(uint32_t), 378181344Sdfr xdrs, xdr_args, args_ptr)) { 379181344Sdfr if (ct->ct_error.re_status == RPC_SUCCESS) 380181344Sdfr ct->ct_error.re_status = RPC_CANTENCODEARGS; 381181344Sdfr (void)xdrrec_endofrecord(xdrs, TRUE); 382181344Sdfr release_fd_lock(ct->ct_fd, mask); 383181344Sdfr return (ct->ct_error.re_status); 384181344Sdfr } 38574462Salfred } 38674462Salfred if (! xdrrec_endofrecord(xdrs, shipnow)) { 38774462Salfred release_fd_lock(ct->ct_fd, mask); 38874462Salfred return (ct->ct_error.re_status = RPC_CANTSEND); 38974462Salfred } 39074462Salfred if (! shipnow) { 39174462Salfred release_fd_lock(ct->ct_fd, mask); 39274462Salfred return (RPC_SUCCESS); 39374462Salfred } 39474462Salfred /* 39574462Salfred * Hack to provide rpc-based message passing 39674462Salfred */ 39774462Salfred if (timeout.tv_sec == 0 && timeout.tv_usec == 0) { 39874462Salfred release_fd_lock(ct->ct_fd, mask); 39974462Salfred return(ct->ct_error.re_status = RPC_TIMEDOUT); 40074462Salfred } 40174462Salfred 40274462Salfred 40374462Salfred /* 40474462Salfred * Keep receiving until we get a valid transaction id 40574462Salfred */ 40674462Salfred xdrs->x_op = XDR_DECODE; 40774462Salfred while (TRUE) { 40874462Salfred reply_msg.acpted_rply.ar_verf = _null_auth; 40974462Salfred reply_msg.acpted_rply.ar_results.where = NULL; 41074462Salfred reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void; 41174462Salfred if (! xdrrec_skiprecord(xdrs)) { 41274462Salfred release_fd_lock(ct->ct_fd, mask); 41374462Salfred return (ct->ct_error.re_status); 41474462Salfred } 41574462Salfred /* now decode and validate the response header */ 41674462Salfred if (! xdr_replymsg(xdrs, &reply_msg)) { 41774462Salfred if (ct->ct_error.re_status == RPC_SUCCESS) 41874462Salfred continue; 41974462Salfred release_fd_lock(ct->ct_fd, mask); 42074462Salfred return (ct->ct_error.re_status); 42174462Salfred } 42274462Salfred if (reply_msg.rm_xid == x_id) 42374462Salfred break; 42474462Salfred } 42574462Salfred 42674462Salfred /* 42774462Salfred * process header 42874462Salfred */ 42974462Salfred _seterr_reply(&reply_msg, &(ct->ct_error)); 43074462Salfred if (ct->ct_error.re_status == RPC_SUCCESS) { 43174462Salfred if (! AUTH_VALIDATE(cl->cl_auth, 43274462Salfred &reply_msg.acpted_rply.ar_verf)) { 43374462Salfred ct->ct_error.re_status = RPC_AUTHERROR; 43474462Salfred ct->ct_error.re_why = AUTH_INVALIDRESP; 435181344Sdfr } else { 436181344Sdfr if (cl->cl_auth->ah_cred.oa_flavor != RPCSEC_GSS) { 437181344Sdfr reply_stat = (*xdr_results)(xdrs, results_ptr); 438181344Sdfr } else { 439181344Sdfr reply_stat = __rpc_gss_unwrap(cl->cl_auth, 440181344Sdfr xdrs, xdr_results, results_ptr); 441181344Sdfr } 442181344Sdfr if (! reply_stat) { 443181344Sdfr if (ct->ct_error.re_status == RPC_SUCCESS) 444181344Sdfr ct->ct_error.re_status = 445181344Sdfr RPC_CANTDECODERES; 446181344Sdfr } 44774462Salfred } 44874462Salfred /* free verifier ... */ 44974462Salfred if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) { 45074462Salfred xdrs->x_op = XDR_FREE; 45174462Salfred (void)xdr_opaque_auth(xdrs, 45274462Salfred &(reply_msg.acpted_rply.ar_verf)); 45374462Salfred } 45474462Salfred } /* end successful completion */ 45574462Salfred else { 45674462Salfred /* maybe our credentials need to be refreshed ... */ 45774462Salfred if (refreshes-- && AUTH_REFRESH(cl->cl_auth, &reply_msg)) 45874462Salfred goto call_again; 45974462Salfred } /* end of unsuccessful completion */ 46074462Salfred release_fd_lock(ct->ct_fd, mask); 46174462Salfred return (ct->ct_error.re_status); 46274462Salfred} 46374462Salfred 46474462Salfredstatic void 46574462Salfredclnt_vc_geterr(cl, errp) 46674462Salfred CLIENT *cl; 46774462Salfred struct rpc_err *errp; 46874462Salfred{ 46974462Salfred struct ct_data *ct; 47074462Salfred 47174462Salfred assert(cl != NULL); 47274462Salfred assert(errp != NULL); 47374462Salfred 47474462Salfred ct = (struct ct_data *) cl->cl_private; 47574462Salfred *errp = ct->ct_error; 47674462Salfred} 47774462Salfred 47874462Salfredstatic bool_t 47974462Salfredclnt_vc_freeres(cl, xdr_res, res_ptr) 48074462Salfred CLIENT *cl; 48174462Salfred xdrproc_t xdr_res; 48295658Sdes void *res_ptr; 48374462Salfred{ 48474462Salfred struct ct_data *ct; 48574462Salfred XDR *xdrs; 48674462Salfred bool_t dummy; 48774462Salfred sigset_t mask; 48874462Salfred sigset_t newmask; 48974462Salfred 49074462Salfred assert(cl != NULL); 49174462Salfred 49274462Salfred ct = (struct ct_data *)cl->cl_private; 49374462Salfred xdrs = &(ct->ct_xdrs); 49474462Salfred 49574462Salfred sigfillset(&newmask); 49674462Salfred thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 49774462Salfred mutex_lock(&clnt_fd_lock); 49874462Salfred while (vc_fd_locks[ct->ct_fd]) 49974462Salfred cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock); 50074462Salfred xdrs->x_op = XDR_FREE; 50174462Salfred dummy = (*xdr_res)(xdrs, res_ptr); 50274462Salfred mutex_unlock(&clnt_fd_lock); 50374462Salfred thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 50474462Salfred cond_signal(&vc_cv[ct->ct_fd]); 50574462Salfred 50674462Salfred return dummy; 50774462Salfred} 50874462Salfred 50974462Salfred/*ARGSUSED*/ 51074462Salfredstatic void 51174462Salfredclnt_vc_abort(cl) 51274462Salfred CLIENT *cl; 51374462Salfred{ 51474462Salfred} 51574462Salfred 51674462Salfredstatic bool_t 51774462Salfredclnt_vc_control(cl, request, info) 51874462Salfred CLIENT *cl; 51974462Salfred u_int request; 52099996Salfred void *info; 52174462Salfred{ 52274462Salfred struct ct_data *ct; 52374462Salfred void *infop = info; 52474462Salfred sigset_t mask; 52574462Salfred sigset_t newmask; 52674462Salfred int rpc_lock_value; 52774462Salfred 52874462Salfred assert(cl != NULL); 52974462Salfred 53074462Salfred ct = (struct ct_data *)cl->cl_private; 53174462Salfred 53274462Salfred sigfillset(&newmask); 53374462Salfred thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 53474462Salfred mutex_lock(&clnt_fd_lock); 53574462Salfred while (vc_fd_locks[ct->ct_fd]) 53674462Salfred cond_wait(&vc_cv[ct->ct_fd], &clnt_fd_lock); 53774462Salfred if (__isthreaded) 53874462Salfred rpc_lock_value = 1; 53974462Salfred else 54074462Salfred rpc_lock_value = 0; 54174462Salfred vc_fd_locks[ct->ct_fd] = rpc_lock_value; 54274462Salfred mutex_unlock(&clnt_fd_lock); 54374462Salfred 54474462Salfred switch (request) { 54574462Salfred case CLSET_FD_CLOSE: 54674462Salfred ct->ct_closeit = TRUE; 54774462Salfred release_fd_lock(ct->ct_fd, mask); 54874462Salfred return (TRUE); 54974462Salfred case CLSET_FD_NCLOSE: 55074462Salfred ct->ct_closeit = FALSE; 55174462Salfred release_fd_lock(ct->ct_fd, mask); 55274462Salfred return (TRUE); 55374462Salfred default: 55474462Salfred break; 55574462Salfred } 55674462Salfred 55774462Salfred /* for other requests which use info */ 55874462Salfred if (info == NULL) { 55974462Salfred release_fd_lock(ct->ct_fd, mask); 56074462Salfred return (FALSE); 56174462Salfred } 56274462Salfred switch (request) { 56374462Salfred case CLSET_TIMEOUT: 56499996Salfred if (time_not_ok((struct timeval *)info)) { 56574462Salfred release_fd_lock(ct->ct_fd, mask); 56674462Salfred return (FALSE); 56774462Salfred } 56874462Salfred ct->ct_wait = *(struct timeval *)infop; 56974462Salfred ct->ct_waitset = TRUE; 57074462Salfred break; 57174462Salfred case CLGET_TIMEOUT: 57274462Salfred *(struct timeval *)infop = ct->ct_wait; 57374462Salfred break; 57474462Salfred case CLGET_SERVER_ADDR: 57574462Salfred (void) memcpy(info, ct->ct_addr.buf, (size_t)ct->ct_addr.len); 57674462Salfred break; 57774462Salfred case CLGET_FD: 57899996Salfred *(int *)info = ct->ct_fd; 57974462Salfred break; 58074462Salfred case CLGET_SVC_ADDR: 58174462Salfred /* The caller should not free this memory area */ 58299996Salfred *(struct netbuf *)info = ct->ct_addr; 58374462Salfred break; 58474462Salfred case CLSET_SVC_ADDR: /* set to new address */ 58574462Salfred release_fd_lock(ct->ct_fd, mask); 58674462Salfred return (FALSE); 58774462Salfred case CLGET_XID: 58874462Salfred /* 58974462Salfred * use the knowledge that xid is the 59074462Salfred * first element in the call structure 59174462Salfred * This will get the xid of the PREVIOUS call 59274462Salfred */ 59399996Salfred *(u_int32_t *)info = 59474462Salfred ntohl(*(u_int32_t *)(void *)&ct->ct_u.ct_mcalli); 59574462Salfred break; 59674462Salfred case CLSET_XID: 59774462Salfred /* This will set the xid of the NEXT call */ 59874462Salfred *(u_int32_t *)(void *)&ct->ct_u.ct_mcalli = 59999996Salfred htonl(*((u_int32_t *)info) + 1); 60074462Salfred /* increment by 1 as clnt_vc_call() decrements once */ 60174462Salfred break; 60274462Salfred case CLGET_VERS: 60374462Salfred /* 60474462Salfred * This RELIES on the information that, in the call body, 60574462Salfred * the version number field is the fifth field from the 60674462Salfred * begining of the RPC header. MUST be changed if the 60774462Salfred * call_struct is changed 60874462Salfred */ 60999996Salfred *(u_int32_t *)info = 61074462Salfred ntohl(*(u_int32_t *)(void *)(ct->ct_u.ct_mcallc + 61174462Salfred 4 * BYTES_PER_XDR_UNIT)); 61274462Salfred break; 61374462Salfred 61474462Salfred case CLSET_VERS: 61574462Salfred *(u_int32_t *)(void *)(ct->ct_u.ct_mcallc + 61674462Salfred 4 * BYTES_PER_XDR_UNIT) = 61799996Salfred htonl(*(u_int32_t *)info); 61874462Salfred break; 61974462Salfred 62074462Salfred case CLGET_PROG: 62174462Salfred /* 62274462Salfred * This RELIES on the information that, in the call body, 62374462Salfred * the program number field is the fourth field from the 62474462Salfred * begining of the RPC header. MUST be changed if the 62574462Salfred * call_struct is changed 62674462Salfred */ 62799996Salfred *(u_int32_t *)info = 62874462Salfred ntohl(*(u_int32_t *)(void *)(ct->ct_u.ct_mcallc + 62974462Salfred 3 * BYTES_PER_XDR_UNIT)); 63074462Salfred break; 63174462Salfred 63274462Salfred case CLSET_PROG: 63374462Salfred *(u_int32_t *)(void *)(ct->ct_u.ct_mcallc + 63474462Salfred 3 * BYTES_PER_XDR_UNIT) = 63599996Salfred htonl(*(u_int32_t *)info); 63674462Salfred break; 63774462Salfred 63874462Salfred default: 63974462Salfred release_fd_lock(ct->ct_fd, mask); 64074462Salfred return (FALSE); 64174462Salfred } 64274462Salfred release_fd_lock(ct->ct_fd, mask); 64374462Salfred return (TRUE); 64474462Salfred} 64574462Salfred 64674462Salfred 64774462Salfredstatic void 64874462Salfredclnt_vc_destroy(cl) 64974462Salfred CLIENT *cl; 65074462Salfred{ 65174462Salfred struct ct_data *ct = (struct ct_data *) cl->cl_private; 65274462Salfred int ct_fd = ct->ct_fd; 65374462Salfred sigset_t mask; 65474462Salfred sigset_t newmask; 65574462Salfred 65674462Salfred assert(cl != NULL); 65774462Salfred 65874462Salfred ct = (struct ct_data *) cl->cl_private; 65974462Salfred 66074462Salfred sigfillset(&newmask); 66174462Salfred thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 66274462Salfred mutex_lock(&clnt_fd_lock); 66374462Salfred while (vc_fd_locks[ct_fd]) 66474462Salfred cond_wait(&vc_cv[ct_fd], &clnt_fd_lock); 66574462Salfred if (ct->ct_closeit && ct->ct_fd != -1) { 66674462Salfred (void)_close(ct->ct_fd); 66774462Salfred } 66874462Salfred XDR_DESTROY(&(ct->ct_xdrs)); 66974462Salfred if (ct->ct_addr.buf) 67074462Salfred free(ct->ct_addr.buf); 67174462Salfred mem_free(ct, sizeof(struct ct_data)); 672241601Spfg if (cl->cl_netid && cl->cl_netid[0]) 673241601Spfg mem_free(cl->cl_netid, strlen(cl->cl_netid) +1); 674241601Spfg if (cl->cl_tp && cl->cl_tp[0]) 675241601Spfg mem_free(cl->cl_tp, strlen(cl->cl_tp) +1); 67674462Salfred mem_free(cl, sizeof(CLIENT)); 67774462Salfred mutex_unlock(&clnt_fd_lock); 67874462Salfred thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 67974462Salfred cond_signal(&vc_cv[ct_fd]); 68074462Salfred} 68174462Salfred 68274462Salfred/* 68374462Salfred * Interface between xdr serializer and tcp connection. 68474462Salfred * Behaves like the system calls, read & write, but keeps some error state 68574462Salfred * around for the rpc level. 68674462Salfred */ 68774462Salfredstatic int 68874462Salfredread_vc(ctp, buf, len) 68995658Sdes void *ctp; 69095658Sdes void *buf; 69174462Salfred int len; 69274462Salfred{ 69374462Salfred struct sockaddr sa; 69474462Salfred socklen_t sal; 69595658Sdes struct ct_data *ct = (struct ct_data *)ctp; 69674462Salfred struct pollfd fd; 69774462Salfred int milliseconds = (int)((ct->ct_wait.tv_sec * 1000) + 69874462Salfred (ct->ct_wait.tv_usec / 1000)); 69974462Salfred 70074462Salfred if (len == 0) 70174462Salfred return (0); 70274462Salfred fd.fd = ct->ct_fd; 70374462Salfred fd.events = POLLIN; 70474462Salfred for (;;) { 70574462Salfred switch (_poll(&fd, 1, milliseconds)) { 70674462Salfred case 0: 70774462Salfred ct->ct_error.re_status = RPC_TIMEDOUT; 70874462Salfred return (-1); 70974462Salfred 71074462Salfred case -1: 71174462Salfred if (errno == EINTR) 71274462Salfred continue; 71374462Salfred ct->ct_error.re_status = RPC_CANTRECV; 71474462Salfred ct->ct_error.re_errno = errno; 71574462Salfred return (-1); 71674462Salfred } 71774462Salfred break; 71874462Salfred } 71974462Salfred 72074462Salfred sal = sizeof(sa); 72174462Salfred if ((_getpeername(ct->ct_fd, &sa, &sal) == 0) && 72274462Salfred (sa.sa_family == AF_LOCAL)) { 72374462Salfred len = __msgread(ct->ct_fd, buf, (size_t)len); 72474462Salfred } else { 72574462Salfred len = _read(ct->ct_fd, buf, (size_t)len); 72674462Salfred } 72774462Salfred 72874462Salfred switch (len) { 72974462Salfred case 0: 73074462Salfred /* premature eof */ 73174462Salfred ct->ct_error.re_errno = ECONNRESET; 73274462Salfred ct->ct_error.re_status = RPC_CANTRECV; 73374462Salfred len = -1; /* it's really an error */ 73474462Salfred break; 73574462Salfred 73674462Salfred case -1: 73774462Salfred ct->ct_error.re_errno = errno; 73874462Salfred ct->ct_error.re_status = RPC_CANTRECV; 73974462Salfred break; 74074462Salfred } 74174462Salfred return (len); 74274462Salfred} 74374462Salfred 74474462Salfredstatic int 74574462Salfredwrite_vc(ctp, buf, len) 74695658Sdes void *ctp; 74795658Sdes void *buf; 74874462Salfred int len; 74974462Salfred{ 75074462Salfred struct sockaddr sa; 75174462Salfred socklen_t sal; 75295658Sdes struct ct_data *ct = (struct ct_data *)ctp; 75374462Salfred int i, cnt; 75474462Salfred 75574462Salfred sal = sizeof(sa); 75674462Salfred if ((_getpeername(ct->ct_fd, &sa, &sal) == 0) && 75774462Salfred (sa.sa_family == AF_LOCAL)) { 758143347Sstefanf for (cnt = len; cnt > 0; cnt -= i, buf = (char *)buf + i) { 75974462Salfred if ((i = __msgwrite(ct->ct_fd, buf, 76074462Salfred (size_t)cnt)) == -1) { 76174462Salfred ct->ct_error.re_errno = errno; 76274462Salfred ct->ct_error.re_status = RPC_CANTSEND; 76374462Salfred return (-1); 76474462Salfred } 76574462Salfred } 76674462Salfred } else { 767133693Sstefanf for (cnt = len; cnt > 0; cnt -= i, buf = (char *)buf + i) { 76874462Salfred if ((i = _write(ct->ct_fd, buf, (size_t)cnt)) == -1) { 76974462Salfred ct->ct_error.re_errno = errno; 77074462Salfred ct->ct_error.re_status = RPC_CANTSEND; 77174462Salfred return (-1); 77274462Salfred } 77374462Salfred } 77474462Salfred } 77574462Salfred return (len); 77674462Salfred} 77774462Salfred 77874462Salfredstatic struct clnt_ops * 77974462Salfredclnt_vc_ops() 78074462Salfred{ 78174462Salfred static struct clnt_ops ops; 78274462Salfred sigset_t mask, newmask; 78374462Salfred 78474462Salfred /* VARIABLES PROTECTED BY ops_lock: ops */ 78574462Salfred 78674462Salfred sigfillset(&newmask); 78774462Salfred thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 78874462Salfred mutex_lock(&ops_lock); 78974462Salfred if (ops.cl_call == NULL) { 79074462Salfred ops.cl_call = clnt_vc_call; 79174462Salfred ops.cl_abort = clnt_vc_abort; 79274462Salfred ops.cl_geterr = clnt_vc_geterr; 79374462Salfred ops.cl_freeres = clnt_vc_freeres; 79474462Salfred ops.cl_destroy = clnt_vc_destroy; 79574462Salfred ops.cl_control = clnt_vc_control; 79674462Salfred } 79774462Salfred mutex_unlock(&ops_lock); 79874462Salfred thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 79974462Salfred return (&ops); 80074462Salfred} 80174462Salfred 80274462Salfred/* 80374462Salfred * Make sure that the time is not garbage. -1 value is disallowed. 80474462Salfred * Note this is different from time_not_ok in clnt_dg.c 80574462Salfred */ 80674462Salfredstatic bool_t 80774462Salfredtime_not_ok(t) 80874462Salfred struct timeval *t; 80974462Salfred{ 81074462Salfred return (t->tv_sec <= -1 || t->tv_sec > 100000000 || 81174462Salfred t->tv_usec <= -1 || t->tv_usec > 1000000); 81274462Salfred} 81374462Salfred 81474627Salfredstatic int 81574462Salfred__msgread(sock, buf, cnt) 81674462Salfred int sock; 81774462Salfred void *buf; 81874462Salfred size_t cnt; 81974462Salfred{ 82074462Salfred struct iovec iov[1]; 82174462Salfred struct msghdr msg; 82284472Sdwmalone union { 82384472Sdwmalone struct cmsghdr cmsg; 82484472Sdwmalone char control[CMSG_SPACE(sizeof(struct cmsgcred))]; 82584472Sdwmalone } cm; 82674462Salfred 82774462Salfred bzero((char *)&cm, sizeof(cm)); 82874462Salfred iov[0].iov_base = buf; 82974462Salfred iov[0].iov_len = cnt; 83074462Salfred 83174462Salfred msg.msg_iov = iov; 83274462Salfred msg.msg_iovlen = 1; 83374462Salfred msg.msg_name = NULL; 83474462Salfred msg.msg_namelen = 0; 83574462Salfred msg.msg_control = (caddr_t)&cm; 83684472Sdwmalone msg.msg_controllen = CMSG_SPACE(sizeof(struct cmsgcred)); 83774462Salfred msg.msg_flags = 0; 83874462Salfred 83974462Salfred return(_recvmsg(sock, &msg, 0)); 84074462Salfred} 84174627Salfred 84274462Salfredstatic int 84374462Salfred__msgwrite(sock, buf, cnt) 84474462Salfred int sock; 84574462Salfred void *buf; 84674462Salfred size_t cnt; 84774462Salfred{ 84874462Salfred struct iovec iov[1]; 84974462Salfred struct msghdr msg; 85084472Sdwmalone union { 85184472Sdwmalone struct cmsghdr cmsg; 85284472Sdwmalone char control[CMSG_SPACE(sizeof(struct cmsgcred))]; 85384472Sdwmalone } cm; 85474462Salfred 85574462Salfred bzero((char *)&cm, sizeof(cm)); 85674462Salfred iov[0].iov_base = buf; 85774462Salfred iov[0].iov_len = cnt; 85874462Salfred 85974462Salfred cm.cmsg.cmsg_type = SCM_CREDS; 86074462Salfred cm.cmsg.cmsg_level = SOL_SOCKET; 86184472Sdwmalone cm.cmsg.cmsg_len = CMSG_LEN(sizeof(struct cmsgcred)); 86274462Salfred 86374462Salfred msg.msg_iov = iov; 86474462Salfred msg.msg_iovlen = 1; 86574462Salfred msg.msg_name = NULL; 86674462Salfred msg.msg_namelen = 0; 86774462Salfred msg.msg_control = (caddr_t)&cm; 86884472Sdwmalone msg.msg_controllen = CMSG_SPACE(sizeof(struct cmsgcred)); 86974462Salfred msg.msg_flags = 0; 87074462Salfred 87174462Salfred return(_sendmsg(sock, &msg, 0)); 87274462Salfred} 873