1 /* $NetBSD: svc_vc.c,v 1.7 2000/08/03 00:01:53 fvdl Exp $ */
2
3 /*-
4 * SPDX-License-Identifier: BSD-3-Clause
5 *
6 * Copyright (c) 2009, Sun Microsystems, Inc.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 * - Redistributions of source code must retain the above copyright notice,
12 * this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright notice,
14 * this list of conditions and the following disclaimer in the documentation
15 * and/or other materials provided with the distribution.
16 * - Neither the name of Sun Microsystems, 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 "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * svc_vc.c, Server side for Connection Oriented based RPC.
35 *
36 * Actually implements two flavors of transporter -
37 * a tcp rendezvouser (a listener and connection establisher)
38 * and a record/tcp stream.
39 */
40
41 #include "namespace.h"
42 #include "reentrant.h"
43 #include <sys/param.h>
44 #include <sys/poll.h>
45 #include <sys/socket.h>
46 #include <sys/un.h>
47 #include <sys/time.h>
48 #include <sys/uio.h>
49 #include <netinet/in.h>
50 #include <netinet/tcp.h>
51
52 #include <assert.h>
53 #include <err.h>
54 #include <errno.h>
55 #include <fcntl.h>
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <unistd.h>
60
61 #include <rpc/rpc.h>
62
63 #include "rpc_com.h"
64 #include "mt_misc.h"
65 #include "un-namespace.h"
66
67 static SVCXPRT *makefd_xprt(int, u_int, u_int);
68 static bool_t rendezvous_request(SVCXPRT *, struct rpc_msg *);
69 static enum xprt_stat rendezvous_stat(SVCXPRT *);
70 static void svc_vc_destroy(SVCXPRT *);
71 static void __svc_vc_dodestroy (SVCXPRT *);
72 static int read_vc(void *, void *, int);
73 static int write_vc(void *, void *, int);
74 static enum xprt_stat svc_vc_stat(SVCXPRT *);
75 static bool_t svc_vc_recv(SVCXPRT *, struct rpc_msg *);
76 static bool_t svc_vc_getargs(SVCXPRT *, xdrproc_t, void *);
77 static bool_t svc_vc_freeargs(SVCXPRT *, xdrproc_t, void *);
78 static bool_t svc_vc_reply(SVCXPRT *, struct rpc_msg *);
79 static void svc_vc_rendezvous_ops(SVCXPRT *);
80 static void svc_vc_ops(SVCXPRT *);
81 static bool_t svc_vc_control(SVCXPRT *xprt, const u_int rq, void *in);
82 static bool_t svc_vc_rendezvous_control (SVCXPRT *xprt, const u_int rq,
83 void *in);
84
85 struct cf_rendezvous { /* kept in xprt->xp_p1 for rendezvouser */
86 u_int sendsize;
87 u_int recvsize;
88 int maxrec;
89 };
90
91 struct cf_conn { /* kept in xprt->xp_p1 for actual connection */
92 enum xprt_stat strm_stat;
93 u_int32_t x_id;
94 XDR xdrs;
95 char verf_body[MAX_AUTH_BYTES];
96 u_int sendsize;
97 u_int recvsize;
98 int maxrec;
99 bool_t nonblock;
100 struct timeval last_recv_time;
101 };
102
103 /*
104 * Usage:
105 * xprt = svc_vc_create(sock, send_buf_size, recv_buf_size);
106 *
107 * Creates, registers, and returns a (rpc) tcp based transporter.
108 * Once *xprt is initialized, it is registered as a transporter
109 * see (svc.h, xprt_register). This routine returns
110 * a NULL if a problem occurred.
111 *
112 * The filedescriptor passed in is expected to refer to a bound, but
113 * not yet connected socket.
114 *
115 * Since streams do buffered io similar to stdio, the caller can specify
116 * how big the send and receive buffers are via the second and third parms;
117 * 0 => use the system default.
118 */
119 SVCXPRT *
svc_vc_create(int fd,u_int sendsize,u_int recvsize)120 svc_vc_create(int fd, u_int sendsize, u_int recvsize)
121 {
122 SVCXPRT *xprt = NULL;
123 struct cf_rendezvous *r = NULL;
124 struct __rpc_sockinfo si;
125 struct sockaddr_storage sslocal;
126 socklen_t slen;
127
128 if (!__rpc_fd2sockinfo(fd, &si))
129 return NULL;
130
131 r = mem_alloc(sizeof(*r));
132 if (r == NULL) {
133 warnx("svc_vc_create: out of memory");
134 goto cleanup_svc_vc_create;
135 }
136 r->sendsize = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsize);
137 r->recvsize = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsize);
138 r->maxrec = __svc_maxrec;
139 xprt = svc_xprt_alloc();
140 if (xprt == NULL) {
141 warnx("svc_vc_create: out of memory");
142 goto cleanup_svc_vc_create;
143 }
144 xprt->xp_p1 = r;
145 xprt->xp_verf = _null_auth;
146 svc_vc_rendezvous_ops(xprt);
147 xprt->xp_port = (u_short)-1; /* It is the rendezvouser */
148 xprt->xp_fd = fd;
149
150 slen = sizeof (struct sockaddr_storage);
151 if (_getsockname(fd, (struct sockaddr *)(void *)&sslocal, &slen) < 0) {
152 warnx("svc_vc_create: could not retrieve local addr");
153 goto cleanup_svc_vc_create;
154 }
155
156 xprt->xp_ltaddr.maxlen = xprt->xp_ltaddr.len = sslocal.ss_len;
157 xprt->xp_ltaddr.buf = mem_alloc((size_t)sslocal.ss_len);
158 if (xprt->xp_ltaddr.buf == NULL) {
159 warnx("svc_vc_create: no mem for local addr");
160 goto cleanup_svc_vc_create;
161 }
162 memcpy(xprt->xp_ltaddr.buf, &sslocal, (size_t)sslocal.ss_len);
163
164 xprt->xp_rtaddr.maxlen = sizeof (struct sockaddr_storage);
165 xprt_register(xprt);
166 return (xprt);
167 cleanup_svc_vc_create:
168 if (xprt)
169 mem_free(xprt, sizeof(*xprt));
170 if (r != NULL)
171 mem_free(r, sizeof(*r));
172 return (NULL);
173 }
174
175 /*
176 * Like svtcp_create(), except the routine takes any *open* UNIX file
177 * descriptor as its first input.
178 */
179 SVCXPRT *
svc_fd_create(int fd,u_int sendsize,u_int recvsize)180 svc_fd_create(int fd, u_int sendsize, u_int recvsize)
181 {
182 struct sockaddr_storage ss;
183 socklen_t slen;
184 SVCXPRT *ret;
185
186 assert(fd != -1);
187
188 ret = makefd_xprt(fd, sendsize, recvsize);
189 if (ret == NULL)
190 return NULL;
191
192 slen = sizeof (struct sockaddr_storage);
193 if (_getsockname(fd, (struct sockaddr *)(void *)&ss, &slen) < 0) {
194 warnx("svc_fd_create: could not retrieve local addr");
195 goto freedata;
196 }
197 ret->xp_ltaddr.maxlen = ret->xp_ltaddr.len = ss.ss_len;
198 ret->xp_ltaddr.buf = mem_alloc((size_t)ss.ss_len);
199 if (ret->xp_ltaddr.buf == NULL) {
200 warnx("svc_fd_create: no mem for local addr");
201 goto freedata;
202 }
203 memcpy(ret->xp_ltaddr.buf, &ss, (size_t)ss.ss_len);
204
205 slen = sizeof (struct sockaddr_storage);
206 if (_getpeername(fd, (struct sockaddr *)(void *)&ss, &slen) < 0) {
207 warnx("svc_fd_create: could not retrieve remote addr");
208 goto freedata;
209 }
210 ret->xp_rtaddr.maxlen = ret->xp_rtaddr.len = ss.ss_len;
211 ret->xp_rtaddr.buf = mem_alloc((size_t)ss.ss_len);
212 if (ret->xp_rtaddr.buf == NULL) {
213 warnx("svc_fd_create: no mem for local addr");
214 goto freedata;
215 }
216 memcpy(ret->xp_rtaddr.buf, &ss, (size_t)ss.ss_len);
217 #ifdef PORTMAP
218 if (ss.ss_family == AF_INET || ss.ss_family == AF_LOCAL) {
219 ret->xp_raddr = *(struct sockaddr_in *)ret->xp_rtaddr.buf;
220 ret->xp_addrlen = sizeof (struct sockaddr_in);
221 }
222 #endif /* PORTMAP */
223
224 return ret;
225
226 freedata:
227 if (ret->xp_ltaddr.buf != NULL)
228 mem_free(ret->xp_ltaddr.buf, rep->xp_ltaddr.maxlen);
229
230 return NULL;
231 }
232
233 static SVCXPRT *
makefd_xprt(int fd,u_int sendsize,u_int recvsize)234 makefd_xprt(int fd, u_int sendsize, u_int recvsize)
235 {
236 SVCXPRT *xprt;
237 struct cf_conn *cd;
238 const char *netid;
239 struct __rpc_sockinfo si;
240
241 assert(fd != -1);
242
243 xprt = svc_xprt_alloc();
244 if (xprt == NULL) {
245 warnx("svc_vc: makefd_xprt: out of memory");
246 goto done;
247 }
248 cd = mem_alloc(sizeof(struct cf_conn));
249 if (cd == NULL) {
250 warnx("svc_tcp: makefd_xprt: out of memory");
251 svc_xprt_free(xprt);
252 xprt = NULL;
253 goto done;
254 }
255 cd->strm_stat = XPRT_IDLE;
256 xdrrec_create(&(cd->xdrs), sendsize, recvsize,
257 xprt, read_vc, write_vc);
258 xprt->xp_p1 = cd;
259 xprt->xp_verf.oa_base = cd->verf_body;
260 svc_vc_ops(xprt); /* truly deals with calls */
261 xprt->xp_port = 0; /* this is a connection, not a rendezvouser */
262 xprt->xp_fd = fd;
263 if (__rpc_fd2sockinfo(fd, &si) && __rpc_sockinfo2netid(&si, &netid))
264 xprt->xp_netid = strdup(netid);
265
266 xprt_register(xprt);
267 done:
268 return (xprt);
269 }
270
271 /*ARGSUSED*/
272 static bool_t
rendezvous_request(SVCXPRT * xprt,struct rpc_msg * msg)273 rendezvous_request(SVCXPRT *xprt, struct rpc_msg *msg)
274 {
275 int sock, flags;
276 struct cf_rendezvous *r;
277 struct cf_conn *cd;
278 struct sockaddr_storage addr, sslocal;
279 socklen_t len, slen;
280 struct __rpc_sockinfo si;
281 SVCXPRT *newxprt;
282 fd_set cleanfds;
283
284 assert(xprt != NULL);
285 assert(msg != NULL);
286
287 r = (struct cf_rendezvous *)xprt->xp_p1;
288 again:
289 len = sizeof addr;
290 if ((sock = _accept(xprt->xp_fd, (struct sockaddr *)(void *)&addr,
291 &len)) < 0) {
292 if (errno == EINTR)
293 goto again;
294 /*
295 * Clean out the most idle file descriptor when we're
296 * running out.
297 */
298 if (errno == EMFILE || errno == ENFILE) {
299 cleanfds = svc_fdset;
300 __svc_clean_idle(&cleanfds, 0, FALSE);
301 goto again;
302 }
303 return (FALSE);
304 }
305 /*
306 * make a new transporter (re-uses xprt)
307 */
308 newxprt = makefd_xprt(sock, r->sendsize, r->recvsize);
309 newxprt->xp_rtaddr.buf = mem_alloc(len);
310 if (newxprt->xp_rtaddr.buf == NULL)
311 return (FALSE);
312 memcpy(newxprt->xp_rtaddr.buf, &addr, len);
313 newxprt->xp_rtaddr.len = len;
314 #ifdef PORTMAP
315 if (addr.ss_family == AF_INET || addr.ss_family == AF_LOCAL) {
316 newxprt->xp_raddr = *(struct sockaddr_in *)newxprt->xp_rtaddr.buf;
317 newxprt->xp_addrlen = sizeof (struct sockaddr_in);
318 }
319 #endif /* PORTMAP */
320 if (__rpc_fd2sockinfo(sock, &si) && si.si_proto == IPPROTO_TCP) {
321 len = 1;
322 /* XXX fvdl - is this useful? */
323 _setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &len, sizeof (len));
324 }
325
326 cd = (struct cf_conn *)newxprt->xp_p1;
327
328 cd->recvsize = r->recvsize;
329 cd->sendsize = r->sendsize;
330 cd->maxrec = r->maxrec;
331
332 if (cd->maxrec != 0) {
333 flags = _fcntl(sock, F_GETFL, 0);
334 if (flags == -1)
335 return (FALSE);
336 if (_fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1)
337 return (FALSE);
338 if (cd->recvsize > cd->maxrec)
339 cd->recvsize = cd->maxrec;
340 cd->nonblock = TRUE;
341 __xdrrec_setnonblock(&cd->xdrs, cd->maxrec);
342 } else
343 cd->nonblock = FALSE;
344 slen = sizeof(struct sockaddr_storage);
345 if(_getsockname(sock, (struct sockaddr *)(void *)&sslocal, &slen) < 0) {
346 warnx("svc_vc_create: could not retrieve local addr");
347 newxprt->xp_ltaddr.maxlen = newxprt->xp_ltaddr.len = 0;
348 } else {
349 newxprt->xp_ltaddr.maxlen = newxprt->xp_ltaddr.len = sslocal.ss_len;
350 newxprt->xp_ltaddr.buf = mem_alloc((size_t)sslocal.ss_len);
351 if (newxprt->xp_ltaddr.buf == NULL) {
352 warnx("svc_vc_create: no mem for local addr");
353 newxprt->xp_ltaddr.maxlen = newxprt->xp_ltaddr.len = 0;
354 } else {
355 memcpy(newxprt->xp_ltaddr.buf, &sslocal, (size_t)sslocal.ss_len);
356 }
357 }
358
359 gettimeofday(&cd->last_recv_time, NULL);
360
361 return (FALSE); /* there is never an rpc msg to be processed */
362 }
363
364 /*ARGSUSED*/
365 static enum xprt_stat
rendezvous_stat(SVCXPRT * xprt)366 rendezvous_stat(SVCXPRT *xprt)
367 {
368
369 return (XPRT_IDLE);
370 }
371
372 static void
svc_vc_destroy(SVCXPRT * xprt)373 svc_vc_destroy(SVCXPRT *xprt)
374 {
375 assert(xprt != NULL);
376
377 xprt_unregister(xprt);
378 __svc_vc_dodestroy(xprt);
379 }
380
381 static void
__svc_vc_dodestroy(SVCXPRT * xprt)382 __svc_vc_dodestroy(SVCXPRT *xprt)
383 {
384 struct cf_conn *cd;
385 struct cf_rendezvous *r;
386
387 cd = (struct cf_conn *)xprt->xp_p1;
388
389 if (xprt->xp_fd != RPC_ANYFD)
390 (void)_close(xprt->xp_fd);
391 if (xprt->xp_port != 0) {
392 /* a rendezvouser socket */
393 r = (struct cf_rendezvous *)xprt->xp_p1;
394 mem_free(r, sizeof (struct cf_rendezvous));
395 xprt->xp_port = 0;
396 } else {
397 /* an actual connection socket */
398 XDR_DESTROY(&(cd->xdrs));
399 mem_free(cd, sizeof(struct cf_conn));
400 }
401 if (xprt->xp_rtaddr.buf)
402 mem_free(xprt->xp_rtaddr.buf, xprt->xp_rtaddr.maxlen);
403 if (xprt->xp_ltaddr.buf)
404 mem_free(xprt->xp_ltaddr.buf, xprt->xp_ltaddr.maxlen);
405 free(xprt->xp_tp);
406 free(xprt->xp_netid);
407 svc_xprt_free(xprt);
408 }
409
410 /*ARGSUSED*/
411 static bool_t
svc_vc_control(SVCXPRT * xprt,const u_int rq,void * in)412 svc_vc_control(SVCXPRT *xprt, const u_int rq, void *in)
413 {
414 return (FALSE);
415 }
416
417 static bool_t
svc_vc_rendezvous_control(SVCXPRT * xprt,const u_int rq,void * in)418 svc_vc_rendezvous_control(SVCXPRT *xprt, const u_int rq, void *in)
419 {
420 struct cf_rendezvous *cfp;
421
422 cfp = (struct cf_rendezvous *)xprt->xp_p1;
423 if (cfp == NULL)
424 return (FALSE);
425 switch (rq) {
426 case SVCGET_CONNMAXREC:
427 *(int *)in = cfp->maxrec;
428 break;
429 case SVCSET_CONNMAXREC:
430 cfp->maxrec = *(int *)in;
431 break;
432 default:
433 return (FALSE);
434 }
435 return (TRUE);
436 }
437
438 /*
439 * reads data from the tcp or uip connection.
440 * any error is fatal and the connection is closed.
441 * (And a read of zero bytes is a half closed stream => error.)
442 * All read operations timeout after 35 seconds. A timeout is
443 * fatal for the connection.
444 */
445 static int
read_vc(void * xprtp,void * buf,int len)446 read_vc(void *xprtp, void *buf, int len)
447 {
448 SVCXPRT *xprt;
449 int sock;
450 int milliseconds = 35 * 1000;
451 struct pollfd pollfd;
452 struct cf_conn *cfp;
453
454 xprt = (SVCXPRT *)xprtp;
455 assert(xprt != NULL);
456
457 sock = xprt->xp_fd;
458
459 cfp = (struct cf_conn *)xprt->xp_p1;
460
461 if (cfp->nonblock) {
462 len = _read(sock, buf, (size_t)len);
463 if (len < 0) {
464 if (errno == EAGAIN)
465 len = 0;
466 else
467 goto fatal_err;
468 }
469 if (len != 0)
470 gettimeofday(&cfp->last_recv_time, NULL);
471 return len;
472 }
473
474 do {
475 pollfd.fd = sock;
476 pollfd.events = POLLIN;
477 pollfd.revents = 0;
478 switch (_poll(&pollfd, 1, milliseconds)) {
479 case -1:
480 if (errno == EINTR)
481 continue;
482 /*FALLTHROUGH*/
483 case 0:
484 goto fatal_err;
485
486 default:
487 break;
488 }
489 } while ((pollfd.revents & POLLIN) == 0);
490
491 if ((len = _read(sock, buf, (size_t)len)) > 0) {
492 gettimeofday(&cfp->last_recv_time, NULL);
493 return (len);
494 }
495
496 fatal_err:
497 ((struct cf_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
498 return (-1);
499 }
500
501 /*
502 * writes data to the tcp connection.
503 * Any error is fatal and the connection is closed.
504 */
505 static int
write_vc(void * xprtp,void * buf,int len)506 write_vc(void *xprtp, void *buf, int len)
507 {
508 SVCXPRT *xprt;
509 int i, cnt;
510 struct cf_conn *cd;
511 struct timeval tv0, tv1;
512
513 xprt = (SVCXPRT *)xprtp;
514 assert(xprt != NULL);
515
516 cd = (struct cf_conn *)xprt->xp_p1;
517
518 if (cd->nonblock)
519 gettimeofday(&tv0, NULL);
520
521 for (cnt = len; cnt > 0; cnt -= i, buf = (char *)buf + i) {
522 i = _write(xprt->xp_fd, buf, (size_t)cnt);
523 if (i < 0) {
524 if (errno != EAGAIN || !cd->nonblock) {
525 cd->strm_stat = XPRT_DIED;
526 return (-1);
527 }
528 if (cd->nonblock) {
529 /*
530 * For non-blocking connections, do not
531 * take more than 2 seconds writing the
532 * data out.
533 *
534 * XXX 2 is an arbitrary amount.
535 */
536 gettimeofday(&tv1, NULL);
537 if (tv1.tv_sec - tv0.tv_sec >= 2) {
538 cd->strm_stat = XPRT_DIED;
539 return (-1);
540 }
541 }
542 i = 0;
543 }
544 }
545
546 return (len);
547 }
548
549 static enum xprt_stat
svc_vc_stat(SVCXPRT * xprt)550 svc_vc_stat(SVCXPRT *xprt)
551 {
552 struct cf_conn *cd;
553
554 assert(xprt != NULL);
555
556 cd = (struct cf_conn *)(xprt->xp_p1);
557
558 if (cd->strm_stat == XPRT_DIED)
559 return (XPRT_DIED);
560 if (! xdrrec_eof(&(cd->xdrs)))
561 return (XPRT_MOREREQS);
562 return (XPRT_IDLE);
563 }
564
565 static bool_t
svc_vc_recv(SVCXPRT * xprt,struct rpc_msg * msg)566 svc_vc_recv(SVCXPRT *xprt, struct rpc_msg *msg)
567 {
568 struct cf_conn *cd;
569 XDR *xdrs;
570
571 assert(xprt != NULL);
572 assert(msg != NULL);
573
574 cd = (struct cf_conn *)(xprt->xp_p1);
575 xdrs = &(cd->xdrs);
576
577 if (cd->nonblock) {
578 if (!__xdrrec_getrec(xdrs, &cd->strm_stat, TRUE))
579 return FALSE;
580 } else {
581 (void)xdrrec_skiprecord(xdrs);
582 }
583
584 xdrs->x_op = XDR_DECODE;
585 if (xdr_callmsg(xdrs, msg)) {
586 cd->x_id = msg->rm_xid;
587 return (TRUE);
588 }
589 cd->strm_stat = XPRT_DIED;
590 return (FALSE);
591 }
592
593 static bool_t
svc_vc_getargs(SVCXPRT * xprt,xdrproc_t xdr_args,void * args_ptr)594 svc_vc_getargs(SVCXPRT *xprt, xdrproc_t xdr_args, void *args_ptr)
595 {
596 struct cf_conn *cd;
597
598 assert(xprt != NULL);
599 cd = (struct cf_conn *)(xprt->xp_p1);
600 return (SVCAUTH_UNWRAP(&SVC_AUTH(xprt),
601 &cd->xdrs, xdr_args, args_ptr));
602 }
603
604 static bool_t
svc_vc_freeargs(SVCXPRT * xprt,xdrproc_t xdr_args,void * args_ptr)605 svc_vc_freeargs(SVCXPRT *xprt, xdrproc_t xdr_args, void *args_ptr)
606 {
607 XDR *xdrs;
608
609 assert(xprt != NULL);
610 /* args_ptr may be NULL */
611
612 xdrs = &(((struct cf_conn *)(xprt->xp_p1))->xdrs);
613
614 xdrs->x_op = XDR_FREE;
615 return ((*xdr_args)(xdrs, args_ptr));
616 }
617
618 static bool_t
svc_vc_reply(SVCXPRT * xprt,struct rpc_msg * msg)619 svc_vc_reply(SVCXPRT *xprt, struct rpc_msg *msg)
620 {
621 struct cf_conn *cd;
622 XDR *xdrs;
623 bool_t rstat;
624 xdrproc_t xdr_proc;
625 caddr_t xdr_where;
626 u_int pos;
627
628 assert(xprt != NULL);
629 assert(msg != NULL);
630
631 cd = (struct cf_conn *)(xprt->xp_p1);
632 xdrs = &(cd->xdrs);
633
634 xdrs->x_op = XDR_ENCODE;
635 msg->rm_xid = cd->x_id;
636 rstat = TRUE;
637 if (msg->rm_reply.rp_stat == MSG_ACCEPTED &&
638 msg->rm_reply.rp_acpt.ar_stat == SUCCESS) {
639 xdr_proc = msg->acpted_rply.ar_results.proc;
640 xdr_where = msg->acpted_rply.ar_results.where;
641 msg->acpted_rply.ar_results.proc = (xdrproc_t) xdr_void;
642 msg->acpted_rply.ar_results.where = NULL;
643
644 pos = XDR_GETPOS(xdrs);
645 if (!xdr_replymsg(xdrs, msg) ||
646 !SVCAUTH_WRAP(&SVC_AUTH(xprt), xdrs, xdr_proc, xdr_where)) {
647 XDR_SETPOS(xdrs, pos);
648 rstat = FALSE;
649 }
650 } else {
651 rstat = xdr_replymsg(xdrs, msg);
652 }
653
654 if (rstat)
655 (void)xdrrec_endofrecord(xdrs, TRUE);
656
657 return (rstat);
658 }
659
660 static void
svc_vc_ops(SVCXPRT * xprt)661 svc_vc_ops(SVCXPRT *xprt)
662 {
663 static struct xp_ops ops;
664 static struct xp_ops2 ops2;
665
666 /* VARIABLES PROTECTED BY ops_lock: ops, ops2 */
667
668 mutex_lock(&ops_lock);
669 if (ops.xp_recv == NULL) {
670 ops.xp_recv = svc_vc_recv;
671 ops.xp_stat = svc_vc_stat;
672 ops.xp_getargs = svc_vc_getargs;
673 ops.xp_reply = svc_vc_reply;
674 ops.xp_freeargs = svc_vc_freeargs;
675 ops.xp_destroy = svc_vc_destroy;
676 ops2.xp_control = svc_vc_control;
677 }
678 xprt->xp_ops = &ops;
679 xprt->xp_ops2 = &ops2;
680 mutex_unlock(&ops_lock);
681 }
682
683 static void
svc_vc_rendezvous_ops(SVCXPRT * xprt)684 svc_vc_rendezvous_ops(SVCXPRT *xprt)
685 {
686 static struct xp_ops ops;
687 static struct xp_ops2 ops2;
688
689 mutex_lock(&ops_lock);
690 if (ops.xp_recv == NULL) {
691 ops.xp_recv = rendezvous_request;
692 ops.xp_stat = rendezvous_stat;
693 ops.xp_getargs =
694 (bool_t (*)(SVCXPRT *, xdrproc_t, void *))abort;
695 ops.xp_reply =
696 (bool_t (*)(SVCXPRT *, struct rpc_msg *))abort;
697 ops.xp_freeargs =
698 (bool_t (*)(SVCXPRT *, xdrproc_t, void *))abort;
699 ops.xp_destroy = svc_vc_destroy;
700 ops2.xp_control = svc_vc_rendezvous_control;
701 }
702 xprt->xp_ops = &ops;
703 xprt->xp_ops2 = &ops2;
704 mutex_unlock(&ops_lock);
705 }
706
707 /*
708 * Get the effective UID of the sending process. Used by rpcbind, keyserv
709 * and rpc.yppasswdd on AF_LOCAL.
710 */
711 int
__rpc_get_local_uid(SVCXPRT * transp,uid_t * uid)712 __rpc_get_local_uid(SVCXPRT *transp, uid_t *uid) {
713 int sock, ret;
714 gid_t egid;
715 uid_t euid;
716 struct sockaddr *sa;
717
718 sock = transp->xp_fd;
719 sa = (struct sockaddr *)transp->xp_rtaddr.buf;
720 if (sa->sa_family == AF_LOCAL) {
721 ret = getpeereid(sock, &euid, &egid);
722 if (ret == 0)
723 *uid = euid;
724 return (ret);
725 } else
726 return (-1);
727 }
728
729 /*
730 * Destroy xprts that have not have had any activity in 'timeout' seconds.
731 * If 'cleanblock' is true, blocking connections (the default) are also
732 * cleaned. If timeout is 0, the least active connection is picked.
733 */
734 bool_t
__svc_clean_idle(fd_set * fds,int timeout,bool_t cleanblock)735 __svc_clean_idle(fd_set *fds, int timeout, bool_t cleanblock)
736 {
737 int i, ncleaned;
738 SVCXPRT *xprt, *least_active;
739 struct timeval tv, tdiff, tmax;
740 struct cf_conn *cd;
741
742 gettimeofday(&tv, NULL);
743 tmax.tv_sec = tmax.tv_usec = 0;
744 least_active = NULL;
745 rwlock_wrlock(&svc_fd_lock);
746 for (i = ncleaned = 0; i <= svc_maxfd; i++) {
747 if (FD_ISSET(i, fds)) {
748 xprt = __svc_xports[i];
749 if (xprt == NULL || xprt->xp_ops == NULL ||
750 xprt->xp_ops->xp_recv != svc_vc_recv)
751 continue;
752 cd = (struct cf_conn *)xprt->xp_p1;
753 if (!cleanblock && !cd->nonblock)
754 continue;
755 if (timeout == 0) {
756 timersub(&tv, &cd->last_recv_time, &tdiff);
757 if (timercmp(&tdiff, &tmax, >)) {
758 tmax = tdiff;
759 least_active = xprt;
760 }
761 continue;
762 }
763 if (tv.tv_sec - cd->last_recv_time.tv_sec > timeout) {
764 __xprt_unregister_unlocked(xprt);
765 __svc_vc_dodestroy(xprt);
766 ncleaned++;
767 }
768 }
769 }
770 if (timeout == 0 && least_active != NULL) {
771 __xprt_unregister_unlocked(least_active);
772 __svc_vc_dodestroy(least_active);
773 ncleaned++;
774 }
775 rwlock_unlock(&svc_fd_lock);
776 return ncleaned > 0 ? TRUE : FALSE;
777 }
778