mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-04 07:03:57 +08:00
021db4be6f
New configure option --enable-obsolete-rpc makes the deprecated RPC headers and functions available at compile time as they were before version 2.14. This option will be removed at some time in the future after the TI-RPC library becomes fully sufficient for the needs of existing applications.
559 lines
14 KiB
C
559 lines
14 KiB
C
/*
|
||
* svc.c, Server-side remote procedure call interface.
|
||
*
|
||
* There are two sets of procedures here. The xprt routines are
|
||
* for handling transport handles. The svc routines handle the
|
||
* list of service routines.
|
||
*
|
||
* Copyright (c) 2010, Oracle America, Inc.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are
|
||
* met:
|
||
*
|
||
* * Redistributions of source code must retain the above copyright
|
||
* notice, this list of conditions and the following disclaimer.
|
||
* * Redistributions in binary form must reproduce the above
|
||
* copyright notice, this list of conditions and the following
|
||
* disclaimer in the documentation and/or other materials
|
||
* provided with the distribution.
|
||
* * Neither the name of the "Oracle America, Inc." nor the names of its
|
||
* contributors may be used to endorse or promote products derived
|
||
* from this software without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
|
||
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
||
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
*/
|
||
|
||
#include <errno.h>
|
||
#include <unistd.h>
|
||
#include <rpc/rpc.h>
|
||
#include <rpc/svc.h>
|
||
#include <rpc/pmap_clnt.h>
|
||
#include <sys/poll.h>
|
||
|
||
#ifdef _RPC_THREAD_SAFE_
|
||
#define xports RPC_THREAD_VARIABLE(svc_xports_s)
|
||
#else
|
||
static SVCXPRT **xports;
|
||
#endif
|
||
|
||
#define NULL_SVC ((struct svc_callout *)0)
|
||
#define RQCRED_SIZE 400 /* this size is excessive */
|
||
|
||
/* The services list
|
||
Each entry represents a set of procedures (an rpc program).
|
||
The dispatch routine takes request structs and runs the
|
||
appropriate procedure. */
|
||
struct svc_callout {
|
||
struct svc_callout *sc_next;
|
||
rpcprog_t sc_prog;
|
||
rpcvers_t sc_vers;
|
||
void (*sc_dispatch) (struct svc_req *, SVCXPRT *);
|
||
bool_t sc_mapped;
|
||
};
|
||
#ifdef _RPC_THREAD_SAFE_
|
||
#define svc_head RPC_THREAD_VARIABLE(svc_head_s)
|
||
#else
|
||
static struct svc_callout *svc_head;
|
||
#endif
|
||
|
||
/* *************** SVCXPRT related stuff **************** */
|
||
|
||
/* Activate a transport handle. */
|
||
void
|
||
xprt_register (SVCXPRT *xprt)
|
||
{
|
||
register int sock = xprt->xp_sock;
|
||
register int i;
|
||
|
||
if (xports == NULL)
|
||
{
|
||
xports = (SVCXPRT **) malloc (_rpc_dtablesize () * sizeof (SVCXPRT *));
|
||
if (xports == NULL) /* Don<6F>t add handle */
|
||
return;
|
||
}
|
||
|
||
if (sock < _rpc_dtablesize ())
|
||
{
|
||
struct pollfd *new_svc_pollfd;
|
||
|
||
xports[sock] = xprt;
|
||
if (sock < FD_SETSIZE)
|
||
FD_SET (sock, &svc_fdset);
|
||
|
||
/* Check if we have an empty slot */
|
||
for (i = 0; i < svc_max_pollfd; ++i)
|
||
if (svc_pollfd[i].fd == -1)
|
||
{
|
||
svc_pollfd[i].fd = sock;
|
||
svc_pollfd[i].events = (POLLIN | POLLPRI |
|
||
POLLRDNORM | POLLRDBAND);
|
||
return;
|
||
}
|
||
|
||
new_svc_pollfd = (struct pollfd *) realloc (svc_pollfd,
|
||
sizeof (struct pollfd)
|
||
* (svc_max_pollfd + 1));
|
||
if (new_svc_pollfd == NULL) /* Out of memory */
|
||
return;
|
||
svc_pollfd = new_svc_pollfd;
|
||
++svc_max_pollfd;
|
||
|
||
svc_pollfd[svc_max_pollfd - 1].fd = sock;
|
||
svc_pollfd[svc_max_pollfd - 1].events = (POLLIN | POLLPRI |
|
||
POLLRDNORM | POLLRDBAND);
|
||
}
|
||
}
|
||
libc_hidden_nolink_sunrpc (xprt_register, GLIBC_2_0)
|
||
|
||
/* De-activate a transport handle. */
|
||
void
|
||
xprt_unregister (SVCXPRT *xprt)
|
||
{
|
||
register int sock = xprt->xp_sock;
|
||
register int i;
|
||
|
||
if ((sock < _rpc_dtablesize ()) && (xports[sock] == xprt))
|
||
{
|
||
xports[sock] = (SVCXPRT *) 0;
|
||
|
||
if (sock < FD_SETSIZE)
|
||
FD_CLR (sock, &svc_fdset);
|
||
|
||
for (i = 0; i < svc_max_pollfd; ++i)
|
||
if (svc_pollfd[i].fd == sock)
|
||
svc_pollfd[i].fd = -1;
|
||
}
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (xprt_unregister)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (xprt_unregister, GLIBC_2_0)
|
||
#endif
|
||
|
||
|
||
/* ********************** CALLOUT list related stuff ************* */
|
||
|
||
/* Search the callout list for a program number, return the callout
|
||
struct. */
|
||
static struct svc_callout *
|
||
svc_find (rpcprog_t prog, rpcvers_t vers, struct svc_callout **prev)
|
||
{
|
||
register struct svc_callout *s, *p;
|
||
|
||
p = NULL_SVC;
|
||
for (s = svc_head; s != NULL_SVC; s = s->sc_next)
|
||
{
|
||
if ((s->sc_prog == prog) && (s->sc_vers == vers))
|
||
goto done;
|
||
p = s;
|
||
}
|
||
done:
|
||
*prev = p;
|
||
return s;
|
||
}
|
||
|
||
|
||
static bool_t
|
||
svc_is_mapped (rpcprog_t prog, rpcvers_t vers)
|
||
{
|
||
struct svc_callout *prev;
|
||
register struct svc_callout *s;
|
||
s = svc_find (prog, vers, &prev);
|
||
return s!= NULL_SVC && s->sc_mapped;
|
||
}
|
||
|
||
|
||
/* Add a service program to the callout list.
|
||
The dispatch routine will be called when a rpc request for this
|
||
program number comes in. */
|
||
bool_t
|
||
svc_register (SVCXPRT * xprt, rpcprog_t prog, rpcvers_t vers,
|
||
void (*dispatch) (struct svc_req *, SVCXPRT *),
|
||
rpcproc_t protocol)
|
||
{
|
||
struct svc_callout *prev;
|
||
register struct svc_callout *s;
|
||
|
||
if ((s = svc_find (prog, vers, &prev)) != NULL_SVC)
|
||
{
|
||
if (s->sc_dispatch == dispatch)
|
||
goto pmap_it; /* he is registering another xptr */
|
||
return FALSE;
|
||
}
|
||
s = (struct svc_callout *) mem_alloc (sizeof (struct svc_callout));
|
||
if (s == (struct svc_callout *) 0)
|
||
return FALSE;
|
||
|
||
s->sc_prog = prog;
|
||
s->sc_vers = vers;
|
||
s->sc_dispatch = dispatch;
|
||
s->sc_next = svc_head;
|
||
s->sc_mapped = FALSE;
|
||
svc_head = s;
|
||
|
||
pmap_it:
|
||
/* now register the information with the local binder service */
|
||
if (protocol)
|
||
{
|
||
if (! pmap_set (prog, vers, protocol, xprt->xp_port))
|
||
return FALSE;
|
||
|
||
s->sc_mapped = TRUE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (svc_register)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (svc_register, GLIBC_2_0)
|
||
#endif
|
||
|
||
/* Remove a service program from the callout list. */
|
||
void
|
||
svc_unregister (rpcprog_t prog, rpcvers_t vers)
|
||
{
|
||
struct svc_callout *prev;
|
||
register struct svc_callout *s;
|
||
|
||
if ((s = svc_find (prog, vers, &prev)) == NULL_SVC)
|
||
return;
|
||
|
||
if (prev == NULL_SVC)
|
||
svc_head = s->sc_next;
|
||
else
|
||
prev->sc_next = s->sc_next;
|
||
|
||
s->sc_next = NULL_SVC;
|
||
mem_free ((char *) s, (u_int) sizeof (struct svc_callout));
|
||
/* now unregister the information with the local binder service */
|
||
if (! svc_is_mapped (prog, vers))
|
||
pmap_unset (prog, vers);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svc_unregister, GLIBC_2_0)
|
||
|
||
/* ******************* REPLY GENERATION ROUTINES ************ */
|
||
|
||
/* Send a reply to an rpc request */
|
||
bool_t
|
||
svc_sendreply (register SVCXPRT *xprt, xdrproc_t xdr_results,
|
||
caddr_t xdr_location)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_ACCEPTED;
|
||
rply.acpted_rply.ar_verf = xprt->xp_verf;
|
||
rply.acpted_rply.ar_stat = SUCCESS;
|
||
rply.acpted_rply.ar_results.where = xdr_location;
|
||
rply.acpted_rply.ar_results.proc = xdr_results;
|
||
return SVC_REPLY (xprt, &rply);
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (svc_sendreply)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (svc_sendreply, GLIBC_2_0)
|
||
#endif
|
||
|
||
/* No procedure error reply */
|
||
void
|
||
svcerr_noproc (register SVCXPRT *xprt)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_ACCEPTED;
|
||
rply.acpted_rply.ar_verf = xprt->xp_verf;
|
||
rply.acpted_rply.ar_stat = PROC_UNAVAIL;
|
||
SVC_REPLY (xprt, &rply);
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (svcerr_noproc)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (svcerr_noproc, GLIBC_2_0)
|
||
#endif
|
||
|
||
/* Can't decode args error reply */
|
||
void
|
||
svcerr_decode (register SVCXPRT *xprt)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_ACCEPTED;
|
||
rply.acpted_rply.ar_verf = xprt->xp_verf;
|
||
rply.acpted_rply.ar_stat = GARBAGE_ARGS;
|
||
SVC_REPLY (xprt, &rply);
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (svcerr_decode)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (svcerr_decode, GLIBC_2_0)
|
||
#endif
|
||
|
||
/* Some system error */
|
||
void
|
||
svcerr_systemerr (register SVCXPRT *xprt)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_ACCEPTED;
|
||
rply.acpted_rply.ar_verf = xprt->xp_verf;
|
||
rply.acpted_rply.ar_stat = SYSTEM_ERR;
|
||
SVC_REPLY (xprt, &rply);
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (svcerr_systemerr)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (svcerr_systemerr, GLIBC_2_0)
|
||
#endif
|
||
|
||
/* Authentication error reply */
|
||
void
|
||
svcerr_auth (SVCXPRT *xprt, enum auth_stat why)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_DENIED;
|
||
rply.rjcted_rply.rj_stat = AUTH_ERROR;
|
||
rply.rjcted_rply.rj_why = why;
|
||
SVC_REPLY (xprt, &rply);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svcerr_auth, GLIBC_2_0)
|
||
|
||
/* Auth too weak error reply */
|
||
void
|
||
svcerr_weakauth (SVCXPRT *xprt)
|
||
{
|
||
svcerr_auth (xprt, AUTH_TOOWEAK);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svcerr_weakauth, GLIBC_2_0)
|
||
|
||
/* Program unavailable error reply */
|
||
void
|
||
svcerr_noprog (register SVCXPRT *xprt)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_ACCEPTED;
|
||
rply.acpted_rply.ar_verf = xprt->xp_verf;
|
||
rply.acpted_rply.ar_stat = PROG_UNAVAIL;
|
||
SVC_REPLY (xprt, &rply);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svcerr_noprog, GLIBC_2_0)
|
||
|
||
/* Program version mismatch error reply */
|
||
void
|
||
svcerr_progvers (register SVCXPRT *xprt, rpcvers_t low_vers,
|
||
rpcvers_t high_vers)
|
||
{
|
||
struct rpc_msg rply;
|
||
|
||
rply.rm_direction = REPLY;
|
||
rply.rm_reply.rp_stat = MSG_ACCEPTED;
|
||
rply.acpted_rply.ar_verf = xprt->xp_verf;
|
||
rply.acpted_rply.ar_stat = PROG_MISMATCH;
|
||
rply.acpted_rply.ar_vers.low = low_vers;
|
||
rply.acpted_rply.ar_vers.high = high_vers;
|
||
SVC_REPLY (xprt, &rply);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svcerr_progvers, GLIBC_2_0)
|
||
|
||
/* ******************* SERVER INPUT STUFF ******************* */
|
||
|
||
/*
|
||
* Get server side input from some transport.
|
||
*
|
||
* Statement of authentication parameters management:
|
||
* This function owns and manages all authentication parameters, specifically
|
||
* the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
|
||
* the "cooked" credentials (rqst->rq_clntcred).
|
||
* However, this function does not know the structure of the cooked
|
||
* credentials, so it make the following assumptions:
|
||
* a) the structure is contiguous (no pointers), and
|
||
* b) the cred structure size does not exceed RQCRED_SIZE bytes.
|
||
* In all events, all three parameters are freed upon exit from this routine.
|
||
* The storage is trivially management on the call stack in user land, but
|
||
* is mallocated in kernel land.
|
||
*/
|
||
|
||
void
|
||
svc_getreq (int rdfds)
|
||
{
|
||
fd_set readfds;
|
||
|
||
FD_ZERO (&readfds);
|
||
readfds.fds_bits[0] = rdfds;
|
||
svc_getreqset (&readfds);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svc_getreq, GLIBC_2_0)
|
||
|
||
void
|
||
svc_getreqset (fd_set *readfds)
|
||
{
|
||
register fd_mask mask;
|
||
register fd_mask *maskp;
|
||
register int setsize;
|
||
register int sock;
|
||
register int bit;
|
||
|
||
setsize = _rpc_dtablesize ();
|
||
if (setsize > FD_SETSIZE)
|
||
setsize = FD_SETSIZE;
|
||
maskp = readfds->fds_bits;
|
||
for (sock = 0; sock < setsize; sock += NFDBITS)
|
||
for (mask = *maskp++; (bit = ffsl (mask)); mask ^= (1L << (bit - 1)))
|
||
svc_getreq_common (sock + bit - 1);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svc_getreqset, GLIBC_2_0)
|
||
|
||
void
|
||
svc_getreq_poll (struct pollfd *pfdp, int pollretval)
|
||
{
|
||
if (pollretval == 0)
|
||
return;
|
||
|
||
register int fds_found;
|
||
for (int i = fds_found = 0; i < svc_max_pollfd; ++i)
|
||
{
|
||
register struct pollfd *p = &pfdp[i];
|
||
|
||
if (p->fd != -1 && p->revents)
|
||
{
|
||
/* fd has input waiting */
|
||
if (p->revents & POLLNVAL)
|
||
xprt_unregister (xports[p->fd]);
|
||
else
|
||
svc_getreq_common (p->fd);
|
||
|
||
if (++fds_found >= pollretval)
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
#ifdef EXPORT_RPC_SYMBOLS
|
||
libc_hidden_def (svc_getreq_poll)
|
||
#else
|
||
libc_hidden_nolink_sunrpc (svc_getreq_poll, GLIBC_2_2)
|
||
#endif
|
||
|
||
|
||
void
|
||
svc_getreq_common (const int fd)
|
||
{
|
||
enum xprt_stat stat;
|
||
struct rpc_msg msg;
|
||
register SVCXPRT *xprt;
|
||
char cred_area[2 * MAX_AUTH_BYTES + RQCRED_SIZE];
|
||
msg.rm_call.cb_cred.oa_base = cred_area;
|
||
msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]);
|
||
|
||
xprt = xports[fd];
|
||
/* Do we control fd? */
|
||
if (xprt == NULL)
|
||
return;
|
||
|
||
/* now receive msgs from xprtprt (support batch calls) */
|
||
do
|
||
{
|
||
if (SVC_RECV (xprt, &msg))
|
||
{
|
||
/* now find the exported program and call it */
|
||
struct svc_callout *s;
|
||
struct svc_req r;
|
||
enum auth_stat why;
|
||
rpcvers_t low_vers;
|
||
rpcvers_t high_vers;
|
||
int prog_found;
|
||
|
||
r.rq_clntcred = &(cred_area[2 * MAX_AUTH_BYTES]);
|
||
r.rq_xprt = xprt;
|
||
r.rq_prog = msg.rm_call.cb_prog;
|
||
r.rq_vers = msg.rm_call.cb_vers;
|
||
r.rq_proc = msg.rm_call.cb_proc;
|
||
r.rq_cred = msg.rm_call.cb_cred;
|
||
|
||
/* first authenticate the message */
|
||
/* Check for null flavor and bypass these calls if possible */
|
||
|
||
if (msg.rm_call.cb_cred.oa_flavor == AUTH_NULL)
|
||
{
|
||
r.rq_xprt->xp_verf.oa_flavor = _null_auth.oa_flavor;
|
||
r.rq_xprt->xp_verf.oa_length = 0;
|
||
}
|
||
else if ((why = _authenticate (&r, &msg)) != AUTH_OK)
|
||
{
|
||
svcerr_auth (xprt, why);
|
||
goto call_done;
|
||
}
|
||
|
||
/* now match message with a registered service */
|
||
prog_found = FALSE;
|
||
low_vers = 0 - 1;
|
||
high_vers = 0;
|
||
|
||
for (s = svc_head; s != NULL_SVC; s = s->sc_next)
|
||
{
|
||
if (s->sc_prog == r.rq_prog)
|
||
{
|
||
if (s->sc_vers == r.rq_vers)
|
||
{
|
||
(*s->sc_dispatch) (&r, xprt);
|
||
goto call_done;
|
||
}
|
||
/* found correct version */
|
||
prog_found = TRUE;
|
||
if (s->sc_vers < low_vers)
|
||
low_vers = s->sc_vers;
|
||
if (s->sc_vers > high_vers)
|
||
high_vers = s->sc_vers;
|
||
}
|
||
/* found correct program */
|
||
}
|
||
/* if we got here, the program or version
|
||
is not served ... */
|
||
if (prog_found)
|
||
svcerr_progvers (xprt, low_vers, high_vers);
|
||
else
|
||
svcerr_noprog (xprt);
|
||
/* Fall through to ... */
|
||
}
|
||
call_done:
|
||
if ((stat = SVC_STAT (xprt)) == XPRT_DIED)
|
||
{
|
||
SVC_DESTROY (xprt);
|
||
break;
|
||
}
|
||
}
|
||
while (stat == XPRT_MOREREQS);
|
||
}
|
||
libc_hidden_nolink_sunrpc (svc_getreq_common, GLIBC_2_2)
|
||
|
||
#ifdef _RPC_THREAD_SAFE_
|
||
|
||
void
|
||
__rpc_thread_svc_cleanup (void)
|
||
{
|
||
struct svc_callout *svcp;
|
||
|
||
while ((svcp = svc_head) != NULL)
|
||
svc_unregister (svcp->sc_prog, svcp->sc_vers);
|
||
}
|
||
|
||
#endif /* _RPC_THREAD_SAFE_ */
|