2 * svc_unix.c, Server side for TCP/IP based RPC.
4 * Copyright (C) 2012-2021 Free Software Foundation, Inc.
5 * This file is part of the GNU C Library.
7 * The GNU C Library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * The GNU C Library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with the GNU C Library; if not, see
19 * <https://www.gnu.org/licenses/>.
21 * Copyright (c) 2010, Oracle America, Inc.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions are
27 * * Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
29 * * Redistributions in binary form must reproduce the above
30 * copyright notice, this list of conditions and the following
31 * disclaimer in the documentation and/or other materials
32 * provided with the distribution.
33 * * Neither the name of the "Oracle America, Inc." nor the names of its
34 * contributors may be used to endorse or promote products derived
35 * from this software without specific prior written permission.
37 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
38 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
39 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
40 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
41 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
42 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
43 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
44 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
45 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
46 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
47 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
48 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
50 * Actually implements two flavors of transporter -
51 * a unix rendezvouser (a listener and connection establisher)
52 * and a record/unix stream.
60 #include <sys/socket.h>
67 #include <shlib-compat.h>
70 * Ops vector for AF_UNIX based rpc service handle
72 static bool_t
svcunix_recv (SVCXPRT
*, struct rpc_msg
*);
73 static enum xprt_stat
svcunix_stat (SVCXPRT
*);
74 static bool_t
svcunix_getargs (SVCXPRT
*, xdrproc_t
, caddr_t
);
75 static bool_t
svcunix_reply (SVCXPRT
*, struct rpc_msg
*);
76 static bool_t
svcunix_freeargs (SVCXPRT
*, xdrproc_t
, caddr_t
);
77 static void svcunix_destroy (SVCXPRT
*);
79 static const struct xp_ops svcunix_op
=
90 * Ops vector for AF_UNIX rendezvous handler
92 static bool_t
rendezvous_request (SVCXPRT
*, struct rpc_msg
*);
93 static enum xprt_stat
rendezvous_stat (SVCXPRT
*);
94 static void svcunix_rendezvous_abort (void) __attribute__ ((__noreturn__
));
96 /* This function makes sure abort() relocation goes through PLT
97 and thus can be lazy bound. */
99 svcunix_rendezvous_abort (void)
104 static const struct xp_ops svcunix_rendezvous_op
=
108 (bool_t (*) (SVCXPRT
*, xdrproc_t
, caddr_t
)) svcunix_rendezvous_abort
,
109 (bool_t (*) (SVCXPRT
*, struct rpc_msg
*)) svcunix_rendezvous_abort
,
110 (bool_t (*) (SVCXPRT
*, xdrproc_t
, caddr_t
)) svcunix_rendezvous_abort
,
114 static int readunix (char*, char *, int);
115 static int writeunix (char *, char *, int);
116 static SVCXPRT
*makefd_xprt (int, u_int
, u_int
);
118 struct unix_rendezvous
{ /* kept in xprt->xp_p1 */
123 struct unix_conn
{ /* kept in xprt->xp_p1 */
124 enum xprt_stat strm_stat
;
127 char verf_body
[MAX_AUTH_BYTES
];
132 * xprt = svcunix_create(sock, send_buf_size, recv_buf_size);
134 * Creates, registers, and returns a (rpc) unix based transporter.
135 * Once *xprt is initialized, it is registered as a transporter
136 * see (svc.h, xprt_register). This routine returns
137 * a NULL if a problem occurred.
139 * If sock<0 then a socket is created, else sock is used.
140 * If the socket, sock is not bound to a port then svcunix_create
141 * binds it to an arbitrary port. The routine then starts a unix
142 * listener on the socket's associated port. In any (successful) case,
143 * xprt->xp_sock is the registered socket number and xprt->xp_port is the
144 * associated port number.
146 * Since unix streams do buffered io similar to stdio, the caller can specify
147 * how big the send and receive buffers are via the second and third parms;
148 * 0 => use the system default.
151 svcunix_create (int sock
, u_int sendsize
, u_int recvsize
, char *path
)
153 bool_t madesock
= FALSE
;
155 struct unix_rendezvous
*r
;
156 struct sockaddr_un addr
;
157 socklen_t len
= sizeof (struct sockaddr_in
);
159 if (sock
== RPC_ANYSOCK
)
161 if ((sock
= __socket (AF_UNIX
, SOCK_STREAM
, 0)) < 0)
163 perror (_("svc_unix.c - AF_UNIX socket creation problem"));
164 return (SVCXPRT
*) NULL
;
168 memset (&addr
, '\0', sizeof (addr
));
169 addr
.sun_family
= AF_UNIX
;
170 len
= strlen (path
) + 1;
171 memcpy (addr
.sun_path
, path
, len
);
172 len
+= sizeof (addr
.sun_family
);
174 __bind (sock
, (struct sockaddr
*) &addr
, len
);
176 if (__getsockname (sock
, (struct sockaddr
*) &addr
, &len
) != 0
177 || __listen (sock
, SOMAXCONN
) != 0)
179 perror (_("svc_unix.c - cannot getsockname or listen"));
182 return (SVCXPRT
*) NULL
;
185 r
= (struct unix_rendezvous
*) mem_alloc (sizeof (*r
));
186 xprt
= (SVCXPRT
*) mem_alloc (sizeof (SVCXPRT
));
187 if (r
== NULL
|| xprt
== NULL
)
189 __fxprintf (NULL
, "%s: %s", __func__
, _("out of memory\n"));
190 mem_free (r
, sizeof (*r
));
191 mem_free (xprt
, sizeof (SVCXPRT
));
194 r
->sendsize
= sendsize
;
195 r
->recvsize
= recvsize
;
197 xprt
->xp_p1
= (caddr_t
) r
;
198 xprt
->xp_verf
= _null_auth
;
199 xprt
->xp_ops
= &svcunix_rendezvous_op
;
201 xprt
->xp_sock
= sock
;
202 xprt_register (xprt
);
205 libc_hidden_nolink_sunrpc (svcunix_create
, GLIBC_2_1
)
208 * Like svunix_create(), except the routine takes any *open* UNIX file
209 * descriptor as its first input.
212 svcunixfd_create (int fd
, u_int sendsize
, u_int recvsize
)
214 return makefd_xprt (fd
, sendsize
, recvsize
);
216 libc_hidden_nolink_sunrpc (svcunixfd_create
, GLIBC_2_1
)
219 makefd_xprt (int fd
, u_int sendsize
, u_int recvsize
)
222 struct unix_conn
*cd
;
224 xprt
= (SVCXPRT
*) mem_alloc (sizeof (SVCXPRT
));
225 cd
= (struct unix_conn
*) mem_alloc (sizeof (struct unix_conn
));
226 if (xprt
== (SVCXPRT
*) NULL
|| cd
== (struct unix_conn
*) NULL
)
228 (void) __fxprintf (NULL
, "%s: %s", "svc_unix: makefd_xprt",
229 _("out of memory\n"));
230 mem_free (xprt
, sizeof (SVCXPRT
));
231 mem_free (cd
, sizeof (struct unix_conn
));
234 cd
->strm_stat
= XPRT_IDLE
;
235 xdrrec_create (&(cd
->xdrs
), sendsize
, recvsize
,
236 (caddr_t
) xprt
, readunix
, writeunix
);
238 xprt
->xp_p1
= (caddr_t
) cd
;
239 xprt
->xp_verf
.oa_base
= cd
->verf_body
;
240 xprt
->xp_addrlen
= 0;
241 xprt
->xp_ops
= &svcunix_op
; /* truly deals with calls */
242 xprt
->xp_port
= 0; /* this is a connection, not a rendezvouser */
244 xprt_register (xprt
);
249 rendezvous_request (SVCXPRT
*xprt
, struct rpc_msg
*errmsg
)
252 struct unix_rendezvous
*r
;
253 struct sockaddr_un addr
;
254 struct sockaddr_in in_addr
;
257 r
= (struct unix_rendezvous
*) xprt
->xp_p1
;
259 len
= sizeof (struct sockaddr_un
);
260 if ((sock
= accept (xprt
->xp_sock
, (struct sockaddr
*) &addr
, &len
)) < 0)
264 __svc_accept_failed ();
268 * make a new transporter (re-uses xprt)
270 memset (&in_addr
, '\0', sizeof (in_addr
));
271 in_addr
.sin_family
= AF_UNIX
;
272 xprt
= makefd_xprt (sock
, r
->sendsize
, r
->recvsize
);
274 /* If we are out of memory, makefd_xprt has already dumped an error. */
277 __svc_wait_on_error ();
281 memcpy (&xprt
->xp_raddr
, &in_addr
, sizeof (in_addr
));
282 xprt
->xp_addrlen
= len
;
283 return FALSE
; /* there is never an rpc msg to be processed */
286 static enum xprt_stat
287 rendezvous_stat (SVCXPRT
*xprt
)
293 svcunix_destroy (SVCXPRT
*xprt
)
295 struct unix_conn
*cd
= (struct unix_conn
*) xprt
->xp_p1
;
297 xprt_unregister (xprt
);
298 __close (xprt
->xp_sock
);
299 if (xprt
->xp_port
!= 0)
301 /* a rendezvouser socket */
306 /* an actual connection socket */
307 XDR_DESTROY (&(cd
->xdrs
));
309 mem_free ((caddr_t
) cd
, sizeof (struct unix_conn
));
310 mem_free ((caddr_t
) xprt
, sizeof (SVCXPRT
));
313 #ifdef SCM_CREDENTIALS
317 /* hack to make sure we have enough memory */
318 char dummy
[(CMSG_ALIGN (sizeof (struct ucred
)) - sizeof (struct ucred
) + sizeof (long))];
321 /* XXX This is not thread safe, but since the main functions in svc.c
322 and the rpcgen generated *_svc functions for the daemon are also not
323 thread safe and uses static global variables, it doesn't matter. */
324 static struct cmessage cm
;
328 __msgread (int sock
, void *data
, size_t cnt
)
341 #ifdef SCM_CREDENTIALS
342 msg
.msg_control
= (caddr_t
) &cm
;
343 msg
.msg_controllen
= sizeof (struct cmessage
);
350 if (__setsockopt (sock
, SOL_SOCKET
, SO_PASSCRED
, &on
, sizeof (on
)))
356 len
= __recvmsg (sock
, &msg
, 0);
359 if (msg
.msg_flags
& MSG_CTRUNC
|| len
== 0)
370 __msgwrite (int sock
, void *data
, size_t cnt
)
372 #ifndef SCM_CREDENTIALS
373 /* We cannot implement this reliably. */
374 __set_errno (ENOSYS
);
379 struct cmsghdr
*cmsg
= &cm
.cmsg
;
383 /* XXX I'm not sure, if gete?id() is always correct, or if we should use
384 get?id(). But since keyserv needs geteuid(), we have no other chance.
385 It would be much better, if the kernel could pass both to the server. */
386 cred
.pid
= __getpid ();
387 cred
.uid
= __geteuid ();
388 cred
.gid
= __getegid ();
390 memcpy (CMSG_DATA(cmsg
), &cred
, sizeof (struct ucred
));
391 cmsg
->cmsg_level
= SOL_SOCKET
;
392 cmsg
->cmsg_type
= SCM_CREDENTIALS
;
393 cmsg
->cmsg_len
= sizeof(*cmsg
) + sizeof(struct ucred
);
402 msg
.msg_control
= cmsg
;
403 msg
.msg_controllen
= CMSG_ALIGN(cmsg
->cmsg_len
);
407 len
= __sendmsg (sock
, &msg
, 0);
418 * reads data from the unix connection.
419 * any error is fatal and the connection is closed.
420 * (And a read of zero bytes is a half closed stream => error.)
423 readunix (char *xprtptr
, char *buf
, int len
)
425 SVCXPRT
*xprt
= (SVCXPRT
*) xprtptr
;
426 int sock
= xprt
->xp_sock
;
427 int milliseconds
= 35 * 1000;
428 struct pollfd pollfd
;
433 pollfd
.events
= POLLIN
;
434 switch (__poll (&pollfd
, 1, milliseconds
))
443 if ((pollfd
.revents
& POLLERR
) || (pollfd
.revents
& POLLHUP
)
444 || (pollfd
.revents
& POLLNVAL
))
449 while ((pollfd
.revents
& POLLIN
) == 0);
451 if ((len
= __msgread (sock
, buf
, len
)) > 0)
455 ((struct unix_conn
*) (xprt
->xp_p1
))->strm_stat
= XPRT_DIED
;
460 * writes data to the unix connection.
461 * Any error is fatal and the connection is closed.
464 writeunix (char *xprtptr
, char * buf
, int len
)
466 SVCXPRT
*xprt
= (SVCXPRT
*) xprtptr
;
469 for (cnt
= len
; cnt
> 0; cnt
-= i
, buf
+= i
)
471 if ((i
= __msgwrite (xprt
->xp_sock
, buf
, cnt
)) < 0)
473 ((struct unix_conn
*) (xprt
->xp_p1
))->strm_stat
= XPRT_DIED
;
480 static enum xprt_stat
481 svcunix_stat (SVCXPRT
*xprt
)
483 struct unix_conn
*cd
=
484 (struct unix_conn
*) (xprt
->xp_p1
);
486 if (cd
->strm_stat
== XPRT_DIED
)
488 if (!xdrrec_eof (&(cd
->xdrs
)))
489 return XPRT_MOREREQS
;
494 svcunix_recv (SVCXPRT
*xprt
, struct rpc_msg
*msg
)
496 struct unix_conn
*cd
= (struct unix_conn
*) (xprt
->xp_p1
);
497 XDR
*xdrs
= &(cd
->xdrs
);
499 xdrs
->x_op
= XDR_DECODE
;
500 xdrrec_skiprecord (xdrs
);
501 if (xdr_callmsg (xdrs
, msg
))
503 cd
->x_id
= msg
->rm_xid
;
504 /* set up verifiers */
505 #ifdef SCM_CREDENTIALS
506 msg
->rm_call
.cb_verf
.oa_flavor
= AUTH_UNIX
;
507 msg
->rm_call
.cb_verf
.oa_base
= (caddr_t
) &cm
;
508 msg
->rm_call
.cb_verf
.oa_length
= sizeof (cm
);
512 cd
->strm_stat
= XPRT_DIED
; /* XXXX */
517 svcunix_getargs (SVCXPRT
*xprt
, xdrproc_t xdr_args
, caddr_t args_ptr
)
519 return (*xdr_args
) (&(((struct unix_conn
*) (xprt
->xp_p1
))->xdrs
),
524 svcunix_freeargs (SVCXPRT
*xprt
, xdrproc_t xdr_args
, caddr_t args_ptr
)
526 XDR
*xdrs
= &(((struct unix_conn
*) (xprt
->xp_p1
))->xdrs
);
528 xdrs
->x_op
= XDR_FREE
;
529 return (*xdr_args
) (xdrs
, args_ptr
);
533 svcunix_reply (SVCXPRT
*xprt
, struct rpc_msg
*msg
)
535 struct unix_conn
*cd
= (struct unix_conn
*) (xprt
->xp_p1
);
536 XDR
*xdrs
= &(cd
->xdrs
);
539 xdrs
->x_op
= XDR_ENCODE
;
540 msg
->rm_xid
= cd
->x_id
;
541 stat
= xdr_replymsg (xdrs
, msg
);
542 (void) xdrrec_endofrecord (xdrs
, TRUE
);