Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/rpc/clnt_udp.c	Lines:	0	166	0.0 %
Date:	2017-11-07	Branches:	0	101	0.0 %


/*	$OpenBSD: clnt_udp.c,v 1.32 2015/11/01 03:45:29 guenther Exp $ */

/*
 * Copyright (c) 2010, Oracle America, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *     * Neither the name of the "Oracle America, Inc." nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * clnt_udp.c, Implements a UDP/IP based, client side RPC.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <rpc/rpc.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#include <rpc/pmap_clnt.h>

/*
 * UDP bases client side rpc operations
 */
static enum clnt_stat	clntudp_call(CLIENT *, u_long, xdrproc_t, caddr_t,
			    xdrproc_t, caddr_t, struct timeval);
static void		clntudp_abort(CLIENT *);
static void		clntudp_geterr(CLIENT *, struct rpc_err *);
static bool_t		clntudp_freeres(CLIENT *, xdrproc_t, caddr_t);
static bool_t           clntudp_control(CLIENT *, u_int, void *);
static void		clntudp_destroy(CLIENT *);

static struct clnt_ops udp_ops = {
	clntudp_call,
	clntudp_abort,
	clntudp_geterr,
	clntudp_freeres,
	clntudp_destroy,
	clntudp_control
};

/*
 * Private data kept per client handle
 */
struct cu_data {
	int		   cu_sock;
	bool_t		   cu_closeit;
	struct sockaddr_in cu_raddr;
	int		   cu_rlen;
	struct timeval	   cu_wait;
	struct timeval     cu_total;
	struct rpc_err	   cu_error;
	XDR		   cu_outxdrs;
	u_int		   cu_xdrpos;
	u_int		   cu_sendsz;
	char		   *cu_outbuf;
	u_int		   cu_recvsz;
	char		   cu_inbuf[1];
};

/*
 * Create a UDP based client handle.
 * If *sockp<0, *sockp is set to a newly created UPD socket.
 * If raddr->sin_port is 0 a binder on the remote machine
 * is consulted for the correct port number.
 * NB: It is the client's responsibility to close *sockp, unless
 *	clntudp_bufcreate() was called with *sockp = -1 (so it created
 *	the socket), and CLNT_DESTROY() is used.
 * NB: The rpch->cl_auth is initialized to null authentication.
 *     Caller may wish to set this something more useful.
 *
 * wait is the amount of time used between retransmitting a call if
 * no response has been heard;  retransmission occurs until the actual
 * rpc call times out.
 *
 * sendsz and recvsz are the maximum allowable packet sizes that can be
 * sent and received.
 */
CLIENT *
clntudp_bufcreate(struct sockaddr_in *raddr, u_long program, u_long version,
    struct timeval wait, int *sockp, u_int sendsz, u_int recvsz)
{
	CLIENT *cl;
	struct cu_data *cu = NULL;
	struct timeval now;
	struct rpc_msg call_msg;

	cl = (CLIENT *)mem_alloc(sizeof(CLIENT));
	if (cl == NULL) {
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		rpc_createerr.cf_error.re_errno = errno;
		goto fooy;
	}
	sendsz = ((sendsz + 3) / 4) * 4;
	recvsz = ((recvsz + 3) / 4) * 4;
	cu = (struct cu_data *)mem_alloc(sizeof(*cu) + sendsz + recvsz);
	if (cu == NULL) {
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		rpc_createerr.cf_error.re_errno = errno;
		goto fooy;
	}
	cu->cu_outbuf = &cu->cu_inbuf[recvsz];

	(void)gettimeofday(&now, NULL);
	if (raddr->sin_port == 0) {
		u_short port;
		if ((port =
		    pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) {
			goto fooy;
		}
		raddr->sin_port = htons(port);
	}
	cl->cl_ops = &udp_ops;
	cl->cl_private = (caddr_t)cu;
	cu->cu_raddr = *raddr;
	cu->cu_rlen = sizeof (cu->cu_raddr);
	cu->cu_wait = wait;
	cu->cu_total.tv_sec = -1;
	cu->cu_total.tv_usec = -1;
	cu->cu_sendsz = sendsz;
	cu->cu_recvsz = recvsz;
	call_msg.rm_xid = arc4random();
	call_msg.rm_direction = CALL;
	call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
	call_msg.rm_call.cb_prog = program;
	call_msg.rm_call.cb_vers = version;
	xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf,
	    sendsz, XDR_ENCODE);
	if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
		goto fooy;
	}
	cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
	if (*sockp < 0) {
		*sockp = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK,
		    IPPROTO_UDP);
		if (*sockp < 0) {
			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
			rpc_createerr.cf_error.re_errno = errno;
			goto fooy;
		}
		/* attempt to bind to priv port */
		(void)bindresvport(*sockp, NULL);
		cu->cu_closeit = TRUE;
	} else {
		cu->cu_closeit = FALSE;
	}
	cu->cu_sock = *sockp;
	cl->cl_auth = authnone_create();
	if (cl->cl_auth == NULL) {
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		rpc_createerr.cf_error.re_errno = errno;
		goto fooy;
	}
	return (cl);
fooy:
	if (cu)
		mem_free((caddr_t)cu, sizeof(*cu) + sendsz + recvsz);
	if (cl)
		mem_free((caddr_t)cl, sizeof(CLIENT));
	return (NULL);
}
DEF_WEAK(clntudp_bufcreate);

CLIENT *
clntudp_create(struct sockaddr_in *raddr, u_long program, u_long version,
    struct timeval wait, int *sockp)
{

	return(clntudp_bufcreate(raddr, program, version, wait, sockp,
	    UDPMSGSIZE, UDPMSGSIZE));
}
DEF_WEAK(clntudp_create);

static enum clnt_stat
clntudp_call(CLIENT *cl,	/* client handle */
    u_long proc,		/* procedure number */
    xdrproc_t xargs,		/* xdr routine for args */
    caddr_t argsp,		/* pointer to args */
    xdrproc_t xresults,		/* xdr routine for results */
    caddr_t resultsp,		/* pointer to results */
    struct timeval utimeout)	/* seconds to wait before giving up */
{
	struct cu_data *cu = (struct cu_data *)cl->cl_private;
	XDR *xdrs;
	int outlen;
	int inlen;
	socklen_t fromlen;
	struct pollfd pfd[1];
	struct sockaddr_in from;
	struct rpc_msg reply_msg;
	XDR reply_xdrs;
	struct timeval time_waited, start, after, tmp1, tmp2;
	bool_t ok;
	int nrefreshes = 2;	/* number of times to refresh cred */
	struct timeval timeout;

	if (cu->cu_total.tv_usec == -1)
		timeout = utimeout;     /* use supplied timeout */
	else
		timeout = cu->cu_total; /* use default timeout */

	pfd[0].fd = cu->cu_sock;
	pfd[0].events = POLLIN;
	timerclear(&time_waited);
call_again:
	xdrs = &(cu->cu_outxdrs);
	xdrs->x_op = XDR_ENCODE;
	XDR_SETPOS(xdrs, cu->cu_xdrpos);
	/*
	 * the transaction is the first thing in the out buffer
	 */
	(*(u_short *)(cu->cu_outbuf))++;
	if (!XDR_PUTLONG(xdrs, (long *)&proc) ||
	    !AUTH_MARSHALL(cl->cl_auth, xdrs) ||
	    !(*xargs)(xdrs, argsp)) {
		return (cu->cu_error.re_status = RPC_CANTENCODEARGS);
	}
	outlen = (int)XDR_GETPOS(xdrs);

send_again:
	if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0,
	    (struct sockaddr *)&(cu->cu_raddr), cu->cu_rlen) != outlen) {
		cu->cu_error.re_errno = errno;
		return (cu->cu_error.re_status = RPC_CANTSEND);
	}

	/*
	 * Hack to provide rpc-based message passing
	 */
	if (!timerisset(&timeout))
		return (cu->cu_error.re_status = RPC_TIMEDOUT);

	/*
	 * sub-optimal code appears here because we have
	 * some clock time to spare while the packets are in flight.
	 * (We assume that this is actually only executed once.)
	 */
	reply_msg.acpted_rply.ar_verf = _null_auth;
	reply_msg.acpted_rply.ar_results.where = resultsp;
	reply_msg.acpted_rply.ar_results.proc = xresults;

	gettimeofday(&start, NULL);
	for (;;) {
		switch (poll(pfd, 1,
		    cu->cu_wait.tv_sec * 1000 + cu->cu_wait.tv_usec / 1000)) {
		case 0:
			timeradd(&time_waited, &cu->cu_wait, &tmp1);
			time_waited = tmp1;
			if (timercmp(&time_waited, &timeout, <))
				goto send_again;
			return (cu->cu_error.re_status = RPC_TIMEDOUT);
		case 1:
			if (pfd[0].revents & POLLNVAL)
				errno = EBADF;
			else if (pfd[0].revents & POLLERR)
				errno = EIO;
			else
				break;
			/* FALLTHROUGH */
		case -1:
			if (errno == EINTR) {
				gettimeofday(&after, NULL);
				timersub(&after, &start, &tmp1);
				timeradd(&time_waited, &tmp1, &tmp2);
				time_waited = tmp2;
				if (timercmp(&time_waited, &timeout, <))
					continue;
				return (cu->cu_error.re_status = RPC_TIMEDOUT);
			}
			cu->cu_error.re_errno = errno;
			return (cu->cu_error.re_status = RPC_CANTRECV);
		}

		do {
			fromlen = sizeof(struct sockaddr);
			inlen = recvfrom(cu->cu_sock, cu->cu_inbuf,
			    (int) cu->cu_recvsz, 0,
			    (struct sockaddr *)&from, &fromlen);
		} while (inlen < 0 && errno == EINTR);
		if (inlen < 0) {
			if (errno == EWOULDBLOCK)
				continue;
			cu->cu_error.re_errno = errno;
			return (cu->cu_error.re_status = RPC_CANTRECV);
		}
		if (inlen < sizeof(u_int32_t))
			continue;
		/* see if reply transaction id matches sent id */
		if (((struct rpc_msg *)(cu->cu_inbuf))->rm_xid !=
		    ((struct rpc_msg *)(cu->cu_outbuf))->rm_xid)
			continue;
		/* we now assume we have the proper reply */
		break;
	}

	/*
	 * now decode and validate the response
	 */
	xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE);
	ok = xdr_replymsg(&reply_xdrs, &reply_msg);
	/* XDR_DESTROY(&reply_xdrs);  save a few cycles on noop destroy */
	if (ok) {
#if 0
		/*
		 * XXX Would like to check these, but call_msg is not
		 * around.
		 */
		if (reply_msg.rm_call.cb_prog != call_msg.rm_call.cb_prog ||
		    reply_msg.rm_call.cb_vers != call_msg.rm_call.cb_vers ||
		    reply_msg.rm_call.cb_proc != call_msg.rm_call.cb_proc) {
			goto call_again;	/* XXX spin? */
		}
#endif

		_seterr_reply(&reply_msg, &(cu->cu_error));
		if (cu->cu_error.re_status == RPC_SUCCESS) {
			if (!AUTH_VALIDATE(cl->cl_auth,
			    &reply_msg.acpted_rply.ar_verf)) {
				cu->cu_error.re_status = RPC_AUTHERROR;
				cu->cu_error.re_why = AUTH_INVALIDRESP;
			}
			if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
				xdrs->x_op = XDR_FREE;
				(void)xdr_opaque_auth(xdrs,
				    &(reply_msg.acpted_rply.ar_verf));
			}
		} else {
			/* maybe our credentials need to be refreshed ... */
			if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth)) {
				nrefreshes--;
				goto call_again;
			}
		}
	} else {
		/* xdr_replymsg() may have left some things allocated */
		int op = reply_xdrs.x_op;
		reply_xdrs.x_op = XDR_FREE;
		xdr_replymsg(&reply_xdrs, &reply_msg);
		reply_xdrs.x_op = op;
		cu->cu_error.re_status = RPC_CANTDECODERES;
	}

	return (cu->cu_error.re_status);
}

static void
clntudp_geterr(CLIENT *cl, struct rpc_err *errp)
{
	struct cu_data *cu = (struct cu_data *)cl->cl_private;

	*errp = cu->cu_error;
}


static bool_t
clntudp_freeres(CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
{
	struct cu_data *cu = (struct cu_data *)cl->cl_private;
	XDR *xdrs = &(cu->cu_outxdrs);

	xdrs->x_op = XDR_FREE;
	return ((*xdr_res)(xdrs, res_ptr));
}

static void
clntudp_abort(CLIENT *clnt)
{
}

static bool_t
clntudp_control(CLIENT *cl, u_int request, void *info)
{
	struct cu_data *cu = (struct cu_data *)cl->cl_private;

	switch (request) {
	case CLSET_TIMEOUT:
		cu->cu_total = *(struct timeval *)info;
		break;
	case CLGET_TIMEOUT:
		*(struct timeval *)info = cu->cu_total;
		break;
	case CLSET_RETRY_TIMEOUT:
		cu->cu_wait = *(struct timeval *)info;
		break;
	case CLGET_RETRY_TIMEOUT:
		*(struct timeval *)info = cu->cu_wait;
		break;
	case CLGET_SERVER_ADDR:
		*(struct sockaddr_in *)info = cu->cu_raddr;
		break;
	default:
		return (FALSE);
	}
	return (TRUE);
}

static void
clntudp_destroy(CLIENT *cl)
{
	struct cu_data *cu = (struct cu_data *)cl->cl_private;

	if (cu->cu_closeit && cu->cu_sock != -1) {
		(void)close(cu->cu_sock);
	}
	XDR_DESTROY(&(cu->cu_outxdrs));
	mem_free((caddr_t)cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz));
	mem_free((caddr_t)cl, sizeof(CLIENT));
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: clnt_udp.c,v 1.32 2015/11/01 03:45:29 guenther Exp $ */
2
3			/*
4			* Copyright (c) 2010, Oracle America, Inc.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions are
8			* met:
9			*
10			* * Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* * Redistributions in binary form must reproduce the above
13			* copyright notice, this list of conditions and the following
14			* disclaimer in the documentation and/or other materials
15			* provided with the distribution.
16			* * Neither the name of the "Oracle America, Inc." nor the names of its
17			* contributors may be used to endorse or promote products derived
18			* from this software without specific prior written permission.
19			*
20			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23			* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24			* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
25			* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
27			* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28			* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29			* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30			* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31			* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32			*/
33
34			/*
35			* clnt_udp.c, Implements a UDP/IP based, client side RPC.
36			*/
37
38			#include <stdio.h>
39			#include <stdlib.h>
40			#include <string.h>
41			#include <unistd.h>
42			#include <fcntl.h>
43			#include <rpc/rpc.h>
44			#include <sys/socket.h>
45			#include <netdb.h>
46			#include <errno.h>
47			#include <rpc/pmap_clnt.h>
48
49			/*
50			* UDP bases client side rpc operations
51			*/
52			static enum clnt_stat clntudp_call(CLIENT *, u_long, xdrproc_t, caddr_t,
53			xdrproc_t, caddr_t, struct timeval);
54			static void clntudp_abort(CLIENT *);
55			static void clntudp_geterr(CLIENT , struct rpc_err );
56			static bool_t clntudp_freeres(CLIENT *, xdrproc_t, caddr_t);
57			static bool_t clntudp_control(CLIENT , u_int, void );
58			static void clntudp_destroy(CLIENT *);
59
60			static struct clnt_ops udp_ops = {
61			clntudp_call,
62			clntudp_abort,
63			clntudp_geterr,
64			clntudp_freeres,
65			clntudp_destroy,
66			clntudp_control
67			};
68
69			/*
70			* Private data kept per client handle
71			*/
72			struct cu_data {
73			int cu_sock;
74			bool_t cu_closeit;
75			struct sockaddr_in cu_raddr;
76			int cu_rlen;
77			struct timeval cu_wait;
78			struct timeval cu_total;
79			struct rpc_err cu_error;
80			XDR cu_outxdrs;
81			u_int cu_xdrpos;
82			u_int cu_sendsz;
83			char *cu_outbuf;
84			u_int cu_recvsz;
85			char cu_inbuf[1];
86			};
87
88			/*
89			* Create a UDP based client handle.
90			* If sockp<0, sockp is set to a newly created UPD socket.
91			* If raddr->sin_port is 0 a binder on the remote machine
92			* is consulted for the correct port number.
93			* NB: It is the client's responsibility to close *sockp, unless
94			* clntudp_bufcreate() was called with *sockp = -1 (so it created
95			* the socket), and CLNT_DESTROY() is used.
96			* NB: The rpch->cl_auth is initialized to null authentication.
97			* Caller may wish to set this something more useful.
98			*
99			* wait is the amount of time used between retransmitting a call if
100			* no response has been heard; retransmission occurs until the actual
101			* rpc call times out.
102			*
103			* sendsz and recvsz are the maximum allowable packet sizes that can be
104			* sent and received.
105			*/
106			CLIENT *
107			clntudp_bufcreate(struct sockaddr_in *raddr, u_long program, u_long version,
108			struct timeval wait, int *sockp, u_int sendsz, u_int recvsz)
109			{
110			CLIENT *cl;
111			struct cu_data *cu = NULL;
112			struct timeval now;
113			struct rpc_msg call_msg;
114
115			cl = (CLIENT *)mem_alloc(sizeof(CLIENT));
116			if (cl == NULL) {
117			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
118			rpc_createerr.cf_error.re_errno = errno;
119			goto fooy;
120			}
121			sendsz = ((sendsz + 3) / 4) * 4;
122			recvsz = ((recvsz + 3) / 4) * 4;
123			cu = (struct cu_data )mem_alloc(sizeof(cu) + sendsz + recvsz);
124			if (cu == NULL) {
125			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
126			rpc_createerr.cf_error.re_errno = errno;
127			goto fooy;
128			}
129			cu->cu_outbuf = &cu->cu_inbuf[recvsz];
130
131			(void)gettimeofday(&now, NULL);
132			if (raddr->sin_port == 0) {
133			u_short port;
134			if ((port =
135			pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) {
136			goto fooy;
137			}
138			raddr->sin_port = htons(port);
139			}
140			cl->cl_ops = &udp_ops;
141			cl->cl_private = (caddr_t)cu;
142			cu->cu_raddr = *raddr;
143			cu->cu_rlen = sizeof (cu->cu_raddr);
144			cu->cu_wait = wait;
145			cu->cu_total.tv_sec = -1;
146			cu->cu_total.tv_usec = -1;
147			cu->cu_sendsz = sendsz;
148			cu->cu_recvsz = recvsz;
149			call_msg.rm_xid = arc4random();
150			call_msg.rm_direction = CALL;
151			call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
152			call_msg.rm_call.cb_prog = program;
153			call_msg.rm_call.cb_vers = version;
154			xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf,
155			sendsz, XDR_ENCODE);
156			if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
157			goto fooy;
158			}
159			cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
160			if (*sockp < 0) {
161			*sockp = socket(AF_INET, SOCK_DGRAM \| SOCK_NONBLOCK,
162			IPPROTO_UDP);
163			if (*sockp < 0) {
164			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
165			rpc_createerr.cf_error.re_errno = errno;
166			goto fooy;
167			}
168			/* attempt to bind to priv port */
169			(void)bindresvport(*sockp, NULL);
170			cu->cu_closeit = TRUE;
171			} else {
172			cu->cu_closeit = FALSE;
173			}
174			cu->cu_sock = *sockp;
175			cl->cl_auth = authnone_create();
176			if (cl->cl_auth == NULL) {
177			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
178			rpc_createerr.cf_error.re_errno = errno;
179			goto fooy;
180			}
181			return (cl);
182			fooy:
183			if (cu)
184			mem_free((caddr_t)cu, sizeof(*cu) + sendsz + recvsz);
185			if (cl)
186			mem_free((caddr_t)cl, sizeof(CLIENT));
187			return (NULL);
188			}
189			DEF_WEAK(clntudp_bufcreate);
190
191			CLIENT *
192			clntudp_create(struct sockaddr_in *raddr, u_long program, u_long version,
193			struct timeval wait, int *sockp)
194			{
195
196			return(clntudp_bufcreate(raddr, program, version, wait, sockp,
197			UDPMSGSIZE, UDPMSGSIZE));
198			}
199			DEF_WEAK(clntudp_create);
200
201			static enum clnt_stat
202			clntudp_call(CLIENT cl, / client handle */
203			u_long proc, /* procedure number */
204			xdrproc_t xargs, /* xdr routine for args */
205			caddr_t argsp, /* pointer to args */
206			xdrproc_t xresults, /* xdr routine for results */
207			caddr_t resultsp, /* pointer to results */
208			struct timeval utimeout) /* seconds to wait before giving up */
209			{
210			struct cu_data cu = (struct cu_data )cl->cl_private;
211			XDR *xdrs;
212			int outlen;
213			int inlen;
214			socklen_t fromlen;
215			struct pollfd pfd[1];
216			struct sockaddr_in from;
217			struct rpc_msg reply_msg;
218			XDR reply_xdrs;
219			struct timeval time_waited, start, after, tmp1, tmp2;
220			bool_t ok;
221			int nrefreshes = 2; /* number of times to refresh cred */
222			struct timeval timeout;
223
224			if (cu->cu_total.tv_usec == -1)
225			timeout = utimeout; /* use supplied timeout */
226			else
227			timeout = cu->cu_total; /* use default timeout */
228
229			pfd[0].fd = cu->cu_sock;
230			pfd[0].events = POLLIN;
231			timerclear(&time_waited);
232			call_again:
233			xdrs = &(cu->cu_outxdrs);
234			xdrs->x_op = XDR_ENCODE;
235			XDR_SETPOS(xdrs, cu->cu_xdrpos);
236			/*
237			* the transaction is the first thing in the out buffer
238			*/
239			((u_short )(cu->cu_outbuf))++;
240			if (!XDR_PUTLONG(xdrs, (long *)&proc) \|\|
241			!AUTH_MARSHALL(cl->cl_auth, xdrs) \|\|
242			!(*xargs)(xdrs, argsp)) {
243			return (cu->cu_error.re_status = RPC_CANTENCODEARGS);
244			}
245			outlen = (int)XDR_GETPOS(xdrs);
246
247			send_again:
248			if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0,
249			(struct sockaddr *)&(cu->cu_raddr), cu->cu_rlen) != outlen) {
250			cu->cu_error.re_errno = errno;
251			return (cu->cu_error.re_status = RPC_CANTSEND);
252			}
253
254			/*
255			* Hack to provide rpc-based message passing
256			*/
257			if (!timerisset(&timeout))
258			return (cu->cu_error.re_status = RPC_TIMEDOUT);
259
260			/*
261			* sub-optimal code appears here because we have
262			* some clock time to spare while the packets are in flight.
263			* (We assume that this is actually only executed once.)
264			*/
265			reply_msg.acpted_rply.ar_verf = _null_auth;
266			reply_msg.acpted_rply.ar_results.where = resultsp;
267			reply_msg.acpted_rply.ar_results.proc = xresults;
268
269			gettimeofday(&start, NULL);
270			for (;;) {
271			switch (poll(pfd, 1,
272			cu->cu_wait.tv_sec * 1000 + cu->cu_wait.tv_usec / 1000)) {
273			case 0:
274			timeradd(&time_waited, &cu->cu_wait, &tmp1);
275			time_waited = tmp1;
276			if (timercmp(&time_waited, &timeout, <))
277			goto send_again;
278			return (cu->cu_error.re_status = RPC_TIMEDOUT);
279			case 1:
280			if (pfd[0].revents & POLLNVAL)
281			errno = EBADF;
282			else if (pfd[0].revents & POLLERR)
283			errno = EIO;
284			else
285			break;
286			/* FALLTHROUGH */
287			case -1:
288			if (errno == EINTR) {
289			gettimeofday(&after, NULL);
290			timersub(&after, &start, &tmp1);
291			timeradd(&time_waited, &tmp1, &tmp2);
292			time_waited = tmp2;
293			if (timercmp(&time_waited, &timeout, <))
294			continue;
295			return (cu->cu_error.re_status = RPC_TIMEDOUT);
296			}
297			cu->cu_error.re_errno = errno;
298			return (cu->cu_error.re_status = RPC_CANTRECV);
299			}
300
301			do {
302			fromlen = sizeof(struct sockaddr);
303			inlen = recvfrom(cu->cu_sock, cu->cu_inbuf,
304			(int) cu->cu_recvsz, 0,
305			(struct sockaddr *)&from, &fromlen);
306			} while (inlen < 0 && errno == EINTR);
307			if (inlen < 0) {
308			if (errno == EWOULDBLOCK)
309			continue;
310			cu->cu_error.re_errno = errno;
311			return (cu->cu_error.re_status = RPC_CANTRECV);
312			}
313			if (inlen < sizeof(u_int32_t))
314			continue;
315			/* see if reply transaction id matches sent id */
316			if (((struct rpc_msg *)(cu->cu_inbuf))->rm_xid !=
317			((struct rpc_msg *)(cu->cu_outbuf))->rm_xid)
318			continue;
319			/* we now assume we have the proper reply */
320			break;
321			}
322
323			/*
324			* now decode and validate the response
325			*/
326			xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE);
327			ok = xdr_replymsg(&reply_xdrs, &reply_msg);
328			/* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */
329			if (ok) {
330			#if 0
331			/*
332			* XXX Would like to check these, but call_msg is not
333			* around.
334			*/
335			if (reply_msg.rm_call.cb_prog != call_msg.rm_call.cb_prog \|\|
336			reply_msg.rm_call.cb_vers != call_msg.rm_call.cb_vers \|\|
337			reply_msg.rm_call.cb_proc != call_msg.rm_call.cb_proc) {
338			goto call_again; /* XXX spin? */
339			}
340			#endif
341
342			_seterr_reply(&reply_msg, &(cu->cu_error));
343			if (cu->cu_error.re_status == RPC_SUCCESS) {
344			if (!AUTH_VALIDATE(cl->cl_auth,
345			&reply_msg.acpted_rply.ar_verf)) {
346			cu->cu_error.re_status = RPC_AUTHERROR;
347			cu->cu_error.re_why = AUTH_INVALIDRESP;
348			}
349			if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
350			xdrs->x_op = XDR_FREE;
351			(void)xdr_opaque_auth(xdrs,
352			&(reply_msg.acpted_rply.ar_verf));
353			}
354			} else {
355			/* maybe our credentials need to be refreshed ... */
356			if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth)) {
357			nrefreshes--;
358			goto call_again;
359			}
360			}
361			} else {
362			/* xdr_replymsg() may have left some things allocated */
363			int op = reply_xdrs.x_op;
364			reply_xdrs.x_op = XDR_FREE;
365			xdr_replymsg(&reply_xdrs, &reply_msg);
366			reply_xdrs.x_op = op;
367			cu->cu_error.re_status = RPC_CANTDECODERES;
368			}
369
370			return (cu->cu_error.re_status);
371			}
372
373			static void
374			clntudp_geterr(CLIENT cl, struct rpc_err errp)
375			{
376			struct cu_data cu = (struct cu_data )cl->cl_private;
377
378			*errp = cu->cu_error;
379			}
380
381
382			static bool_t
383			clntudp_freeres(CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
384			{
385			struct cu_data cu = (struct cu_data )cl->cl_private;
386			XDR *xdrs = &(cu->cu_outxdrs);
387
388			xdrs->x_op = XDR_FREE;
389			return ((*xdr_res)(xdrs, res_ptr));
390			}
391
392			static void
393			clntudp_abort(CLIENT *clnt)
394			{
395			}
396
397			static bool_t
398			clntudp_control(CLIENT cl, u_int request, void info)
399			{
400			struct cu_data cu = (struct cu_data )cl->cl_private;
401
402			switch (request) {
403			case CLSET_TIMEOUT:
404			cu->cu_total = (struct timeval )info;
405			break;
406			case CLGET_TIMEOUT:
407			(struct timeval )info = cu->cu_total;
408			break;
409			case CLSET_RETRY_TIMEOUT:
410			cu->cu_wait = (struct timeval )info;
411			break;
412			case CLGET_RETRY_TIMEOUT:
413			(struct timeval )info = cu->cu_wait;
414			break;
415			case CLGET_SERVER_ADDR:
416			(struct sockaddr_in )info = cu->cu_raddr;
417			break;
418			default:
419			return (FALSE);
420			}
421			return (TRUE);
422			}
423
424			static void
425			clntudp_destroy(CLIENT *cl)
426			{
427			struct cu_data cu = (struct cu_data )cl->cl_private;
428
429			if (cu->cu_closeit && cu->cu_sock != -1) {
430			(void)close(cu->cu_sock);
431			}
432			XDR_DESTROY(&(cu->cu_outxdrs));
433			mem_free((caddr_t)cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz));
434			mem_free((caddr_t)cl, sizeof(CLIENT));
435			}