xref: /freebsd/sys/rpc/clnt_bck.c (revision 57718be8fa0bd5edc11ab9a72e68cc71982939a6) 
1 /*	$NetBSD: clnt_vc.c,v 1.4 2000/07/14 08:40:42 fvdl Exp $	*/
2 
3 /*-
4  * Copyright (c) 2009, Sun Microsystems, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  * - Redistributions of source code must retain the above copyright notice,
10  *   this list of conditions and the following disclaimer.
11  * - Redistributions in binary form must reproduce the above copyright notice,
12  *   this list of conditions and the following disclaimer in the documentation
13  *   and/or other materials provided with the distribution.
14  * - Neither the name of Sun Microsystems, Inc. nor the names of its
15  *   contributors may be used to endorse or promote products derived
16  *   from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
28  * POSSIBILITY OF SUCH DAMAGE.
29  */
30 
31 #if defined(LIBC_SCCS) && !defined(lint)
32 static char *sccsid2 = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro";
33 static char *sccsid = "@(#)clnt_tcp.c	2.2 88/08/01 4.0 RPCSRC";
34 static char sccsid3[] = "@(#)clnt_vc.c 1.19 89/03/16 Copyr 1988 Sun Micro";
35 #endif
36 #include <sys/cdefs.h>
37 __FBSDID("$FreeBSD$");
38 
39 /*
40  * clnt_tcp.c, Implements a TCP/IP based, client side RPC.
41  *
42  * Copyright (C) 1984, Sun Microsystems, Inc.
43  *
44  * TCP based RPC supports 'batched calls'.
45  * A sequence of calls may be batched-up in a send buffer.  The rpc call
46  * return immediately to the client even though the call was not necessarily
47  * sent.  The batching occurs if the results' xdr routine is NULL (0) AND
48  * the rpc timeout value is zero (see clnt.h, rpc).
49  *
50  * Clients should NOT casually batch calls that in fact return results; that is,
51  * the server side should be aware that a call is batched and not produce any
52  * return message.  Batched calls that produce many result messages can
53  * deadlock (netlock) the client and the server....
54  *
55  * Now go hang yourself.
56  */
57 
58 /*
59  * This code handles the special case of a NFSv4.n backchannel for
60  * callback RPCs. It is similar to clnt_vc.c, but uses the TCP
61  * connection provided by the client to the server.
62  */
63 
64 #include <sys/param.h>
65 #include <sys/systm.h>
66 #include <sys/lock.h>
67 #include <sys/malloc.h>
68 #include <sys/mbuf.h>
69 #include <sys/mutex.h>
70 #include <sys/pcpu.h>
71 #include <sys/proc.h>
72 #include <sys/protosw.h>
73 #include <sys/socket.h>
74 #include <sys/socketvar.h>
75 #include <sys/sx.h>
76 #include <sys/syslog.h>
77 #include <sys/time.h>
78 #include <sys/uio.h>
79 
80 #include <net/vnet.h>
81 
82 #include <netinet/tcp.h>
83 
84 #include <rpc/rpc.h>
85 #include <rpc/rpc_com.h>
86 #include <rpc/krpc.h>
87 
88 struct cmessage {
89         struct cmsghdr cmsg;
90         struct cmsgcred cmcred;
91 };
92 
93 static void clnt_bck_geterr(CLIENT *, struct rpc_err *);
94 static bool_t clnt_bck_freeres(CLIENT *, xdrproc_t, void *);
95 static void clnt_bck_abort(CLIENT *);
96 static bool_t clnt_bck_control(CLIENT *, u_int, void *);
97 static void clnt_bck_close(CLIENT *);
98 static void clnt_bck_destroy(CLIENT *);
99 
100 static struct clnt_ops clnt_bck_ops = {
101 	.cl_abort =	clnt_bck_abort,
102 	.cl_geterr =	clnt_bck_geterr,
103 	.cl_freeres =	clnt_bck_freeres,
104 	.cl_close =	clnt_bck_close,
105 	.cl_destroy =	clnt_bck_destroy,
106 	.cl_control =	clnt_bck_control
107 };
108 
109 /*
110  * Create a client handle for a connection.
111  * Default options are set, which the user can change using clnt_control()'s.
112  * This code handles the special case of an NFSv4.1 session backchannel
113  * call, which is sent on a TCP connection created against the server
114  * by a client.
115  */
116 void *
117 clnt_bck_create(
118 	struct socket *so,		/* Server transport socket. */
119 	const rpcprog_t prog,		/* program number */
120 	const rpcvers_t vers)		/* version number */
121 {
122 	CLIENT *cl;			/* client handle */
123 	struct ct_data *ct = NULL;	/* client handle */
124 	struct timeval now;
125 	struct rpc_msg call_msg;
126 	static uint32_t disrupt;
127 	XDR xdrs;
128 
129 	if (disrupt == 0)
130 		disrupt = (uint32_t)(long)so;
131 
132 	cl = (CLIENT *)mem_alloc(sizeof (*cl));
133 	ct = (struct ct_data *)mem_alloc(sizeof (*ct));
134 
135 	mtx_init(&ct->ct_lock, "ct->ct_lock", NULL, MTX_DEF);
136 	ct->ct_threads = 0;
137 	ct->ct_closing = FALSE;
138 	ct->ct_closed = FALSE;
139 	ct->ct_upcallrefs = 0;
140 	ct->ct_closeit = FALSE;
141 
142 	/*
143 	 * Set up private data struct
144 	 */
145 	ct->ct_wait.tv_sec = -1;
146 	ct->ct_wait.tv_usec = -1;
147 
148 	/*
149 	 * Initialize call message
150 	 */
151 	getmicrotime(&now);
152 	ct->ct_xid = ((uint32_t)++disrupt) ^ __RPC_GETXID(&now);
153 	call_msg.rm_xid = ct->ct_xid;
154 	call_msg.rm_direction = CALL;
155 	call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
156 	call_msg.rm_call.cb_prog = (uint32_t)prog;
157 	call_msg.rm_call.cb_vers = (uint32_t)vers;
158 
159 	/*
160 	 * pre-serialize the static part of the call msg and stash it away
161 	 */
162 	xdrmem_create(&xdrs, ct->ct_mcallc, MCALL_MSG_SIZE,
163 	    XDR_ENCODE);
164 	if (!xdr_callhdr(&xdrs, &call_msg))
165 		goto err;
166 	ct->ct_mpos = XDR_GETPOS(&xdrs);
167 	XDR_DESTROY(&xdrs);
168 	ct->ct_waitchan = "rpcbck";
169 	ct->ct_waitflag = 0;
170 	cl->cl_refs = 1;
171 	cl->cl_ops = &clnt_bck_ops;
172 	cl->cl_private = ct;
173 	cl->cl_auth = authnone_create();
174 	TAILQ_INIT(&ct->ct_pending);
175 	return (cl);
176 
177 err:
178 	if (cl) {
179 		if (ct) {
180 			mtx_destroy(&ct->ct_lock);
181 			mem_free(ct, sizeof (struct ct_data));
182 		}
183 		if (cl)
184 			mem_free(cl, sizeof (CLIENT));
185 	}
186 	return (NULL);
187 }
188 
189 enum clnt_stat
190 clnt_bck_call(
191 	CLIENT		*cl,		/* client handle */
192 	struct rpc_callextra *ext,	/* call metadata */
193 	rpcproc_t	proc,		/* procedure number */
194 	struct mbuf	*args,		/* pointer to args */
195 	struct mbuf	**resultsp,	/* pointer to results */
196 	struct timeval	utimeout,
197 	SVCXPRT		*xprt)
198 {
199 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
200 	AUTH *auth;
201 	struct rpc_err *errp;
202 	enum clnt_stat stat;
203 	XDR xdrs;
204 	struct rpc_msg reply_msg;
205 	bool_t ok;
206 	int nrefreshes = 2;		/* number of times to refresh cred */
207 	struct timeval timeout;
208 	uint32_t xid;
209 	struct mbuf *mreq = NULL, *results;
210 	struct ct_request *cr;
211 	int error;
212 
213 	cr = malloc(sizeof(struct ct_request), M_RPC, M_WAITOK);
214 
215 	mtx_lock(&ct->ct_lock);
216 
217 	if (ct->ct_closing || ct->ct_closed) {
218 		mtx_unlock(&ct->ct_lock);
219 		free(cr, M_RPC);
220 		return (RPC_CANTSEND);
221 	}
222 	ct->ct_threads++;
223 
224 	if (ext) {
225 		auth = ext->rc_auth;
226 		errp = &ext->rc_err;
227 	} else {
228 		auth = cl->cl_auth;
229 		errp = &ct->ct_error;
230 	}
231 
232 	cr->cr_mrep = NULL;
233 	cr->cr_error = 0;
234 
235 	if (ct->ct_wait.tv_usec == -1)
236 		timeout = utimeout;	/* use supplied timeout */
237 	else
238 		timeout = ct->ct_wait;	/* use default timeout */
239 
240 call_again:
241 	mtx_assert(&ct->ct_lock, MA_OWNED);
242 
243 	ct->ct_xid++;
244 	xid = ct->ct_xid;
245 
246 	mtx_unlock(&ct->ct_lock);
247 
248 	/*
249 	 * Leave space to pre-pend the record mark.
250 	 */
251 	mreq = m_gethdr(M_WAITOK, MT_DATA);
252 	mreq->m_data += sizeof(uint32_t);
253 	KASSERT(ct->ct_mpos + sizeof(uint32_t) <= MHLEN,
254 	    ("RPC header too big"));
255 	bcopy(ct->ct_mcallc, mreq->m_data, ct->ct_mpos);
256 	mreq->m_len = ct->ct_mpos;
257 
258 	/*
259 	 * The XID is the first thing in the request.
260 	 */
261 	*mtod(mreq, uint32_t *) = htonl(xid);
262 
263 	xdrmbuf_create(&xdrs, mreq, XDR_ENCODE);
264 
265 	errp->re_status = stat = RPC_SUCCESS;
266 
267 	if ((!XDR_PUTINT32(&xdrs, &proc)) ||
268 	    (!AUTH_MARSHALL(auth, xid, &xdrs,
269 	     m_copym(args, 0, M_COPYALL, M_WAITOK)))) {
270 		errp->re_status = stat = RPC_CANTENCODEARGS;
271 		mtx_lock(&ct->ct_lock);
272 		goto out;
273 	}
274 	mreq->m_pkthdr.len = m_length(mreq, NULL);
275 
276 	/*
277 	 * Prepend a record marker containing the packet length.
278 	 */
279 	M_PREPEND(mreq, sizeof(uint32_t), M_WAITOK);
280 	*mtod(mreq, uint32_t *) =
281 	    htonl(0x80000000 | (mreq->m_pkthdr.len - sizeof(uint32_t)));
282 
283 	cr->cr_xid = xid;
284 	mtx_lock(&ct->ct_lock);
285 	/*
286 	 * Check to see if the client end has already started to close down
287 	 * the connection. The svc code will have set ct_error.re_status
288 	 * to RPC_CANTRECV if this is the case.
289 	 * If the client starts to close down the connection after this
290 	 * point, it will be detected later when cr_error is checked,
291 	 * since the request is in the ct_pending queue.
292 	 */
293 	if (ct->ct_error.re_status == RPC_CANTRECV) {
294 		if (errp != &ct->ct_error) {
295 			errp->re_errno = ct->ct_error.re_errno;
296 			errp->re_status = RPC_CANTRECV;
297 		}
298 		stat = RPC_CANTRECV;
299 		goto out;
300 	}
301 	TAILQ_INSERT_TAIL(&ct->ct_pending, cr, cr_link);
302 	mtx_unlock(&ct->ct_lock);
303 
304 	/*
305 	 * sosend consumes mreq.
306 	 */
307 	sx_xlock(&xprt->xp_lock);
308 	error = sosend(xprt->xp_socket, NULL, NULL, mreq, NULL, 0, curthread);
309 if (error != 0) printf("sosend=%d\n", error);
310 	mreq = NULL;
311 	if (error == EMSGSIZE) {
312 printf("emsgsize\n");
313 		SOCKBUF_LOCK(&xprt->xp_socket->so_snd);
314 		sbwait(&xprt->xp_socket->so_snd);
315 		SOCKBUF_UNLOCK(&xprt->xp_socket->so_snd);
316 		sx_xunlock(&xprt->xp_lock);
317 		AUTH_VALIDATE(auth, xid, NULL, NULL);
318 		mtx_lock(&ct->ct_lock);
319 		TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
320 		goto call_again;
321 	}
322 	sx_xunlock(&xprt->xp_lock);
323 
324 	reply_msg.acpted_rply.ar_verf.oa_flavor = AUTH_NULL;
325 	reply_msg.acpted_rply.ar_verf.oa_base = cr->cr_verf;
326 	reply_msg.acpted_rply.ar_verf.oa_length = 0;
327 	reply_msg.acpted_rply.ar_results.where = NULL;
328 	reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
329 
330 	mtx_lock(&ct->ct_lock);
331 	if (error) {
332 		TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
333 		errp->re_errno = error;
334 		errp->re_status = stat = RPC_CANTSEND;
335 		goto out;
336 	}
337 
338 	/*
339 	 * Check to see if we got an upcall while waiting for the
340 	 * lock. In both these cases, the request has been removed
341 	 * from ct->ct_pending.
342 	 */
343 	if (cr->cr_error) {
344 		TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
345 		errp->re_errno = cr->cr_error;
346 		errp->re_status = stat = RPC_CANTRECV;
347 		goto out;
348 	}
349 	if (cr->cr_mrep) {
350 		TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
351 		goto got_reply;
352 	}
353 
354 	/*
355 	 * Hack to provide rpc-based message passing
356 	 */
357 	if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
358 		TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
359 		errp->re_status = stat = RPC_TIMEDOUT;
360 		goto out;
361 	}
362 
363 	error = msleep(cr, &ct->ct_lock, ct->ct_waitflag, ct->ct_waitchan,
364 	    tvtohz(&timeout));
365 
366 	TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
367 
368 	if (error) {
369 		/*
370 		 * The sleep returned an error so our request is still
371 		 * on the list. Turn the error code into an
372 		 * appropriate client status.
373 		 */
374 		errp->re_errno = error;
375 		switch (error) {
376 		case EINTR:
377 			stat = RPC_INTR;
378 			break;
379 		case EWOULDBLOCK:
380 			stat = RPC_TIMEDOUT;
381 			break;
382 		default:
383 			stat = RPC_CANTRECV;
384 		};
385 		errp->re_status = stat;
386 		goto out;
387 	} else {
388 		/*
389 		 * We were woken up by the svc thread.  If the
390 		 * upcall had a receive error, report that,
391 		 * otherwise we have a reply.
392 		 */
393 		if (cr->cr_error) {
394 			errp->re_errno = cr->cr_error;
395 			errp->re_status = stat = RPC_CANTRECV;
396 			goto out;
397 		}
398 	}
399 
400 got_reply:
401 	/*
402 	 * Now decode and validate the response. We need to drop the
403 	 * lock since xdr_replymsg may end up sleeping in malloc.
404 	 */
405 	mtx_unlock(&ct->ct_lock);
406 
407 	if (ext && ext->rc_feedback)
408 		ext->rc_feedback(FEEDBACK_OK, proc, ext->rc_feedback_arg);
409 
410 	xdrmbuf_create(&xdrs, cr->cr_mrep, XDR_DECODE);
411 	ok = xdr_replymsg(&xdrs, &reply_msg);
412 	cr->cr_mrep = NULL;
413 
414 	if (ok) {
415 		if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
416 		    (reply_msg.acpted_rply.ar_stat == SUCCESS))
417 			errp->re_status = stat = RPC_SUCCESS;
418 		else
419 			stat = _seterr_reply(&reply_msg, errp);
420 
421 		if (stat == RPC_SUCCESS) {
422 			results = xdrmbuf_getall(&xdrs);
423 			if (!AUTH_VALIDATE(auth, xid,
424 			    &reply_msg.acpted_rply.ar_verf, &results)) {
425 				errp->re_status = stat = RPC_AUTHERROR;
426 				errp->re_why = AUTH_INVALIDRESP;
427 			} else {
428 				KASSERT(results,
429 				    ("auth validated but no result"));
430 				*resultsp = results;
431 			}
432 		}		/* end successful completion */
433 		/*
434 		 * If unsuccesful AND error is an authentication error
435 		 * then refresh credentials and try again, else break
436 		 */
437 		else if (stat == RPC_AUTHERROR)
438 			/* maybe our credentials need to be refreshed ... */
439 			if (nrefreshes > 0 && AUTH_REFRESH(auth, &reply_msg)) {
440 				nrefreshes--;
441 				XDR_DESTROY(&xdrs);
442 				mtx_lock(&ct->ct_lock);
443 				goto call_again;
444 			}
445 			/* end of unsuccessful completion */
446 		/* end of valid reply message */
447 	} else
448 		errp->re_status = stat = RPC_CANTDECODERES;
449 	XDR_DESTROY(&xdrs);
450 	mtx_lock(&ct->ct_lock);
451 out:
452 	mtx_assert(&ct->ct_lock, MA_OWNED);
453 
454 	KASSERT(stat != RPC_SUCCESS || *resultsp,
455 	    ("RPC_SUCCESS without reply"));
456 
457 	if (mreq != NULL)
458 		m_freem(mreq);
459 	if (cr->cr_mrep != NULL)
460 		m_freem(cr->cr_mrep);
461 
462 	ct->ct_threads--;
463 	if (ct->ct_closing)
464 		wakeup(ct);
465 
466 	mtx_unlock(&ct->ct_lock);
467 
468 	if (auth && stat != RPC_SUCCESS)
469 		AUTH_VALIDATE(auth, xid, NULL, NULL);
470 
471 	free(cr, M_RPC);
472 
473 	return (stat);
474 }
475 
476 static void
477 clnt_bck_geterr(CLIENT *cl, struct rpc_err *errp)
478 {
479 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
480 
481 	*errp = ct->ct_error;
482 }
483 
484 static bool_t
485 clnt_bck_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
486 {
487 	XDR xdrs;
488 	bool_t dummy;
489 
490 	xdrs.x_op = XDR_FREE;
491 	dummy = (*xdr_res)(&xdrs, res_ptr);
492 
493 	return (dummy);
494 }
495 
496 /*ARGSUSED*/
497 static void
498 clnt_bck_abort(CLIENT *cl)
499 {
500 }
501 
502 static bool_t
503 clnt_bck_control(CLIENT *cl, u_int request, void *info)
504 {
505 
506 	return (TRUE);
507 }
508 
509 static void
510 clnt_bck_close(CLIENT *cl)
511 {
512 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
513 
514 	mtx_lock(&ct->ct_lock);
515 
516 	if (ct->ct_closed) {
517 		mtx_unlock(&ct->ct_lock);
518 		return;
519 	}
520 
521 	if (ct->ct_closing) {
522 		while (ct->ct_closing)
523 			msleep(ct, &ct->ct_lock, 0, "rpcclose", 0);
524 		KASSERT(ct->ct_closed, ("client should be closed"));
525 		mtx_unlock(&ct->ct_lock);
526 		return;
527 	}
528 
529 	ct->ct_closing = FALSE;
530 	ct->ct_closed = TRUE;
531 	mtx_unlock(&ct->ct_lock);
532 	wakeup(ct);
533 }
534 
535 static void
536 clnt_bck_destroy(CLIENT *cl)
537 {
538 	struct ct_data *ct = (struct ct_data *) cl->cl_private;
539 
540 	clnt_bck_close(cl);
541 
542 	mtx_destroy(&ct->ct_lock);
543 	mem_free(ct, sizeof(struct ct_data));
544 	if (cl->cl_netid && cl->cl_netid[0])
545 		mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
546 	if (cl->cl_tp && cl->cl_tp[0])
547 		mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
548 	mem_free(cl, sizeof(CLIENT));
549 }
550 
551 /*
552  * This call is done by the svc code when a backchannel RPC reply is
553  * received.
554  */
555 void
556 clnt_bck_svccall(void *arg, struct mbuf *mrep, uint32_t xid)
557 {
558 	struct ct_data *ct = (struct ct_data *)arg;
559 	struct ct_request *cr;
560 	int foundreq;
561 
562 	mtx_lock(&ct->ct_lock);
563 	ct->ct_upcallrefs++;
564 	/*
565 	 * See if we can match this reply to a request.
566 	 */
567 	foundreq = 0;
568 	TAILQ_FOREACH(cr, &ct->ct_pending, cr_link) {
569 		if (cr->cr_xid == xid) {
570 			/*
571 			 * This one matches. We leave the reply mbuf list in
572 			 * cr->cr_mrep. Set the XID to zero so that we will
573 			 * ignore any duplicated replies.
574 			 */
575 			cr->cr_xid = 0;
576 			cr->cr_mrep = mrep;
577 			cr->cr_error = 0;
578 			foundreq = 1;
579 			wakeup(cr);
580 			break;
581 		}
582 	}
583 
584 	ct->ct_upcallrefs--;
585 	if (ct->ct_upcallrefs < 0)
586 		panic("rpcvc svccall refcnt");
587 	if (ct->ct_upcallrefs == 0)
588 		wakeup(&ct->ct_upcallrefs);
589 	mtx_unlock(&ct->ct_lock);
590 	if (foundreq == 0)
591 		m_freem(mrep);
592 }
593 
594