1 /* $NetBSD: clnt_dg.c,v 1.33 2024/01/23 17:24:38 christos 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 * Copyright (c) 1986-1991 by Sun Microsystems Inc.
35 */
36
37 /* #ident "@(#)clnt_dg.c 1.23 94/04/22 SMI" */
38
39 #include <sys/cdefs.h>
40 #if defined(LIBC_SCCS) && !defined(lint)
41 #if 0
42 static char sccsid[] = "@(#)clnt_dg.c 1.19 89/03/16 Copyr 1988 Sun Micro";
43 #else
44 __RCSID("$NetBSD: clnt_dg.c,v 1.33 2024/01/23 17:24:38 christos Exp $");
45 #endif
46 #endif
47
48 /*
49 * Implements a connectionless client side RPC.
50 */
51
52 #include "namespace.h"
53 #include "reentrant.h"
54 #include <sys/poll.h>
55 #include <sys/types.h>
56 #include <sys/time.h>
57 #include <sys/socket.h>
58 #include <sys/ioctl.h>
59 #include <rpc/rpc.h>
60 #include <assert.h>
61 #include <errno.h>
62 #include <stdlib.h>
63 #include <string.h>
64 #include <signal.h>
65 #include <unistd.h>
66 #include <err.h>
67
68 #include "svc_fdset.h"
69 #include "rpc_internal.h"
70
71 #ifdef __weak_alias
72 __weak_alias(clnt_dg_create,_clnt_dg_create)
73 #endif
74
75 #define RPC_MAX_BACKOFF 30 /* seconds */
76
77
78 static struct clnt_ops *clnt_dg_ops(void);
79 static bool_t time_not_ok(struct timeval *);
80 static enum clnt_stat clnt_dg_call(CLIENT *, rpcproc_t, xdrproc_t,
81 const char *, xdrproc_t, caddr_t, struct timeval);
82 static void clnt_dg_geterr(CLIENT *, struct rpc_err *);
83 static bool_t clnt_dg_freeres(CLIENT *, xdrproc_t, caddr_t);
84 static void clnt_dg_abort(CLIENT *);
85 static bool_t clnt_dg_control(CLIENT *, u_int, char *);
86 static void clnt_dg_destroy(CLIENT *);
87
88
89
90
91 /*
92 * This machinery implements per-fd locks for MT-safety. It is not
93 * sufficient to do per-CLIENT handle locks for MT-safety because a
94 * user may create more than one CLIENT handle with the same fd behind
95 * it. Therefore, we allocate an array of flags (dg_fd_locks), protected
96 * by the clnt_fd_lock mutex, and an array (dg_cv) of condition variables
97 * similarly protected. Dg_fd_lock[fd] == 1 => a call is active on some
98 * CLIENT handle created for that fd.
99 * The current implementation holds locks across the entire RPC and reply,
100 * including retransmissions. Yes, this is silly, and as soon as this
101 * code is proven to work, this should be the first thing fixed. One step
102 * at a time.
103 */
104 static int *dg_fd_locks;
105 #ifdef _REENTRANT
106 #define __rpc_lock_value __isthreaded;
107 static cond_t *dg_cv;
108 #define release_fd_lock(fd, mask) { \
109 mutex_lock(&clnt_fd_lock); \
110 dg_fd_locks[fd] = 0; \
111 mutex_unlock(&clnt_fd_lock); \
112 thr_sigsetmask(SIG_SETMASK, &(mask), NULL); \
113 cond_signal(&dg_cv[fd]); \
114 }
115 #else
116 #define release_fd_lock(fd,mask)
117 #define __rpc_lock_value 0
118 #endif
119
120 static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory";
121
122 /* VARIABLES PROTECTED BY clnt_fd_lock: dg_fd_locks, dg_cv */
123
124 /*
125 * Private data kept per client handle
126 */
127 struct cu_data {
128 int cu_fd; /* connections fd */
129 bool_t cu_closeit; /* opened by library */
130 struct sockaddr_storage cu_raddr; /* remote address */
131 int cu_rlen;
132 struct timeval cu_wait; /* retransmit interval */
133 struct timeval cu_total; /* total time for the call */
134 struct rpc_err cu_error;
135 XDR cu_outxdrs;
136 u_int cu_xdrpos;
137 u_int cu_sendsz; /* send size */
138 char *cu_outbuf;
139 u_int cu_recvsz; /* recv size */
140 struct pollfd cu_pfdp;
141 char cu_inbuf[1];
142 };
143
144 /*
145 * Connection less client creation returns with client handle parameters.
146 * Default options are set, which the user can change using clnt_control().
147 * fd should be open and bound.
148 * NB: The rpch->cl_auth is initialized to null authentication.
149 * Caller may wish to set this something more useful.
150 *
151 * sendsz and recvsz are the maximum allowable packet sizes that can be
152 * sent and received. Normally they are the same, but they can be
153 * changed to improve the program efficiency and buffer allocation.
154 * If they are 0, use the transport default.
155 *
156 * If svcaddr is NULL, returns NULL.
157 */
158 CLIENT *
clnt_dg_create(int fd,const struct netbuf * svcaddr,rpcprog_t program,rpcvers_t version,u_int sendsz,u_int recvsz)159 clnt_dg_create(
160 int fd, /* open file descriptor */
161 const struct netbuf *svcaddr, /* servers address */
162 rpcprog_t program, /* program number */
163 rpcvers_t version, /* version number */
164 u_int sendsz, /* buffer recv size */
165 u_int recvsz) /* buffer send size */
166 {
167 CLIENT *cl = NULL; /* client handle */
168 struct cu_data *cu = NULL; /* private data */
169 struct rpc_msg call_msg;
170 #ifdef _REENTRANT
171 sigset_t mask;
172 #endif
173 sigset_t newmask;
174 struct __rpc_sockinfo si;
175 int one = 1;
176
177 __clnt_sigfillset(&newmask);
178 thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
179 mutex_lock(&clnt_fd_lock);
180 if (dg_fd_locks == NULL) {
181 #ifdef _REENTRANT
182 size_t cv_allocsz;
183 #endif
184 size_t fd_allocsz;
185 int dtbsize = __rpc_dtbsize();
186
187 fd_allocsz = dtbsize * sizeof (int);
188 dg_fd_locks = mem_alloc(fd_allocsz);
189 if (dg_fd_locks == NULL) {
190 goto err0;
191 } else
192 memset(dg_fd_locks, '\0', fd_allocsz);
193
194 #ifdef _REENTRANT
195 cv_allocsz = dtbsize * sizeof (cond_t);
196 dg_cv = mem_alloc(cv_allocsz);
197 if (dg_cv == NULL) {
198 mem_free(dg_fd_locks, fd_allocsz);
199 dg_fd_locks = NULL;
200 goto err0;
201 } else {
202 int i;
203
204 for (i = 0; i < dtbsize; i++)
205 cond_init(&dg_cv[i], 0, (void *) 0);
206 }
207 #endif
208 }
209
210 mutex_unlock(&clnt_fd_lock);
211 thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
212
213 if (svcaddr == NULL) {
214 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
215 return (NULL);
216 }
217
218 if (!__rpc_fd2sockinfo(fd, &si)) {
219 rpc_createerr.cf_stat = RPC_TLIERROR;
220 rpc_createerr.cf_error.re_errno = 0;
221 return (NULL);
222 }
223 /*
224 * Find the receive and the send size
225 */
226 sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz);
227 recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz);
228 if ((sendsz == 0) || (recvsz == 0)) {
229 rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
230 rpc_createerr.cf_error.re_errno = 0;
231 return (NULL);
232 }
233
234 if ((cl = mem_alloc(sizeof (CLIENT))) == NULL)
235 goto err1;
236 /*
237 * Should be multiple of 4 for XDR.
238 */
239 sendsz = ((sendsz + 3) / 4) * 4;
240 recvsz = ((recvsz + 3) / 4) * 4;
241 cu = malloc(sizeof (*cu) + sendsz + recvsz);
242 if (cu == NULL)
243 goto err1;
244 memset(cu, 0, sizeof(*cu));
245 (void) memcpy(&cu->cu_raddr, svcaddr->buf, (size_t)svcaddr->len);
246 cu->cu_rlen = svcaddr->len;
247 cu->cu_outbuf = &cu->cu_inbuf[recvsz];
248 /* Other values can also be set through clnt_control() */
249 #ifdef RUMP_RPC
250 cu->cu_wait.tv_sec = 15; /* heuristically chosen */
251 cu->cu_wait.tv_usec = 0;
252 #else
253 cu->cu_wait.tv_sec = 0; /* for testing, 10x / second */
254 cu->cu_wait.tv_usec = 100000;
255 #endif
256 cu->cu_total.tv_sec = -1;
257 cu->cu_total.tv_usec = -1;
258 cu->cu_sendsz = sendsz;
259 cu->cu_recvsz = recvsz;
260 call_msg.rm_xid = __RPC_GETXID();
261 call_msg.rm_call.cb_prog = program;
262 call_msg.rm_call.cb_vers = version;
263 xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE);
264 if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
265 rpc_createerr.cf_stat = RPC_CANTENCODEARGS; /* XXX */
266 rpc_createerr.cf_error.re_errno = 0;
267 goto err2;
268 }
269 cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
270
271 /* XXX fvdl - do we still want this? */
272 #if 0
273 (void)bindresvport_sa(fd, (struct sockaddr *)svcaddr->buf);
274 #endif
275 ioctl(fd, FIONBIO, (char *)(void *)&one);
276
277 /*
278 * By default, closeit is always FALSE. It is users responsibility
279 * to do a close on it, else the user may use clnt_control
280 * to let clnt_destroy do it for him/her.
281 */
282 cu->cu_closeit = FALSE;
283 cu->cu_fd = fd;
284 cu->cu_pfdp.fd = cu->cu_fd;
285 cu->cu_pfdp.events = POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND;
286 cl->cl_ops = clnt_dg_ops();
287 cl->cl_private = (caddr_t)(void *)cu;
288 cl->cl_auth = authnone_create();
289 cl->cl_tp = NULL;
290 cl->cl_netid = NULL;
291 return (cl);
292 err0:
293 mutex_unlock(&clnt_fd_lock);
294 thr_sigsetmask(SIG_SETMASK, &(mask), NULL);
295 err1:
296 warnx(mem_err_clnt_dg);
297 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
298 rpc_createerr.cf_error.re_errno = errno;
299 err2:
300 if (cl) {
301 mem_free(cl, sizeof (CLIENT));
302 if (cu)
303 mem_free(cu, sizeof (*cu) + sendsz + recvsz);
304 }
305 return (NULL);
306 }
307
308 static enum clnt_stat
clnt_dg_call(CLIENT * cl,rpcproc_t proc,xdrproc_t xargs,const char * argsp,xdrproc_t xresults,caddr_t resultsp,struct timeval utimeout)309 clnt_dg_call(
310 CLIENT * cl, /* client handle */
311 rpcproc_t proc, /* procedure number */
312 xdrproc_t xargs, /* xdr routine for args */
313 const char * argsp, /* pointer to args */
314 xdrproc_t xresults, /* xdr routine for results */
315 caddr_t resultsp, /* pointer to results */
316 struct timeval utimeout) /* seconds to wait before giving up */
317 {
318 struct cu_data *cu;
319 XDR *xdrs;
320 size_t outlen;
321 struct rpc_msg reply_msg;
322 XDR reply_xdrs;
323 bool_t ok;
324 int nrefreshes = 2; /* number of times to refresh cred */
325 struct timeval timeout;
326 struct timeval retransmit_time;
327 struct timeval next_sendtime, starttime, time_waited, tv;
328 #ifdef _REENTRANT
329 sigset_t mask, *maskp = &mask;
330 #else
331 sigset_t *maskp = NULL;
332 #endif
333 sigset_t newmask;
334 ssize_t recvlen = 0;
335 struct timespec ts;
336 int n;
337
338 _DIAGASSERT(cl != NULL);
339
340 cu = (struct cu_data *)cl->cl_private;
341
342 __clnt_sigfillset(&newmask);
343 thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
344 mutex_lock(&clnt_fd_lock);
345 while (dg_fd_locks[cu->cu_fd])
346 cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
347 dg_fd_locks[cu->cu_fd] = __rpc_lock_value;
348 mutex_unlock(&clnt_fd_lock);
349 if (cu->cu_total.tv_usec == -1) {
350 timeout = utimeout; /* use supplied timeout */
351 } else {
352 timeout = cu->cu_total; /* use default timeout */
353 }
354
355 time_waited.tv_sec = 0;
356 time_waited.tv_usec = 0;
357 retransmit_time = next_sendtime = cu->cu_wait;
358 gettimeofday(&starttime, NULL);
359
360 call_again:
361 xdrs = &(cu->cu_outxdrs);
362 xdrs->x_op = XDR_ENCODE;
363 XDR_SETPOS(xdrs, cu->cu_xdrpos);
364 /*
365 * the transaction is the first thing in the out buffer
366 */
367 (*(u_int32_t *)(void *)(cu->cu_outbuf))++;
368 if ((! XDR_PUTINT32(xdrs, (int32_t *)&proc)) ||
369 (! AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
370 (! (*xargs)(xdrs, __UNCONST(argsp)))) {
371 cu->cu_error.re_status = RPC_CANTENCODEARGS;
372 goto out;
373 }
374 outlen = (size_t)XDR_GETPOS(xdrs);
375
376 send_again:
377 if ((size_t)sendto(cu->cu_fd, cu->cu_outbuf, outlen, 0,
378 (struct sockaddr *)(void *)&cu->cu_raddr, (socklen_t)cu->cu_rlen)
379 != outlen) {
380 cu->cu_error.re_errno = errno;
381 cu->cu_error.re_status = RPC_CANTSEND;
382 goto out;
383 }
384
385 /*
386 * Hack to provide rpc-based message passing
387 */
388 if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
389 cu->cu_error.re_status = RPC_TIMEDOUT;
390 goto out;
391 }
392 /*
393 * sub-optimal code appears here because we have
394 * some clock time to spare while the packets are in flight.
395 * (We assume that this is actually only executed once.)
396 */
397 reply_msg.acpted_rply.ar_verf = _null_auth;
398 reply_msg.acpted_rply.ar_results.where = resultsp;
399 reply_msg.acpted_rply.ar_results.proc = xresults;
400
401
402 for (;;) {
403 /* Decide how long to wait. */
404 if (timercmp(&next_sendtime, &timeout, <))
405 timersub(&next_sendtime, &time_waited, &tv);
406 else
407 timersub(&timeout, &time_waited, &tv);
408 if (tv.tv_sec < 0 || tv.tv_usec < 0)
409 tv.tv_sec = tv.tv_usec = 0;
410 TIMEVAL_TO_TIMESPEC(&tv, &ts);
411
412 n = pollts(&cu->cu_pfdp, 1, &ts, maskp);
413 if (n == 1) {
414 /* We have some data now */
415 do {
416 recvlen = recvfrom(cu->cu_fd, cu->cu_inbuf,
417 cu->cu_recvsz, 0, NULL, NULL);
418 } while (recvlen < 0 && errno == EINTR);
419
420 if (recvlen < 0 && errno != EWOULDBLOCK) {
421 cu->cu_error.re_errno = errno;
422 cu->cu_error.re_status = RPC_CANTRECV;
423 goto out;
424 }
425 if (recvlen >= (ssize_t)sizeof(uint32_t)) {
426 if (memcmp(cu->cu_inbuf, cu->cu_outbuf,
427 sizeof(uint32_t)) == 0)
428 /* Assume we have the proper reply. */
429 break;
430 }
431 }
432 if (n == -1) {
433 cu->cu_error.re_errno = errno;
434 cu->cu_error.re_status = RPC_CANTRECV;
435 goto out;
436 }
437
438 gettimeofday(&tv, NULL);
439 timersub(&tv, &starttime, &time_waited);
440
441 /* Check for timeout. */
442 if (timercmp(&time_waited, &timeout, >)) {
443 cu->cu_error.re_status = RPC_TIMEDOUT;
444 goto out;
445 }
446
447 /* Retransmit if necessary. */
448 if (timercmp(&time_waited, &next_sendtime, >)) {
449 /* update retransmit_time */
450 if (retransmit_time.tv_sec < RPC_MAX_BACKOFF)
451 timeradd(&retransmit_time, &retransmit_time,
452 &retransmit_time);
453 timeradd(&next_sendtime, &retransmit_time,
454 &next_sendtime);
455 goto send_again;
456 }
457 }
458
459 /*
460 * now decode and validate the response
461 */
462
463 xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)recvlen, XDR_DECODE);
464 ok = xdr_replymsg(&reply_xdrs, &reply_msg);
465 /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */
466 if (ok) {
467 if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
468 (reply_msg.acpted_rply.ar_stat == SUCCESS))
469 cu->cu_error.re_status = RPC_SUCCESS;
470 else
471 _seterr_reply(&reply_msg, &(cu->cu_error));
472
473 if (cu->cu_error.re_status == RPC_SUCCESS) {
474 if (! AUTH_VALIDATE(cl->cl_auth,
475 &reply_msg.acpted_rply.ar_verf)) {
476 cu->cu_error.re_status = RPC_AUTHERROR;
477 cu->cu_error.re_why = AUTH_INVALIDRESP;
478 }
479 if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
480 xdrs->x_op = XDR_FREE;
481 (void) xdr_opaque_auth(xdrs,
482 &(reply_msg.acpted_rply.ar_verf));
483 }
484 } /* end successful completion */
485 /*
486 * If unsuccessful AND error is an authentication error
487 * then refresh credentials and try again, else break
488 */
489 else if (cu->cu_error.re_status == RPC_AUTHERROR)
490 /* maybe our credentials need to be refreshed ... */
491 if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth)) {
492 nrefreshes--;
493 goto call_again;
494 }
495 /* end of unsuccessful completion */
496 } /* end of valid reply message */
497 else {
498 cu->cu_error.re_status = RPC_CANTDECODERES;
499
500 }
501 out:
502 release_fd_lock(cu->cu_fd, mask);
503 return (cu->cu_error.re_status);
504 }
505
506 static void
clnt_dg_geterr(CLIENT * cl,struct rpc_err * errp)507 clnt_dg_geterr(CLIENT *cl, struct rpc_err *errp)
508 {
509 struct cu_data *cu;
510
511 _DIAGASSERT(cl != NULL);
512 _DIAGASSERT(errp != NULL);
513
514 cu = (struct cu_data *)cl->cl_private;
515 *errp = cu->cu_error;
516 }
517
518 static bool_t
clnt_dg_freeres(CLIENT * cl,xdrproc_t xdr_res,caddr_t res_ptr)519 clnt_dg_freeres(CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
520 {
521 struct cu_data *cu;
522 XDR *xdrs;
523 bool_t dummy;
524 #ifdef _REENTRANT
525 sigset_t mask;
526 #endif
527 sigset_t newmask;
528
529 _DIAGASSERT(cl != NULL);
530 cu = (struct cu_data *)cl->cl_private;
531 xdrs = &(cu->cu_outxdrs);
532
533 __clnt_sigfillset(&newmask);
534 thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
535 mutex_lock(&clnt_fd_lock);
536 while (dg_fd_locks[cu->cu_fd])
537 cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
538 xdrs->x_op = XDR_FREE;
539 dummy = (*xdr_res)(xdrs, res_ptr);
540 mutex_unlock(&clnt_fd_lock);
541 thr_sigsetmask(SIG_SETMASK, &mask, NULL);
542 cond_signal(&dg_cv[cu->cu_fd]);
543 return (dummy);
544 }
545
546 /*ARGSUSED*/
547 static void
clnt_dg_abort(CLIENT * h)548 clnt_dg_abort(CLIENT *h)
549 {
550 }
551
552 static bool_t
clnt_dg_control(CLIENT * cl,u_int request,char * info)553 clnt_dg_control(CLIENT *cl, u_int request, char *info)
554 {
555 struct cu_data *cu;
556 struct netbuf *addr;
557 #ifdef _REENTRANT
558 sigset_t mask;
559 #endif
560 sigset_t newmask;
561
562 _DIAGASSERT(cl != NULL);
563 /* info is handled below */
564
565 cu = (struct cu_data *)cl->cl_private;
566
567 __clnt_sigfillset(&newmask);
568 thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
569 mutex_lock(&clnt_fd_lock);
570 while (dg_fd_locks[cu->cu_fd])
571 cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock);
572 dg_fd_locks[cu->cu_fd] = __rpc_lock_value;
573 mutex_unlock(&clnt_fd_lock);
574 switch (request) {
575 case CLSET_FD_CLOSE:
576 cu->cu_closeit = TRUE;
577 release_fd_lock(cu->cu_fd, mask);
578 return (TRUE);
579 case CLSET_FD_NCLOSE:
580 cu->cu_closeit = FALSE;
581 release_fd_lock(cu->cu_fd, mask);
582 return (TRUE);
583 }
584
585 /* for other requests which use info */
586 if (info == NULL) {
587 release_fd_lock(cu->cu_fd, mask);
588 return (FALSE);
589 }
590 switch (request) {
591 case CLSET_TIMEOUT:
592 if (time_not_ok((struct timeval *)(void *)info)) {
593 release_fd_lock(cu->cu_fd, mask);
594 return (FALSE);
595 }
596 cu->cu_total = *(struct timeval *)(void *)info;
597 break;
598 case CLGET_TIMEOUT:
599 *(struct timeval *)(void *)info = cu->cu_total;
600 break;
601 case CLGET_SERVER_ADDR: /* Give him the fd address */
602 /* Now obsolete. Only for backward compatibility */
603 (void) memcpy(info, &cu->cu_raddr, (size_t)cu->cu_rlen);
604 break;
605 case CLSET_RETRY_TIMEOUT:
606 if (time_not_ok((struct timeval *)(void *)info)) {
607 release_fd_lock(cu->cu_fd, mask);
608 return (FALSE);
609 }
610 cu->cu_wait = *(struct timeval *)(void *)info;
611 break;
612 case CLGET_RETRY_TIMEOUT:
613 *(struct timeval *)(void *)info = cu->cu_wait;
614 break;
615 case CLGET_FD:
616 *(int *)(void *)info = cu->cu_fd;
617 break;
618 case CLGET_SVC_ADDR:
619 addr = (struct netbuf *)(void *)info;
620 addr->buf = &cu->cu_raddr;
621 addr->len = cu->cu_rlen;
622 addr->maxlen = sizeof cu->cu_raddr;
623 break;
624 case CLSET_SVC_ADDR: /* set to new address */
625 addr = (struct netbuf *)(void *)info;
626 if (addr->len < sizeof cu->cu_raddr) {
627 release_fd_lock(cu->cu_fd, mask);
628 return (FALSE);
629 }
630 (void) memcpy(&cu->cu_raddr, addr->buf, (size_t)addr->len);
631 cu->cu_rlen = addr->len;
632 break;
633 case CLGET_XID:
634 /*
635 * use the knowledge that xid is the
636 * first element in the call structure *.
637 * This will get the xid of the PREVIOUS call
638 */
639 *(u_int32_t *)(void *)info =
640 ntohl(*(u_int32_t *)(void *)cu->cu_outbuf);
641 break;
642
643 case CLSET_XID:
644 /* This will set the xid of the NEXT call */
645 *(u_int32_t *)(void *)cu->cu_outbuf =
646 htonl(*(u_int32_t *)(void *)info - 1);
647 /* decrement by 1 as clnt_dg_call() increments once */
648 break;
649
650 case CLGET_VERS:
651 /*
652 * This RELIES on the information that, in the call body,
653 * the version number field is the fifth field from the
654 * beginning of the RPC header. MUST be changed if the
655 * call_struct is changed
656 */
657 *(u_int32_t *)(void *)info =
658 ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf +
659 4 * BYTES_PER_XDR_UNIT));
660 break;
661
662 case CLSET_VERS:
663 *(u_int32_t *)(void *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT)
664 = htonl(*(u_int32_t *)(void *)info);
665 break;
666
667 case CLGET_PROG:
668 /*
669 * This RELIES on the information that, in the call body,
670 * the program number field is the fourth field from the
671 * beginning of the RPC header. MUST be changed if the
672 * call_struct is changed
673 */
674 *(u_int32_t *)(void *)info =
675 ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf +
676 3 * BYTES_PER_XDR_UNIT));
677 break;
678
679 case CLSET_PROG:
680 *(u_int32_t *)(void *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT)
681 = htonl(*(u_int32_t *)(void *)info);
682 break;
683
684 default:
685 release_fd_lock(cu->cu_fd, mask);
686 return (FALSE);
687 }
688 release_fd_lock(cu->cu_fd, mask);
689 return (TRUE);
690 }
691
692 static void
clnt_dg_destroy(CLIENT * cl)693 clnt_dg_destroy(CLIENT *cl)
694 {
695 struct cu_data *cu;
696 int cu_fd;
697 #ifdef _REENTRANT
698 sigset_t mask;
699 #endif
700 sigset_t newmask;
701
702 _DIAGASSERT(cl != NULL);
703
704 cu = (struct cu_data *)cl->cl_private;
705 cu_fd = cu->cu_fd;
706
707 __clnt_sigfillset(&newmask);
708 thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
709 mutex_lock(&clnt_fd_lock);
710 while (dg_fd_locks[cu_fd])
711 cond_wait(&dg_cv[cu_fd], &clnt_fd_lock);
712 if (cu->cu_closeit)
713 (void) close(cu_fd);
714 XDR_DESTROY(&(cu->cu_outxdrs));
715 mem_free(cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
716 if (cl->cl_netid && cl->cl_netid[0])
717 mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
718 if (cl->cl_tp && cl->cl_tp[0])
719 mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
720 mem_free(cl, sizeof (CLIENT));
721 mutex_unlock(&clnt_fd_lock);
722 thr_sigsetmask(SIG_SETMASK, &mask, NULL);
723 cond_signal(&dg_cv[cu_fd]);
724 }
725
726 static struct clnt_ops *
clnt_dg_ops(void)727 clnt_dg_ops(void)
728 {
729 static struct clnt_ops ops;
730 #ifdef _REENTRANT
731 sigset_t mask;
732 #endif
733 sigset_t newmask;
734
735 /* VARIABLES PROTECTED BY ops_lock: ops */
736
737 __clnt_sigfillset(&newmask);
738 thr_sigsetmask(SIG_SETMASK, &newmask, &mask);
739 mutex_lock(&ops_lock);
740 if (ops.cl_call == NULL) {
741 ops.cl_call = clnt_dg_call;
742 ops.cl_abort = clnt_dg_abort;
743 ops.cl_geterr = clnt_dg_geterr;
744 ops.cl_freeres = clnt_dg_freeres;
745 ops.cl_destroy = clnt_dg_destroy;
746 ops.cl_control = clnt_dg_control;
747 }
748 mutex_unlock(&ops_lock);
749 thr_sigsetmask(SIG_SETMASK, &mask, NULL);
750 return (&ops);
751 }
752
753 /*
754 * Make sure that the time is not garbage. -1 value is allowed.
755 */
756 static bool_t
time_not_ok(struct timeval * t)757 time_not_ok(struct timeval *t)
758 {
759
760 _DIAGASSERT(t != NULL);
761
762 return (t->tv_sec < -1 || t->tv_sec > 100000000 ||
763 t->tv_usec < -1 || t->tv_usec > 1000000);
764 }
765