1*c067908dSmckusick /* @(#)clnt_udp.c 2.2 88/08/01 4.0 RPCSRC */
2*c067908dSmckusick /*
3*c067908dSmckusick * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
4*c067908dSmckusick * unrestricted use provided that this legend is included on all tape
5*c067908dSmckusick * media and as a part of the software program in whole or part. Users
6*c067908dSmckusick * may copy or modify Sun RPC without charge, but are not authorized
7*c067908dSmckusick * to license or distribute it to anyone else except as part of a product or
8*c067908dSmckusick * program developed by the user.
9*c067908dSmckusick *
10*c067908dSmckusick * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
11*c067908dSmckusick * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
12*c067908dSmckusick * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
13*c067908dSmckusick *
14*c067908dSmckusick * Sun RPC is provided with no support and without any obligation on the
15*c067908dSmckusick * part of Sun Microsystems, Inc. to assist in its use, correction,
16*c067908dSmckusick * modification or enhancement.
17*c067908dSmckusick *
18*c067908dSmckusick * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
19*c067908dSmckusick * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
20*c067908dSmckusick * OR ANY PART THEREOF.
21*c067908dSmckusick *
22*c067908dSmckusick * In no event will Sun Microsystems, Inc. be liable for any lost revenue
23*c067908dSmckusick * or profits or other special, indirect and consequential damages, even if
24*c067908dSmckusick * Sun has been advised of the possibility of such damages.
25*c067908dSmckusick *
26*c067908dSmckusick * Sun Microsystems, Inc.
27*c067908dSmckusick * 2550 Garcia Avenue
28*c067908dSmckusick * Mountain View, California 94043
29*c067908dSmckusick */
30*c067908dSmckusick #if !defined(lint) && defined(SCCSIDS)
31*c067908dSmckusick static char sccsid[] = "@(#)clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
32*c067908dSmckusick #endif
33*c067908dSmckusick
34*c067908dSmckusick /*
35*c067908dSmckusick * clnt_udp.c, Implements a UDP/IP based, client side RPC.
36*c067908dSmckusick *
37*c067908dSmckusick * Copyright (C) 1984, Sun Microsystems, Inc.
38*c067908dSmckusick */
39*c067908dSmckusick
40*c067908dSmckusick #include <stdio.h>
41*c067908dSmckusick #include <rpc/rpc.h>
42*c067908dSmckusick #include <sys/socket.h>
43*c067908dSmckusick #include <sys/ioctl.h>
44*c067908dSmckusick #include <netdb.h>
45*c067908dSmckusick #include <errno.h>
46*c067908dSmckusick #include <rpc/pmap_clnt.h>
47*c067908dSmckusick
48*c067908dSmckusick extern int errno;
49*c067908dSmckusick
50*c067908dSmckusick /*
51*c067908dSmckusick * UDP bases client side rpc operations
52*c067908dSmckusick */
53*c067908dSmckusick static enum clnt_stat clntudp_call();
54*c067908dSmckusick static void clntudp_abort();
55*c067908dSmckusick static void clntudp_geterr();
56*c067908dSmckusick static bool_t clntudp_freeres();
57*c067908dSmckusick static bool_t clntudp_control();
58*c067908dSmckusick static void clntudp_destroy();
59*c067908dSmckusick
60*c067908dSmckusick static struct clnt_ops udp_ops = {
61*c067908dSmckusick clntudp_call,
62*c067908dSmckusick clntudp_abort,
63*c067908dSmckusick clntudp_geterr,
64*c067908dSmckusick clntudp_freeres,
65*c067908dSmckusick clntudp_destroy,
66*c067908dSmckusick clntudp_control
67*c067908dSmckusick };
68*c067908dSmckusick
69*c067908dSmckusick /*
70*c067908dSmckusick * Private data kept per client handle
71*c067908dSmckusick */
72*c067908dSmckusick struct cu_data {
73*c067908dSmckusick int cu_sock;
74*c067908dSmckusick bool_t cu_closeit;
75*c067908dSmckusick struct sockaddr_in cu_raddr;
76*c067908dSmckusick int cu_rlen;
77*c067908dSmckusick struct timeval cu_wait;
78*c067908dSmckusick struct timeval cu_total;
79*c067908dSmckusick struct rpc_err cu_error;
80*c067908dSmckusick XDR cu_outxdrs;
81*c067908dSmckusick u_int cu_xdrpos;
82*c067908dSmckusick u_int cu_sendsz;
83*c067908dSmckusick char *cu_outbuf;
84*c067908dSmckusick u_int cu_recvsz;
85*c067908dSmckusick char cu_inbuf[1];
86*c067908dSmckusick };
87*c067908dSmckusick
88*c067908dSmckusick /*
89*c067908dSmckusick * Create a UDP based client handle.
90*c067908dSmckusick * If *sockp<0, *sockp is set to a newly created UPD socket.
91*c067908dSmckusick * If raddr->sin_port is 0 a binder on the remote machine
92*c067908dSmckusick * is consulted for the correct port number.
93*c067908dSmckusick * NB: It is the clients responsibility to close *sockp.
94*c067908dSmckusick * NB: The rpch->cl_auth is initialized to null authentication.
95*c067908dSmckusick * Caller may wish to set this something more useful.
96*c067908dSmckusick *
97*c067908dSmckusick * wait is the amount of time used between retransmitting a call if
98*c067908dSmckusick * no response has been heard; retransmition occurs until the actual
99*c067908dSmckusick * rpc call times out.
100*c067908dSmckusick *
101*c067908dSmckusick * sendsz and recvsz are the maximum allowable packet sizes that can be
102*c067908dSmckusick * sent and received.
103*c067908dSmckusick */
104*c067908dSmckusick CLIENT *
clntudp_bufcreate(raddr,program,version,wait,sockp,sendsz,recvsz)105*c067908dSmckusick clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz)
106*c067908dSmckusick struct sockaddr_in *raddr;
107*c067908dSmckusick u_long program;
108*c067908dSmckusick u_long version;
109*c067908dSmckusick struct timeval wait;
110*c067908dSmckusick register int *sockp;
111*c067908dSmckusick u_int sendsz;
112*c067908dSmckusick u_int recvsz;
113*c067908dSmckusick {
114*c067908dSmckusick CLIENT *cl;
115*c067908dSmckusick register struct cu_data *cu;
116*c067908dSmckusick struct timeval now;
117*c067908dSmckusick struct rpc_msg call_msg;
118*c067908dSmckusick
119*c067908dSmckusick cl = (CLIENT *)mem_alloc(sizeof(CLIENT));
120*c067908dSmckusick if (cl == NULL) {
121*c067908dSmckusick (void) fprintf(stderr, "clntudp_create: out of memory\n");
122*c067908dSmckusick rpc_createerr.cf_stat = RPC_SYSTEMERROR;
123*c067908dSmckusick rpc_createerr.cf_error.re_errno = errno;
124*c067908dSmckusick goto fooy;
125*c067908dSmckusick }
126*c067908dSmckusick sendsz = ((sendsz + 3) / 4) * 4;
127*c067908dSmckusick recvsz = ((recvsz + 3) / 4) * 4;
128*c067908dSmckusick cu = (struct cu_data *)mem_alloc(sizeof(*cu) + sendsz + recvsz);
129*c067908dSmckusick if (cu == NULL) {
130*c067908dSmckusick (void) fprintf(stderr, "clntudp_create: out of memory\n");
131*c067908dSmckusick rpc_createerr.cf_stat = RPC_SYSTEMERROR;
132*c067908dSmckusick rpc_createerr.cf_error.re_errno = errno;
133*c067908dSmckusick goto fooy;
134*c067908dSmckusick }
135*c067908dSmckusick cu->cu_outbuf = &cu->cu_inbuf[recvsz];
136*c067908dSmckusick
137*c067908dSmckusick (void)gettimeofday(&now, (struct timezone *)0);
138*c067908dSmckusick if (raddr->sin_port == 0) {
139*c067908dSmckusick u_short port;
140*c067908dSmckusick if ((port =
141*c067908dSmckusick pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) {
142*c067908dSmckusick goto fooy;
143*c067908dSmckusick }
144*c067908dSmckusick raddr->sin_port = htons(port);
145*c067908dSmckusick }
146*c067908dSmckusick cl->cl_ops = &udp_ops;
147*c067908dSmckusick cl->cl_private = (caddr_t)cu;
148*c067908dSmckusick cu->cu_raddr = *raddr;
149*c067908dSmckusick cu->cu_rlen = sizeof (cu->cu_raddr);
150*c067908dSmckusick cu->cu_wait = wait;
151*c067908dSmckusick cu->cu_total.tv_sec = -1;
152*c067908dSmckusick cu->cu_total.tv_usec = -1;
153*c067908dSmckusick cu->cu_sendsz = sendsz;
154*c067908dSmckusick cu->cu_recvsz = recvsz;
155*c067908dSmckusick call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec;
156*c067908dSmckusick call_msg.rm_direction = CALL;
157*c067908dSmckusick call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
158*c067908dSmckusick call_msg.rm_call.cb_prog = program;
159*c067908dSmckusick call_msg.rm_call.cb_vers = version;
160*c067908dSmckusick xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf,
161*c067908dSmckusick sendsz, XDR_ENCODE);
162*c067908dSmckusick if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
163*c067908dSmckusick goto fooy;
164*c067908dSmckusick }
165*c067908dSmckusick cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
166*c067908dSmckusick if (*sockp < 0) {
167*c067908dSmckusick int dontblock = 1;
168*c067908dSmckusick
169*c067908dSmckusick *sockp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
170*c067908dSmckusick if (*sockp < 0) {
171*c067908dSmckusick rpc_createerr.cf_stat = RPC_SYSTEMERROR;
172*c067908dSmckusick rpc_createerr.cf_error.re_errno = errno;
173*c067908dSmckusick goto fooy;
174*c067908dSmckusick }
175*c067908dSmckusick /* attempt to bind to prov port */
176*c067908dSmckusick (void)bindresvport(*sockp, (struct sockaddr_in *)0);
177*c067908dSmckusick /* the sockets rpc controls are non-blocking */
178*c067908dSmckusick (void)ioctl(*sockp, FIONBIO, (char *) &dontblock);
179*c067908dSmckusick cu->cu_closeit = TRUE;
180*c067908dSmckusick } else {
181*c067908dSmckusick cu->cu_closeit = FALSE;
182*c067908dSmckusick }
183*c067908dSmckusick cu->cu_sock = *sockp;
184*c067908dSmckusick cl->cl_auth = authnone_create();
185*c067908dSmckusick return (cl);
186*c067908dSmckusick fooy:
187*c067908dSmckusick if (cu)
188*c067908dSmckusick mem_free((caddr_t)cu, sizeof(*cu) + sendsz + recvsz);
189*c067908dSmckusick if (cl)
190*c067908dSmckusick mem_free((caddr_t)cl, sizeof(CLIENT));
191*c067908dSmckusick return ((CLIENT *)NULL);
192*c067908dSmckusick }
193*c067908dSmckusick
194*c067908dSmckusick CLIENT *
clntudp_create(raddr,program,version,wait,sockp)195*c067908dSmckusick clntudp_create(raddr, program, version, wait, sockp)
196*c067908dSmckusick struct sockaddr_in *raddr;
197*c067908dSmckusick u_long program;
198*c067908dSmckusick u_long version;
199*c067908dSmckusick struct timeval wait;
200*c067908dSmckusick register int *sockp;
201*c067908dSmckusick {
202*c067908dSmckusick
203*c067908dSmckusick return(clntudp_bufcreate(raddr, program, version, wait, sockp,
204*c067908dSmckusick UDPMSGSIZE, UDPMSGSIZE));
205*c067908dSmckusick }
206*c067908dSmckusick
207*c067908dSmckusick static enum clnt_stat
clntudp_call(cl,proc,xargs,argsp,xresults,resultsp,utimeout)208*c067908dSmckusick clntudp_call(cl, proc, xargs, argsp, xresults, resultsp, utimeout)
209*c067908dSmckusick register CLIENT *cl; /* client handle */
210*c067908dSmckusick u_long proc; /* procedure number */
211*c067908dSmckusick xdrproc_t xargs; /* xdr routine for args */
212*c067908dSmckusick caddr_t argsp; /* pointer to args */
213*c067908dSmckusick xdrproc_t xresults; /* xdr routine for results */
214*c067908dSmckusick caddr_t resultsp; /* pointer to results */
215*c067908dSmckusick struct timeval utimeout; /* seconds to wait before giving up */
216*c067908dSmckusick {
217*c067908dSmckusick register struct cu_data *cu = (struct cu_data *)cl->cl_private;
218*c067908dSmckusick register XDR *xdrs;
219*c067908dSmckusick register int outlen;
220*c067908dSmckusick register int inlen;
221*c067908dSmckusick int fromlen;
222*c067908dSmckusick #ifdef FD_SETSIZE
223*c067908dSmckusick fd_set readfds;
224*c067908dSmckusick fd_set mask;
225*c067908dSmckusick #else
226*c067908dSmckusick int readfds;
227*c067908dSmckusick register int mask;
228*c067908dSmckusick #endif /* def FD_SETSIZE */
229*c067908dSmckusick struct sockaddr_in from;
230*c067908dSmckusick struct rpc_msg reply_msg;
231*c067908dSmckusick XDR reply_xdrs;
232*c067908dSmckusick struct timeval time_waited;
233*c067908dSmckusick bool_t ok;
234*c067908dSmckusick int nrefreshes = 2; /* number of times to refresh cred */
235*c067908dSmckusick struct timeval timeout;
236*c067908dSmckusick
237*c067908dSmckusick if (cu->cu_total.tv_usec == -1) {
238*c067908dSmckusick timeout = utimeout; /* use supplied timeout */
239*c067908dSmckusick } else {
240*c067908dSmckusick timeout = cu->cu_total; /* use default timeout */
241*c067908dSmckusick }
242*c067908dSmckusick
243*c067908dSmckusick time_waited.tv_sec = 0;
244*c067908dSmckusick time_waited.tv_usec = 0;
245*c067908dSmckusick call_again:
246*c067908dSmckusick xdrs = &(cu->cu_outxdrs);
247*c067908dSmckusick xdrs->x_op = XDR_ENCODE;
248*c067908dSmckusick XDR_SETPOS(xdrs, cu->cu_xdrpos);
249*c067908dSmckusick /*
250*c067908dSmckusick * the transaction is the first thing in the out buffer
251*c067908dSmckusick */
252*c067908dSmckusick (*(u_short *)(cu->cu_outbuf))++;
253*c067908dSmckusick if ((! XDR_PUTLONG(xdrs, (long *)&proc)) ||
254*c067908dSmckusick (! AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
255*c067908dSmckusick (! (*xargs)(xdrs, argsp)))
256*c067908dSmckusick return (cu->cu_error.re_status = RPC_CANTENCODEARGS);
257*c067908dSmckusick outlen = (int)XDR_GETPOS(xdrs);
258*c067908dSmckusick
259*c067908dSmckusick send_again:
260*c067908dSmckusick if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0,
261*c067908dSmckusick (struct sockaddr *)&(cu->cu_raddr), cu->cu_rlen)
262*c067908dSmckusick != outlen) {
263*c067908dSmckusick cu->cu_error.re_errno = errno;
264*c067908dSmckusick return (cu->cu_error.re_status = RPC_CANTSEND);
265*c067908dSmckusick }
266*c067908dSmckusick
267*c067908dSmckusick /*
268*c067908dSmckusick * Hack to provide rpc-based message passing
269*c067908dSmckusick */
270*c067908dSmckusick if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
271*c067908dSmckusick return (cu->cu_error.re_status = RPC_TIMEDOUT);
272*c067908dSmckusick }
273*c067908dSmckusick /*
274*c067908dSmckusick * sub-optimal code appears here because we have
275*c067908dSmckusick * some clock time to spare while the packets are in flight.
276*c067908dSmckusick * (We assume that this is actually only executed once.)
277*c067908dSmckusick */
278*c067908dSmckusick reply_msg.acpted_rply.ar_verf = _null_auth;
279*c067908dSmckusick reply_msg.acpted_rply.ar_results.where = resultsp;
280*c067908dSmckusick reply_msg.acpted_rply.ar_results.proc = xresults;
281*c067908dSmckusick #ifdef FD_SETSIZE
282*c067908dSmckusick FD_ZERO(&mask);
283*c067908dSmckusick FD_SET(cu->cu_sock, &mask);
284*c067908dSmckusick #else
285*c067908dSmckusick mask = 1 << cu->cu_sock;
286*c067908dSmckusick #endif /* def FD_SETSIZE */
287*c067908dSmckusick for (;;) {
288*c067908dSmckusick readfds = mask;
289*c067908dSmckusick switch (select(_rpc_dtablesize(), &readfds, (int *)NULL,
290*c067908dSmckusick (int *)NULL, &(cu->cu_wait))) {
291*c067908dSmckusick
292*c067908dSmckusick case 0:
293*c067908dSmckusick time_waited.tv_sec += cu->cu_wait.tv_sec;
294*c067908dSmckusick time_waited.tv_usec += cu->cu_wait.tv_usec;
295*c067908dSmckusick while (time_waited.tv_usec >= 1000000) {
296*c067908dSmckusick time_waited.tv_sec++;
297*c067908dSmckusick time_waited.tv_usec -= 1000000;
298*c067908dSmckusick }
299*c067908dSmckusick if ((time_waited.tv_sec < timeout.tv_sec) ||
300*c067908dSmckusick ((time_waited.tv_sec == timeout.tv_sec) &&
301*c067908dSmckusick (time_waited.tv_usec < timeout.tv_usec)))
302*c067908dSmckusick goto send_again;
303*c067908dSmckusick return (cu->cu_error.re_status = RPC_TIMEDOUT);
304*c067908dSmckusick
305*c067908dSmckusick /*
306*c067908dSmckusick * buggy in other cases because time_waited is not being
307*c067908dSmckusick * updated.
308*c067908dSmckusick */
309*c067908dSmckusick case -1:
310*c067908dSmckusick if (errno == EINTR)
311*c067908dSmckusick continue;
312*c067908dSmckusick cu->cu_error.re_errno = errno;
313*c067908dSmckusick return (cu->cu_error.re_status = RPC_CANTRECV);
314*c067908dSmckusick }
315*c067908dSmckusick do {
316*c067908dSmckusick fromlen = sizeof(struct sockaddr);
317*c067908dSmckusick inlen = recvfrom(cu->cu_sock, cu->cu_inbuf,
318*c067908dSmckusick (int) cu->cu_recvsz, 0,
319*c067908dSmckusick (struct sockaddr *)&from, &fromlen);
320*c067908dSmckusick } while (inlen < 0 && errno == EINTR);
321*c067908dSmckusick if (inlen < 0) {
322*c067908dSmckusick if (errno == EWOULDBLOCK)
323*c067908dSmckusick continue;
324*c067908dSmckusick cu->cu_error.re_errno = errno;
325*c067908dSmckusick return (cu->cu_error.re_status = RPC_CANTRECV);
326*c067908dSmckusick }
327*c067908dSmckusick if (inlen < sizeof(u_long))
328*c067908dSmckusick continue;
329*c067908dSmckusick /* see if reply transaction id matches sent id */
330*c067908dSmckusick if (*((u_long *)(cu->cu_inbuf)) != *((u_long *)(cu->cu_outbuf)))
331*c067908dSmckusick continue;
332*c067908dSmckusick /* we now assume we have the proper reply */
333*c067908dSmckusick break;
334*c067908dSmckusick }
335*c067908dSmckusick
336*c067908dSmckusick /*
337*c067908dSmckusick * now decode and validate the response
338*c067908dSmckusick */
339*c067908dSmckusick xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE);
340*c067908dSmckusick ok = xdr_replymsg(&reply_xdrs, &reply_msg);
341*c067908dSmckusick /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */
342*c067908dSmckusick if (ok) {
343*c067908dSmckusick _seterr_reply(&reply_msg, &(cu->cu_error));
344*c067908dSmckusick if (cu->cu_error.re_status == RPC_SUCCESS) {
345*c067908dSmckusick if (! AUTH_VALIDATE(cl->cl_auth,
346*c067908dSmckusick &reply_msg.acpted_rply.ar_verf)) {
347*c067908dSmckusick cu->cu_error.re_status = RPC_AUTHERROR;
348*c067908dSmckusick cu->cu_error.re_why = AUTH_INVALIDRESP;
349*c067908dSmckusick }
350*c067908dSmckusick if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
351*c067908dSmckusick xdrs->x_op = XDR_FREE;
352*c067908dSmckusick (void)xdr_opaque_auth(xdrs,
353*c067908dSmckusick &(reply_msg.acpted_rply.ar_verf));
354*c067908dSmckusick }
355*c067908dSmckusick } /* end successful completion */
356*c067908dSmckusick else {
357*c067908dSmckusick /* maybe our credentials need to be refreshed ... */
358*c067908dSmckusick if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth)) {
359*c067908dSmckusick nrefreshes--;
360*c067908dSmckusick goto call_again;
361*c067908dSmckusick }
362*c067908dSmckusick } /* end of unsuccessful completion */
363*c067908dSmckusick } /* end of valid reply message */
364*c067908dSmckusick else {
365*c067908dSmckusick cu->cu_error.re_status = RPC_CANTDECODERES;
366*c067908dSmckusick }
367*c067908dSmckusick return (cu->cu_error.re_status);
368*c067908dSmckusick }
369*c067908dSmckusick
370*c067908dSmckusick static void
clntudp_geterr(cl,errp)371*c067908dSmckusick clntudp_geterr(cl, errp)
372*c067908dSmckusick CLIENT *cl;
373*c067908dSmckusick struct rpc_err *errp;
374*c067908dSmckusick {
375*c067908dSmckusick register struct cu_data *cu = (struct cu_data *)cl->cl_private;
376*c067908dSmckusick
377*c067908dSmckusick *errp = cu->cu_error;
378*c067908dSmckusick }
379*c067908dSmckusick
380*c067908dSmckusick
381*c067908dSmckusick static bool_t
clntudp_freeres(cl,xdr_res,res_ptr)382*c067908dSmckusick clntudp_freeres(cl, xdr_res, res_ptr)
383*c067908dSmckusick CLIENT *cl;
384*c067908dSmckusick xdrproc_t xdr_res;
385*c067908dSmckusick caddr_t res_ptr;
386*c067908dSmckusick {
387*c067908dSmckusick register struct cu_data *cu = (struct cu_data *)cl->cl_private;
388*c067908dSmckusick register XDR *xdrs = &(cu->cu_outxdrs);
389*c067908dSmckusick
390*c067908dSmckusick xdrs->x_op = XDR_FREE;
391*c067908dSmckusick return ((*xdr_res)(xdrs, res_ptr));
392*c067908dSmckusick }
393*c067908dSmckusick
394*c067908dSmckusick static void
clntudp_abort()395*c067908dSmckusick clntudp_abort(/*h*/)
396*c067908dSmckusick /*CLIENT *h;*/
397*c067908dSmckusick {
398*c067908dSmckusick }
399*c067908dSmckusick
400*c067908dSmckusick static bool_t
clntudp_control(cl,request,info)401*c067908dSmckusick clntudp_control(cl, request, info)
402*c067908dSmckusick CLIENT *cl;
403*c067908dSmckusick int request;
404*c067908dSmckusick char *info;
405*c067908dSmckusick {
406*c067908dSmckusick register struct cu_data *cu = (struct cu_data *)cl->cl_private;
407*c067908dSmckusick
408*c067908dSmckusick switch (request) {
409*c067908dSmckusick case CLSET_TIMEOUT:
410*c067908dSmckusick cu->cu_total = *(struct timeval *)info;
411*c067908dSmckusick break;
412*c067908dSmckusick case CLGET_TIMEOUT:
413*c067908dSmckusick *(struct timeval *)info = cu->cu_total;
414*c067908dSmckusick break;
415*c067908dSmckusick case CLSET_RETRY_TIMEOUT:
416*c067908dSmckusick cu->cu_wait = *(struct timeval *)info;
417*c067908dSmckusick break;
418*c067908dSmckusick case CLGET_RETRY_TIMEOUT:
419*c067908dSmckusick *(struct timeval *)info = cu->cu_wait;
420*c067908dSmckusick break;
421*c067908dSmckusick case CLGET_SERVER_ADDR:
422*c067908dSmckusick *(struct sockaddr_in *)info = cu->cu_raddr;
423*c067908dSmckusick break;
424*c067908dSmckusick default:
425*c067908dSmckusick return (FALSE);
426*c067908dSmckusick }
427*c067908dSmckusick return (TRUE);
428*c067908dSmckusick }
429*c067908dSmckusick
430*c067908dSmckusick static void
clntudp_destroy(cl)431*c067908dSmckusick clntudp_destroy(cl)
432*c067908dSmckusick CLIENT *cl;
433*c067908dSmckusick {
434*c067908dSmckusick register struct cu_data *cu = (struct cu_data *)cl->cl_private;
435*c067908dSmckusick
436*c067908dSmckusick if (cu->cu_closeit) {
437*c067908dSmckusick (void)close(cu->cu_sock);
438*c067908dSmckusick }
439*c067908dSmckusick XDR_DESTROY(&(cu->cu_outxdrs));
440*c067908dSmckusick mem_free((caddr_t)cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz));
441*c067908dSmckusick mem_free((caddr_t)cl, sizeof(CLIENT));
442*c067908dSmckusick }
443