FreeBSD/Linux Kernel Cross Reference
sys/rpc/clnt_dg.c
1 /* $NetBSD: clnt_dg.c,v 1.4 2000/07/14 08:40:41 fvdl Exp $ */
2
3 /*
4 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
5 * unrestricted use provided that this legend is included on all tape
6 * media and as a part of the software program in whole or part. Users
7 * may copy or modify Sun RPC without charge, but are not authorized
8 * to license or distribute it to anyone else except as part of a product or
9 * program developed by the user.
10 *
11 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
12 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
13 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
14 *
15 * Sun RPC is provided with no support and without any obligation on the
16 * part of Sun Microsystems, Inc. to assist in its use, correction,
17 * modification or enhancement.
18 *
19 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
20 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
21 * OR ANY PART THEREOF.
22 *
23 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
24 * or profits or other special, indirect and consequential damages, even if
25 * Sun has been advised of the possibility of such damages.
26 *
27 * Sun Microsystems, Inc.
28 * 2550 Garcia Avenue
29 * Mountain View, California 94043
30 */
31 /*
32 * Copyright (c) 1986-1991 by Sun Microsystems Inc.
33 */
34
35 #if defined(LIBC_SCCS) && !defined(lint)
36 #ident "@(#)clnt_dg.c 1.23 94/04/22 SMI"
37 static char sccsid[] = "@(#)clnt_dg.c 1.19 89/03/16 Copyr 1988 Sun Micro";
38 #endif
39 #include <sys/cdefs.h>
40 __FBSDID("$FreeBSD: releng/6.4/sys/rpc/clnt_dg.c 178459 2008-04-24 10:46:25Z dfr $");
41
42 /*
43 * Implements a connectionless client side RPC.
44 */
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/lock.h>
49 #include <sys/malloc.h>
50 #include <sys/mbuf.h>
51 #include <sys/mutex.h>
52 #include <sys/pcpu.h>
53 #include <sys/proc.h>
54 #include <sys/socket.h>
55 #include <sys/socketvar.h>
56 #include <sys/time.h>
57 #include <sys/uio.h>
58
59 #include <rpc/rpc.h>
60 #include <rpc/rpc_com.h>
61
62
63 #ifdef _FREEFALL_CONFIG
64 /*
65 * Disable RPC exponential back-off for FreeBSD.org systems.
66 */
67 #define RPC_MAX_BACKOFF 1 /* second */
68 #else
69 #define RPC_MAX_BACKOFF 30 /* seconds */
70 #endif
71
72 static bool_t time_not_ok(struct timeval *);
73 static enum clnt_stat clnt_dg_call(CLIENT *, rpcproc_t, xdrproc_t, void *,
74 xdrproc_t, void *, struct timeval);
75 static void clnt_dg_geterr(CLIENT *, struct rpc_err *);
76 static bool_t clnt_dg_freeres(CLIENT *, xdrproc_t, void *);
77 static void clnt_dg_abort(CLIENT *);
78 static bool_t clnt_dg_control(CLIENT *, u_int, void *);
79 static void clnt_dg_destroy(CLIENT *);
80 static void clnt_dg_soupcall(struct socket *so, void *arg, int waitflag);
81
82 static struct clnt_ops clnt_dg_ops = {
83 .cl_call = clnt_dg_call,
84 .cl_abort = clnt_dg_abort,
85 .cl_geterr = clnt_dg_geterr,
86 .cl_freeres = clnt_dg_freeres,
87 .cl_destroy = clnt_dg_destroy,
88 .cl_control = clnt_dg_control
89 };
90
91 static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory";
92
93 /*
94 * A pending RPC request which awaits a reply.
95 */
96 struct cu_request {
97 TAILQ_ENTRY(cu_request) cr_link;
98 uint32_t cr_xid; /* XID of request */
99 struct mbuf *cr_mrep; /* reply received by upcall */
100 int cr_error; /* any error from upcall */
101 };
102
103 TAILQ_HEAD(cu_request_list, cu_request);
104
105 #define MCALL_MSG_SIZE 24
106
107 /*
108 * This structure is pointed to by the socket's so_upcallarg
109 * member. It is separate from the client private data to facilitate
110 * multiple clients sharing the same socket. The cs_lock mutex is used
111 * to protect all fields of this structure, the socket's receive
112 * buffer SOCKBUF_LOCK is used to ensure that exactly one of these
113 * structures is installed on the socket.
114 */
115 struct cu_socket {
116 struct mtx cs_lock;
117 int cs_refs; /* Count of clients */
118 struct cu_request_list cs_pending; /* Requests awaiting replies */
119
120 };
121
122 /*
123 * Private data kept per client handle
124 */
125 struct cu_data {
126 struct socket *cu_socket; /* connection socket */
127 bool_t cu_closeit; /* opened by library */
128 struct sockaddr_storage cu_raddr; /* remote address */
129 int cu_rlen;
130 struct timeval cu_wait; /* retransmit interval */
131 struct timeval cu_total; /* total time for the call */
132 struct rpc_err cu_error;
133 uint32_t cu_xid;
134 char cu_mcallc[MCALL_MSG_SIZE]; /* marshalled callmsg */
135 size_t cu_mcalllen;
136 size_t cu_sendsz; /* send size */
137 size_t cu_recvsz; /* recv size */
138 int cu_async;
139 int cu_connect; /* Use connect(). */
140 int cu_connected; /* Have done connect(). */
141 const char *cu_waitchan;
142 int cu_waitflag;
143 };
144
145 /*
146 * Connection less client creation returns with client handle parameters.
147 * Default options are set, which the user can change using clnt_control().
148 * fd should be open and bound.
149 * NB: The rpch->cl_auth is initialized to null authentication.
150 * Caller may wish to set this something more useful.
151 *
152 * sendsz and recvsz are the maximum allowable packet sizes that can be
153 * sent and received. Normally they are the same, but they can be
154 * changed to improve the program efficiency and buffer allocation.
155 * If they are 0, use the transport default.
156 *
157 * If svcaddr is NULL, returns NULL.
158 */
159 CLIENT *
160 clnt_dg_create(
161 struct socket *so,
162 struct sockaddr *svcaddr, /* servers address */
163 rpcprog_t program, /* program number */
164 rpcvers_t version, /* version number */
165 size_t sendsz, /* buffer recv size */
166 size_t recvsz) /* buffer send size */
167 {
168 CLIENT *cl = NULL; /* client handle */
169 struct cu_data *cu = NULL; /* private data */
170 struct cu_socket *cs = NULL;
171 struct timeval now;
172 struct rpc_msg call_msg;
173 struct __rpc_sockinfo si;
174 XDR xdrs;
175
176 if (svcaddr == NULL) {
177 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
178 return (NULL);
179 }
180
181 if (!__rpc_socket2sockinfo(so, &si)) {
182 rpc_createerr.cf_stat = RPC_TLIERROR;
183 rpc_createerr.cf_error.re_errno = 0;
184 return (NULL);
185 }
186
187 /*
188 * Find the receive and the send size
189 */
190 sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz);
191 recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz);
192 if ((sendsz == 0) || (recvsz == 0)) {
193 rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
194 rpc_createerr.cf_error.re_errno = 0;
195 return (NULL);
196 }
197
198 cl = mem_alloc(sizeof (CLIENT));
199
200 /*
201 * Should be multiple of 4 for XDR.
202 */
203 sendsz = ((sendsz + 3) / 4) * 4;
204 recvsz = ((recvsz + 3) / 4) * 4;
205 cu = mem_alloc(sizeof (*cu));
206 (void) memcpy(&cu->cu_raddr, svcaddr, (size_t)svcaddr->sa_len);
207 cu->cu_rlen = svcaddr->sa_len;
208 /* Other values can also be set through clnt_control() */
209 cu->cu_wait.tv_sec = 15; /* heuristically chosen */
210 cu->cu_wait.tv_usec = 0;
211 cu->cu_total.tv_sec = -1;
212 cu->cu_total.tv_usec = -1;
213 cu->cu_sendsz = sendsz;
214 cu->cu_recvsz = recvsz;
215 cu->cu_async = FALSE;
216 cu->cu_connect = FALSE;
217 cu->cu_connected = FALSE;
218 cu->cu_waitchan = "rpcrecv";
219 cu->cu_waitflag = 0;
220 (void) getmicrotime(&now);
221 cu->cu_xid = __RPC_GETXID(&now);
222 call_msg.rm_xid = cu->cu_xid;
223 call_msg.rm_call.cb_prog = program;
224 call_msg.rm_call.cb_vers = version;
225 xdrmem_create(&xdrs, cu->cu_mcallc, MCALL_MSG_SIZE, XDR_ENCODE);
226 if (! xdr_callhdr(&xdrs, &call_msg)) {
227 rpc_createerr.cf_stat = RPC_CANTENCODEARGS; /* XXX */
228 rpc_createerr.cf_error.re_errno = 0;
229 goto err2;
230 }
231 cu->cu_mcalllen = XDR_GETPOS(&xdrs);;
232
233 /*
234 * By default, closeit is always FALSE. It is users responsibility
235 * to do a close on it, else the user may use clnt_control
236 * to let clnt_destroy do it for him/her.
237 */
238 cu->cu_closeit = FALSE;
239 cu->cu_socket = so;
240
241 SOCKBUF_LOCK(&so->so_rcv);
242 recheck_socket:
243 if (so->so_upcall) {
244 if (so->so_upcall != clnt_dg_soupcall) {
245 SOCKBUF_UNLOCK(&so->so_rcv);
246 printf("clnt_dg_create(): socket already has an incompatible upcall\n");
247 goto err2;
248 }
249 cs = (struct cu_socket *) so->so_upcallarg;
250 mtx_lock(&cs->cs_lock);
251 cs->cs_refs++;
252 mtx_unlock(&cs->cs_lock);
253 } else {
254 /*
255 * We are the first on this socket - allocate the
256 * structure and install it in the socket.
257 */
258 SOCKBUF_UNLOCK(&cu->cu_socket->so_rcv);
259 cs = mem_alloc(sizeof(*cs));
260 SOCKBUF_LOCK(&cu->cu_socket->so_rcv);
261 if (so->so_upcall) {
262 /*
263 * We have lost a race with some other client.
264 */
265 mem_free(cs, sizeof(*cs));
266 goto recheck_socket;
267 }
268 mtx_init(&cs->cs_lock, "cs->cs_lock", NULL, MTX_DEF);
269 cs->cs_refs = 1;
270 TAILQ_INIT(&cs->cs_pending);
271 so->so_upcallarg = cs;
272 so->so_upcall = clnt_dg_soupcall;
273 so->so_rcv.sb_flags |= SB_UPCALL;
274 }
275 SOCKBUF_UNLOCK(&so->so_rcv);
276
277 cl->cl_ops = &clnt_dg_ops;
278 cl->cl_private = (caddr_t)(void *)cu;
279 cl->cl_auth = authnone_create();
280 cl->cl_tp = NULL;
281 cl->cl_netid = NULL;
282 return (cl);
283 err2:
284 if (cl) {
285 mem_free(cl, sizeof (CLIENT));
286 if (cu)
287 mem_free(cu, sizeof (*cu));
288 }
289 return (NULL);
290 }
291
292 static enum clnt_stat
293 clnt_dg_call(
294 CLIENT *cl, /* client handle */
295 rpcproc_t proc, /* procedure number */
296 xdrproc_t xargs, /* xdr routine for args */
297 void *argsp, /* pointer to args */
298 xdrproc_t xresults, /* xdr routine for results */
299 void *resultsp, /* pointer to results */
300 struct timeval utimeout) /* seconds to wait before giving up */
301 {
302 struct cu_data *cu = (struct cu_data *)cl->cl_private;
303 struct cu_socket *cs = (struct cu_socket *) cu->cu_socket->so_upcallarg;
304 XDR xdrs;
305 struct rpc_msg reply_msg;
306 bool_t ok;
307 int nrefreshes = 2; /* number of times to refresh cred */
308 struct timeval timeout;
309 struct timeval retransmit_time;
310 struct timeval next_sendtime, starttime, time_waited, tv;
311 struct sockaddr *sa;
312 socklen_t salen;
313 uint32_t xid;
314 struct mbuf *mreq = NULL;
315 struct cu_request cr;
316 int error;
317
318 mtx_lock(&cs->cs_lock);
319
320 cr.cr_mrep = NULL;
321 cr.cr_error = 0;
322
323 if (cu->cu_total.tv_usec == -1) {
324 timeout = utimeout; /* use supplied timeout */
325 } else {
326 timeout = cu->cu_total; /* use default timeout */
327 }
328
329 if (cu->cu_connect && !cu->cu_connected) {
330 mtx_unlock(&cs->cs_lock);
331 error = soconnect(cu->cu_socket,
332 (struct sockaddr *)&cu->cu_raddr, curthread);
333 mtx_lock(&cs->cs_lock);
334 if (error) {
335 cu->cu_error.re_errno = error;
336 cu->cu_error.re_status = RPC_CANTSEND;
337 goto out;
338 }
339 cu->cu_connected = 1;
340 }
341 if (cu->cu_connected) {
342 sa = NULL;
343 salen = 0;
344 } else {
345 sa = (struct sockaddr *)&cu->cu_raddr;
346 salen = cu->cu_rlen;
347 }
348 time_waited.tv_sec = 0;
349 time_waited.tv_usec = 0;
350 retransmit_time = next_sendtime = cu->cu_wait;
351
352 getmicrotime(&starttime);
353
354 call_again:
355 mtx_assert(&cs->cs_lock, MA_OWNED);
356
357 cu->cu_xid++;
358 xid = cu->cu_xid;
359
360 send_again:
361 mtx_unlock(&cs->cs_lock);
362
363 MGETHDR(mreq, M_WAIT, MT_DATA);
364 MCLGET(mreq, M_WAIT);
365 mreq->m_len = 0;
366 m_append(mreq, cu->cu_mcalllen, cu->cu_mcallc);
367
368 /*
369 * The XID is the first thing in the request.
370 */
371 *mtod(mreq, uint32_t *) = htonl(xid);
372
373 xdrmbuf_create(&xdrs, mreq, XDR_ENCODE);
374
375 if (cu->cu_async == TRUE && xargs == NULL)
376 goto get_reply;
377
378 if ((! XDR_PUTINT32(&xdrs, &proc)) ||
379 (! AUTH_MARSHALL(cl->cl_auth, &xdrs)) ||
380 (! (*xargs)(&xdrs, argsp))) {
381 cu->cu_error.re_status = RPC_CANTENCODEARGS;
382 mtx_lock(&cs->cs_lock);
383 goto out;
384 }
385 m_fixhdr(mreq);
386
387 cr.cr_xid = xid;
388 mtx_lock(&cs->cs_lock);
389 TAILQ_INSERT_TAIL(&cs->cs_pending, &cr, cr_link);
390 mtx_unlock(&cs->cs_lock);
391
392 /*
393 * sosend consumes mreq.
394 */
395 error = sosend(cu->cu_socket, sa, NULL, mreq, NULL, 0, curthread);
396 mreq = NULL;
397
398 /*
399 * sub-optimal code appears here because we have
400 * some clock time to spare while the packets are in flight.
401 * (We assume that this is actually only executed once.)
402 */
403 reply_msg.acpted_rply.ar_verf = _null_auth;
404 reply_msg.acpted_rply.ar_results.where = resultsp;
405 reply_msg.acpted_rply.ar_results.proc = xresults;
406
407 mtx_lock(&cs->cs_lock);
408 if (error) {
409 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
410
411 cu->cu_error.re_errno = error;
412 cu->cu_error.re_status = RPC_CANTSEND;
413 goto out;
414 }
415
416 /*
417 * Check to see if we got an upcall while waiting for the
418 * lock. In both these cases, the request has been removed
419 * from cs->cs_pending.
420 */
421 if (cr.cr_error) {
422 cu->cu_error.re_errno = cr.cr_error;
423 cu->cu_error.re_status = RPC_CANTRECV;
424 goto out;
425 }
426 if (cr.cr_mrep) {
427 goto got_reply;
428 }
429
430 /*
431 * Hack to provide rpc-based message passing
432 */
433 if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
434 if (cr.cr_xid)
435 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
436 cu->cu_error.re_status = RPC_TIMEDOUT;
437 goto out;
438 }
439
440 get_reply:
441 for (;;) {
442 /* Decide how long to wait. */
443 if (timevalcmp(&next_sendtime, &timeout, <)) {
444 tv = next_sendtime;
445 } else {
446 tv = timeout;
447 }
448 timevalsub(&tv, &time_waited);
449 if (tv.tv_sec < 0 || tv.tv_usec < 0)
450 tv.tv_sec = tv.tv_usec = 0;
451
452 error = msleep(&cr, &cs->cs_lock, cu->cu_waitflag,
453 cu->cu_waitchan, tvtohz(&tv));
454
455 if (!error) {
456 /*
457 * We were woken up by the upcall. If the
458 * upcall had a receive error, report that,
459 * otherwise we have a reply.
460 */
461 if (cr.cr_error) {
462 cu->cu_error.re_errno = cr.cr_error;
463 cu->cu_error.re_status = RPC_CANTRECV;
464 goto out;
465 }
466 break;
467 }
468
469 /*
470 * The sleep returned an error so our request is still
471 * on the list. If we got EWOULDBLOCK, we may want to
472 * re-send the request.
473 */
474 if (error != EWOULDBLOCK) {
475 if (cr.cr_xid)
476 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
477 cu->cu_error.re_errno = error;
478 if (error == EINTR)
479 cu->cu_error.re_status = RPC_INTR;
480 else
481 cu->cu_error.re_status = RPC_CANTRECV;
482 goto out;
483 }
484
485 getmicrotime(&tv);
486 time_waited = tv;
487 timevalsub(&time_waited, &starttime);
488
489 /* Check for timeout. */
490 if (timevalcmp(&time_waited, &timeout, >)) {
491 if (cr.cr_xid)
492 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
493 cu->cu_error.re_errno = EWOULDBLOCK;
494 cu->cu_error.re_status = RPC_TIMEDOUT;
495 goto out;
496 }
497
498 /* Retransmit if necessary. */
499 if (timevalcmp(&time_waited, &next_sendtime, >)) {
500 if (cr.cr_xid)
501 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
502 /* update retransmit_time */
503 if (retransmit_time.tv_sec < RPC_MAX_BACKOFF)
504 timevaladd(&retransmit_time, &retransmit_time);
505 timevaladd(&next_sendtime, &retransmit_time);
506 goto send_again;
507 }
508 }
509
510 got_reply:
511 /*
512 * Now decode and validate the response. We need to drop the
513 * lock since xdr_replymsg may end up sleeping in malloc.
514 */
515 mtx_unlock(&cs->cs_lock);
516
517 xdrmbuf_create(&xdrs, cr.cr_mrep, XDR_DECODE);
518 ok = xdr_replymsg(&xdrs, &reply_msg);
519 XDR_DESTROY(&xdrs);
520 cr.cr_mrep = NULL;
521
522 mtx_lock(&cs->cs_lock);
523
524 if (ok) {
525 if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
526 (reply_msg.acpted_rply.ar_stat == SUCCESS))
527 cu->cu_error.re_status = RPC_SUCCESS;
528 else
529 _seterr_reply(&reply_msg, &(cu->cu_error));
530
531 if (cu->cu_error.re_status == RPC_SUCCESS) {
532 if (! AUTH_VALIDATE(cl->cl_auth,
533 &reply_msg.acpted_rply.ar_verf)) {
534 cu->cu_error.re_status = RPC_AUTHERROR;
535 cu->cu_error.re_why = AUTH_INVALIDRESP;
536 }
537 if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
538 xdrs.x_op = XDR_FREE;
539 (void) xdr_opaque_auth(&xdrs,
540 &(reply_msg.acpted_rply.ar_verf));
541 }
542 } /* end successful completion */
543 /*
544 * If unsuccesful AND error is an authentication error
545 * then refresh credentials and try again, else break
546 */
547 else if (cu->cu_error.re_status == RPC_AUTHERROR)
548 /* maybe our credentials need to be refreshed ... */
549 if (nrefreshes > 0 &&
550 AUTH_REFRESH(cl->cl_auth, &reply_msg)) {
551 nrefreshes--;
552 goto call_again;
553 }
554 /* end of unsuccessful completion */
555 } /* end of valid reply message */
556 else {
557 cu->cu_error.re_status = RPC_CANTDECODERES;
558
559 }
560 out:
561 mtx_assert(&cs->cs_lock, MA_OWNED);
562
563 if (mreq)
564 m_freem(mreq);
565 if (cr.cr_mrep)
566 m_freem(cr.cr_mrep);
567
568 mtx_unlock(&cs->cs_lock);
569 return (cu->cu_error.re_status);
570 }
571
572 static void
573 clnt_dg_geterr(CLIENT *cl, struct rpc_err *errp)
574 {
575 struct cu_data *cu = (struct cu_data *)cl->cl_private;
576
577 *errp = cu->cu_error;
578 }
579
580 static bool_t
581 clnt_dg_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
582 {
583 XDR xdrs;
584 bool_t dummy;
585
586 xdrs.x_op = XDR_FREE;
587 dummy = (*xdr_res)(&xdrs, res_ptr);
588
589 return (dummy);
590 }
591
592 /*ARGSUSED*/
593 static void
594 clnt_dg_abort(CLIENT *h)
595 {
596 }
597
598 static bool_t
599 clnt_dg_control(CLIENT *cl, u_int request, void *info)
600 {
601 struct cu_data *cu = (struct cu_data *)cl->cl_private;
602 struct cu_socket *cs = (struct cu_socket *) cu->cu_socket->so_upcallarg;
603 struct sockaddr *addr;
604
605 mtx_lock(&cs->cs_lock);
606
607 switch (request) {
608 case CLSET_FD_CLOSE:
609 cu->cu_closeit = TRUE;
610 mtx_unlock(&cs->cs_lock);
611 return (TRUE);
612 case CLSET_FD_NCLOSE:
613 cu->cu_closeit = FALSE;
614 mtx_unlock(&cs->cs_lock);
615 return (TRUE);
616 }
617
618 /* for other requests which use info */
619 if (info == NULL) {
620 mtx_unlock(&cs->cs_lock);
621 return (FALSE);
622 }
623 switch (request) {
624 case CLSET_TIMEOUT:
625 if (time_not_ok((struct timeval *)info)) {
626 mtx_unlock(&cs->cs_lock);
627 return (FALSE);
628 }
629 cu->cu_total = *(struct timeval *)info;
630 break;
631 case CLGET_TIMEOUT:
632 *(struct timeval *)info = cu->cu_total;
633 break;
634 case CLSET_RETRY_TIMEOUT:
635 if (time_not_ok((struct timeval *)info)) {
636 mtx_unlock(&cs->cs_lock);
637 return (FALSE);
638 }
639 cu->cu_wait = *(struct timeval *)info;
640 break;
641 case CLGET_RETRY_TIMEOUT:
642 *(struct timeval *)info = cu->cu_wait;
643 break;
644 case CLGET_SVC_ADDR:
645 /*
646 * Slightly different semantics to userland - we use
647 * sockaddr instead of netbuf.
648 */
649 memcpy(info, &cu->cu_raddr, cu->cu_raddr.ss_len);
650 break;
651 case CLSET_SVC_ADDR: /* set to new address */
652 addr = (struct sockaddr *)info;
653 (void) memcpy(&cu->cu_raddr, addr, addr->sa_len);
654 break;
655 case CLGET_XID:
656 *(uint32_t *)info = cu->cu_xid;
657 break;
658
659 case CLSET_XID:
660 /* This will set the xid of the NEXT call */
661 /* decrement by 1 as clnt_dg_call() increments once */
662 cu->cu_xid = *(uint32_t *)info - 1;
663 break;
664
665 case CLGET_VERS:
666 /*
667 * This RELIES on the information that, in the call body,
668 * the version number field is the fifth field from the
669 * begining of the RPC header. MUST be changed if the
670 * call_struct is changed
671 */
672 *(uint32_t *)info =
673 ntohl(*(uint32_t *)(void *)(cu->cu_mcallc +
674 4 * BYTES_PER_XDR_UNIT));
675 break;
676
677 case CLSET_VERS:
678 *(uint32_t *)(void *)(cu->cu_mcallc + 4 * BYTES_PER_XDR_UNIT)
679 = htonl(*(uint32_t *)info);
680 break;
681
682 case CLGET_PROG:
683 /*
684 * This RELIES on the information that, in the call body,
685 * the program number field is the fourth field from the
686 * begining of the RPC header. MUST be changed if the
687 * call_struct is changed
688 */
689 *(uint32_t *)info =
690 ntohl(*(uint32_t *)(void *)(cu->cu_mcallc +
691 3 * BYTES_PER_XDR_UNIT));
692 break;
693
694 case CLSET_PROG:
695 *(uint32_t *)(void *)(cu->cu_mcallc + 3 * BYTES_PER_XDR_UNIT)
696 = htonl(*(uint32_t *)info);
697 break;
698 case CLSET_ASYNC:
699 cu->cu_async = *(int *)info;
700 break;
701 case CLSET_CONNECT:
702 cu->cu_connect = *(int *)info;
703 break;
704 case CLSET_WAITCHAN:
705 cu->cu_waitchan = *(const char **)info;
706 break;
707 case CLGET_WAITCHAN:
708 *(const char **) info = cu->cu_waitchan;
709 break;
710 case CLSET_INTERRUPTIBLE:
711 if (*(int *) info)
712 cu->cu_waitflag = PCATCH;
713 else
714 cu->cu_waitflag = 0;
715 break;
716 case CLGET_INTERRUPTIBLE:
717 if (cu->cu_waitflag)
718 *(int *) info = TRUE;
719 else
720 *(int *) info = FALSE;
721 break;
722 default:
723 mtx_unlock(&cs->cs_lock);
724 return (FALSE);
725 }
726 mtx_unlock(&cs->cs_lock);
727 return (TRUE);
728 }
729
730 static void
731 clnt_dg_destroy(CLIENT *cl)
732 {
733 struct cu_data *cu = (struct cu_data *)cl->cl_private;
734 struct cu_socket *cs = (struct cu_socket *) cu->cu_socket->so_upcallarg;
735 struct socket *so = NULL;
736 bool_t lastsocketref;
737
738 SOCKBUF_LOCK(&cu->cu_socket->so_rcv);
739
740 mtx_lock(&cs->cs_lock);
741 cs->cs_refs--;
742 if (cs->cs_refs == 0) {
743 cu->cu_socket->so_upcallarg = NULL;
744 cu->cu_socket->so_upcall = NULL;
745 cu->cu_socket->so_rcv.sb_flags &= ~SB_UPCALL;
746 mtx_destroy(&cs->cs_lock);
747 SOCKBUF_UNLOCK(&cu->cu_socket->so_rcv);
748 mem_free(cs, sizeof(*cs));
749 lastsocketref = TRUE;
750 } else {
751 mtx_unlock(&cs->cs_lock);
752 SOCKBUF_UNLOCK(&cu->cu_socket->so_rcv);
753 lastsocketref = FALSE;
754 }
755
756 if (cu->cu_closeit) {
757 KASSERT(lastsocketref, ("clnt_dg_destroy(): closing a socket "
758 "shared with other clients"));
759 so = cu->cu_socket;
760 cu->cu_socket = NULL;
761 }
762
763 if (so)
764 soclose(so);
765
766 if (cl->cl_netid && cl->cl_netid[0])
767 mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
768 if (cl->cl_tp && cl->cl_tp[0])
769 mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
770 mem_free(cu, sizeof (*cu));
771 mem_free(cl, sizeof (CLIENT));
772 }
773
774 /*
775 * Make sure that the time is not garbage. -1 value is allowed.
776 */
777 static bool_t
778 time_not_ok(struct timeval *t)
779 {
780 return (t->tv_sec < -1 || t->tv_sec > 100000000 ||
781 t->tv_usec < -1 || t->tv_usec > 1000000);
782 }
783
784 void
785 clnt_dg_soupcall(struct socket *so, void *arg, int waitflag)
786 {
787 struct cu_socket *cs = (struct cu_socket *) arg;
788 struct uio uio;
789 struct mbuf *m;
790 struct mbuf *control;
791 struct cu_request *cr;
792 int error, rcvflag, foundreq;
793 uint32_t xid;
794
795 uio.uio_resid = 1000000000;
796 uio.uio_td = curthread;
797 do {
798 m = NULL;
799 control = NULL;
800 rcvflag = MSG_DONTWAIT;
801 error = soreceive(so, NULL, &uio, &m, &control, &rcvflag);
802 if (control)
803 m_freem(control);
804
805 if (error == EWOULDBLOCK)
806 break;
807
808 /*
809 * If there was an error, wake up all pending
810 * requests.
811 */
812 if (error) {
813 mtx_lock(&cs->cs_lock);
814 TAILQ_FOREACH(cr, &cs->cs_pending, cr_link) {
815 cr->cr_error = error;
816 wakeup(cr);
817 }
818 TAILQ_INIT(&cs->cs_pending);
819 mtx_unlock(&cs->cs_lock);
820 break;
821 }
822
823 /*
824 * The XID is in the first uint32_t of the reply.
825 */
826 m = m_pullup(m, sizeof(xid));
827 if (!m)
828 break;
829 xid = ntohl(*mtod(m, uint32_t *));
830
831 /*
832 * Attempt to match this reply with a pending request.
833 */
834 mtx_lock(&cs->cs_lock);
835 foundreq = 0;
836 TAILQ_FOREACH(cr, &cs->cs_pending, cr_link) {
837 if (cr->cr_xid == xid) {
838 /*
839 * This one matches. We snip it out of
840 * the pending list and leave the
841 * reply mbuf in cr->cr_mrep. Set the
842 * XID to zero so that clnt_dg_call
843 * can know not to repeat the
844 * TAILQ_REMOVE.
845 */
846 TAILQ_REMOVE(&cs->cs_pending, cr, cr_link);
847 cr->cr_xid = 0;
848 cr->cr_mrep = m;
849 cr->cr_error = 0;
850 foundreq = 1;
851 wakeup(cr);
852 break;
853 }
854 }
855 mtx_unlock(&cs->cs_lock);
856
857 /*
858 * If we didn't find the matching request, just drop
859 * it - its probably a repeated reply.
860 */
861 if (!foundreq)
862 m_freem(m);
863 } while (m);
864 }
865
Cache object: dea90f6260a8fbce57a5bf294c191731
|