f67e4a8fc7
associated changes that had to happen to make this possible as well as bugs fixed along the way. Bring in required TLI library routines to support this. Since we don't support TLI we've essentially copied what NetBSD has done, adding a thin layer to emulate direct the TLI calls into BSD socket calls. This is mostly from Sun's tirpc release that was made in 1994, however some fixes were backported from the 1999 release (supposedly only made available after this porting effort was underway). The submitter has agreed to continue on and bring us up to the 1999 release. Several key features are introduced with this update: Client calls are thread safe. (1999 code has server side thread safe) Updated, a more modern interface. Many userland updates were done to bring the code up to par with the recent RPC API. There is an update to the pthreads library, a function pthread_main_np() was added to emulate a function of Sun's threads library. While we're at it, bring in NetBSD's lockd, it's been far too long of a wait. New rpcbind(8) replaces portmap(8) (supporting communication over an authenticated Unix-domain socket, and by default only allowing set and unset requests over that channel). It's much more secure than the old portmapper. Umount(8), mountd(8), mount_nfs(8), nfsd(8) have also been upgraded to support TI-RPC and to support IPV6. Umount(8) is also fixed to unmount pathnames longer than 80 chars, which are currently truncated by the Kernel statfs structure. Submitted by: Martin Blapp <mb@imp.ch> Manpage review: ru Secure RPC implemented by: wpaul
717 lines
16 KiB
C
717 lines
16 KiB
C
/* $NetBSD: svc.c,v 1.21 2000/07/06 03:10:35 christos Exp $ */
|
|
|
|
/*
|
|
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
|
* unrestricted use provided that this legend is included on all tape
|
|
* media and as a part of the software program in whole or part. Users
|
|
* may copy or modify Sun RPC without charge, but are not authorized
|
|
* to license or distribute it to anyone else except as part of a product or
|
|
* program developed by the user.
|
|
*
|
|
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
|
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
|
*
|
|
* Sun RPC is provided with no support and without any obligation on the
|
|
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
|
* modification or enhancement.
|
|
*
|
|
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
|
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
|
* OR ANY PART THEREOF.
|
|
*
|
|
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
|
* or profits or other special, indirect and consequential damages, even if
|
|
* Sun has been advised of the possibility of such damages.
|
|
*
|
|
* Sun Microsystems, Inc.
|
|
* 2550 Garcia Avenue
|
|
* Mountain View, California 94043
|
|
*/
|
|
|
|
#if defined(LIBC_SCCS) && !defined(lint)
|
|
/*static char *sccsid = "from: @(#)svc.c 1.44 88/02/08 Copyr 1984 Sun Micro";*/
|
|
/*static char *sccsid = "from: @(#)svc.c 2.4 88/08/11 4.0 RPCSRC";*/
|
|
static char *rcsid = "$FreeBSD$";
|
|
#endif
|
|
|
|
/*
|
|
* 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) 1984, Sun Microsystems, Inc.
|
|
*/
|
|
|
|
#include "reentrant.h"
|
|
#include "namespace.h"
|
|
#include <sys/types.h>
|
|
#include <sys/poll.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <rpc/rpc.h>
|
|
#ifdef PORTMAP
|
|
#include <rpc/pmap_clnt.h>
|
|
#endif /* PORTMAP */
|
|
#include "un-namespace.h"
|
|
|
|
#include "rpc_com.h"
|
|
|
|
static SVCXPRT **xports;
|
|
|
|
#define RQCRED_SIZE 400 /* this size is excessive */
|
|
|
|
#define SVC_VERSQUIET 0x0001 /* keep quiet about vers mismatch */
|
|
#define version_keepquiet(xp) ((u_long)(xp)->xp_p3 & SVC_VERSQUIET)
|
|
|
|
#define max(a, b) (a > b ? a : b)
|
|
|
|
/*
|
|
* The services list
|
|
* Each entry represents a set of procedures (an rpc program).
|
|
* The dispatch routine takes request structs and runs the
|
|
* apropriate procedure.
|
|
*/
|
|
static struct svc_callout {
|
|
struct svc_callout *sc_next;
|
|
rpcprog_t sc_prog;
|
|
rpcvers_t sc_vers;
|
|
char *sc_netid;
|
|
void (*sc_dispatch) __P((struct svc_req *, SVCXPRT *));
|
|
} *svc_head;
|
|
|
|
extern rwlock_t svc_lock;
|
|
extern rwlock_t svc_fd_lock;
|
|
|
|
static struct svc_callout *svc_find __P((rpcprog_t, rpcvers_t,
|
|
struct svc_callout **, char *));
|
|
|
|
/* *************** SVCXPRT related stuff **************** */
|
|
|
|
/*
|
|
* Activate a transport handle.
|
|
*/
|
|
void
|
|
xprt_register(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
int sock;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
sock = xprt->xp_fd;
|
|
|
|
rwlock_wrlock(&svc_fd_lock);
|
|
if (xports == NULL) {
|
|
xports = (SVCXPRT **)
|
|
mem_alloc(FD_SETSIZE * sizeof(SVCXPRT *));
|
|
if (xports == NULL)
|
|
return;
|
|
memset(xports, '\0', FD_SETSIZE * sizeof(SVCXPRT *));
|
|
}
|
|
if (sock < FD_SETSIZE) {
|
|
xports[sock] = xprt;
|
|
FD_SET(sock, &svc_fdset);
|
|
svc_maxfd = max(svc_maxfd, sock);
|
|
}
|
|
rwlock_unlock(&svc_fd_lock);
|
|
}
|
|
|
|
/*
|
|
* De-activate a transport handle.
|
|
*/
|
|
void
|
|
xprt_unregister(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
int sock;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
sock = xprt->xp_fd;
|
|
|
|
rwlock_wrlock(&svc_fd_lock);
|
|
if ((sock < FD_SETSIZE) && (xports[sock] == xprt)) {
|
|
xports[sock] = NULL;
|
|
FD_CLR(sock, &svc_fdset);
|
|
if (sock >= svc_maxfd) {
|
|
for (svc_maxfd--; svc_maxfd>=0; svc_maxfd--)
|
|
if (xports[svc_maxfd])
|
|
break;
|
|
}
|
|
}
|
|
rwlock_unlock(&svc_fd_lock);
|
|
}
|
|
|
|
/*
|
|
* 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_reg(xprt, prog, vers, dispatch, nconf)
|
|
SVCXPRT *xprt;
|
|
const rpcprog_t prog;
|
|
const rpcvers_t vers;
|
|
void (*dispatch) __P((struct svc_req *, SVCXPRT *));
|
|
const struct netconfig *nconf;
|
|
{
|
|
bool_t dummy;
|
|
struct svc_callout *prev;
|
|
struct svc_callout *s;
|
|
struct netconfig *tnconf;
|
|
char *netid = NULL;
|
|
int flag = 0;
|
|
|
|
/* VARIABLES PROTECTED BY svc_lock: s, prev, svc_head */
|
|
|
|
if (xprt->xp_netid) {
|
|
netid = strdup(xprt->xp_netid);
|
|
flag = 1;
|
|
} else if (nconf && nconf->nc_netid) {
|
|
netid = strdup(nconf->nc_netid);
|
|
flag = 1;
|
|
} else if ((tnconf = __rpcgettp(xprt->xp_fd)) != NULL) {
|
|
netid = strdup(tnconf->nc_netid);
|
|
flag = 1;
|
|
freenetconfigent(tnconf);
|
|
} /* must have been created with svc_raw_create */
|
|
if ((netid == NULL) && (flag == 1)) {
|
|
return (FALSE);
|
|
}
|
|
|
|
rwlock_wrlock(&svc_lock);
|
|
if ((s = svc_find(prog, vers, &prev, netid)) != NULL) {
|
|
if (netid)
|
|
free(netid);
|
|
if (s->sc_dispatch == dispatch)
|
|
goto rpcb_it; /* he is registering another xptr */
|
|
rwlock_unlock(&svc_lock);
|
|
return (FALSE);
|
|
}
|
|
s = mem_alloc(sizeof (struct svc_callout));
|
|
if (s == NULL) {
|
|
if (netid)
|
|
free(netid);
|
|
rwlock_unlock(&svc_lock);
|
|
return (FALSE);
|
|
}
|
|
|
|
s->sc_prog = prog;
|
|
s->sc_vers = vers;
|
|
s->sc_dispatch = dispatch;
|
|
s->sc_netid = netid;
|
|
s->sc_next = svc_head;
|
|
svc_head = s;
|
|
|
|
if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
|
|
((SVCXPRT *) xprt)->xp_netid = strdup(netid);
|
|
|
|
rpcb_it:
|
|
rwlock_unlock(&svc_lock);
|
|
/* now register the information with the local binder service */
|
|
if (nconf) {
|
|
/*LINTED const castaway*/
|
|
dummy = rpcb_set(prog, vers, (struct netconfig *) nconf,
|
|
&((SVCXPRT *) xprt)->xp_ltaddr);
|
|
return (dummy);
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
/*
|
|
* Remove a service program from the callout list.
|
|
*/
|
|
void
|
|
svc_unreg(prog, vers)
|
|
const rpcprog_t prog;
|
|
const rpcvers_t vers;
|
|
{
|
|
struct svc_callout *prev;
|
|
struct svc_callout *s;
|
|
|
|
/* unregister the information anyway */
|
|
(void) rpcb_unset(prog, vers, NULL);
|
|
rwlock_wrlock(&svc_lock);
|
|
while ((s = svc_find(prog, vers, &prev, NULL)) != NULL) {
|
|
if (prev == NULL) {
|
|
svc_head = s->sc_next;
|
|
} else {
|
|
prev->sc_next = s->sc_next;
|
|
}
|
|
s->sc_next = NULL;
|
|
if (s->sc_netid)
|
|
mem_free(s->sc_netid, sizeof (s->sc_netid) + 1);
|
|
mem_free(s, sizeof (struct svc_callout));
|
|
}
|
|
rwlock_unlock(&svc_lock);
|
|
}
|
|
|
|
/* ********************** CALLOUT list related stuff ************* */
|
|
|
|
#ifdef PORTMAP
|
|
/*
|
|
* 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(xprt, prog, vers, dispatch, protocol)
|
|
SVCXPRT *xprt;
|
|
u_long prog;
|
|
u_long vers;
|
|
void (*dispatch) __P((struct svc_req *, SVCXPRT *));
|
|
int protocol;
|
|
{
|
|
struct svc_callout *prev;
|
|
struct svc_callout *s;
|
|
|
|
assert(xprt != NULL);
|
|
assert(dispatch != NULL);
|
|
|
|
if ((s = svc_find((rpcprog_t)prog, (rpcvers_t)vers, &prev, NULL)) !=
|
|
NULL) {
|
|
if (s->sc_dispatch == dispatch)
|
|
goto pmap_it; /* he is registering another xptr */
|
|
return (FALSE);
|
|
}
|
|
s = mem_alloc(sizeof(struct svc_callout));
|
|
if (s == NULL) {
|
|
return (FALSE);
|
|
}
|
|
s->sc_prog = (rpcprog_t)prog;
|
|
s->sc_vers = (rpcvers_t)vers;
|
|
s->sc_dispatch = dispatch;
|
|
s->sc_next = svc_head;
|
|
svc_head = s;
|
|
pmap_it:
|
|
/* now register the information with the local binder service */
|
|
if (protocol) {
|
|
return (pmap_set(prog, vers, protocol, xprt->xp_port));
|
|
}
|
|
return (TRUE);
|
|
}
|
|
|
|
/*
|
|
* Remove a service program from the callout list.
|
|
*/
|
|
void
|
|
svc_unregister(prog, vers)
|
|
u_long prog;
|
|
u_long vers;
|
|
{
|
|
struct svc_callout *prev;
|
|
struct svc_callout *s;
|
|
|
|
if ((s = svc_find((rpcprog_t)prog, (rpcvers_t)vers, &prev, NULL)) ==
|
|
NULL)
|
|
return;
|
|
if (prev == NULL) {
|
|
svc_head = s->sc_next;
|
|
} else {
|
|
prev->sc_next = s->sc_next;
|
|
}
|
|
s->sc_next = NULL;
|
|
mem_free(s, sizeof(struct svc_callout));
|
|
/* now unregister the information with the local binder service */
|
|
(void)pmap_unset(prog, vers);
|
|
}
|
|
#endif /* PORTMAP */
|
|
|
|
/*
|
|
* Search the callout list for a program number, return the callout
|
|
* struct.
|
|
*/
|
|
static struct svc_callout *
|
|
svc_find(prog, vers, prev, netid)
|
|
rpcprog_t prog;
|
|
rpcvers_t vers;
|
|
struct svc_callout **prev;
|
|
char *netid;
|
|
{
|
|
struct svc_callout *s, *p;
|
|
|
|
assert(prev != NULL);
|
|
|
|
p = NULL;
|
|
for (s = svc_head; s != NULL; s = s->sc_next) {
|
|
if (((s->sc_prog == prog) && (s->sc_vers == vers)) &&
|
|
((netid == NULL) || (s->sc_netid == NULL) ||
|
|
(strcmp(netid, s->sc_netid) == 0)))
|
|
break;
|
|
p = s;
|
|
}
|
|
*prev = p;
|
|
return (s);
|
|
}
|
|
|
|
/* ******************* REPLY GENERATION ROUTINES ************ */
|
|
|
|
/*
|
|
* Send a reply to an rpc request
|
|
*/
|
|
bool_t
|
|
svc_sendreply(xprt, xdr_results, xdr_location)
|
|
SVCXPRT *xprt;
|
|
xdrproc_t xdr_results;
|
|
caddr_t xdr_location;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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));
|
|
}
|
|
|
|
/*
|
|
* No procedure error reply
|
|
*/
|
|
void
|
|
svcerr_noproc(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Can't decode args error reply
|
|
*/
|
|
void
|
|
svcerr_decode(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Some system error
|
|
*/
|
|
void
|
|
svcerr_systemerr(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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);
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* Tell RPC package to not complain about version errors to the client. This
|
|
* is useful when revving broadcast protocols that sit on a fixed address.
|
|
* There is really one (or should be only one) example of this kind of
|
|
* protocol: the portmapper (or rpc binder).
|
|
*/
|
|
void
|
|
__svc_versquiet_on(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
u_long tmp;
|
|
|
|
tmp = ((u_long) xprt->xp_p3) | SVC_VERSQUIET;
|
|
xprt->xp_p3 = (caddr_t) tmp;
|
|
}
|
|
|
|
void
|
|
__svc_versquiet_off(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
u_long tmp;
|
|
|
|
tmp = ((u_long) xprt->xp_p3) & ~SVC_VERSQUIET;
|
|
xprt->xp_p3 = (caddr_t) tmp;
|
|
}
|
|
|
|
void
|
|
svc_versquiet(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
__svc_versquiet_on(xprt);
|
|
}
|
|
|
|
int
|
|
__svc_versquiet_get(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
return ((int) xprt->xp_p3) & SVC_VERSQUIET;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Authentication error reply
|
|
*/
|
|
void
|
|
svcerr_auth(xprt, why)
|
|
SVCXPRT *xprt;
|
|
enum auth_stat why;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Auth too weak error reply
|
|
*/
|
|
void
|
|
svcerr_weakauth(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
|
|
assert(xprt != NULL);
|
|
|
|
svcerr_auth(xprt, AUTH_TOOWEAK);
|
|
}
|
|
|
|
/*
|
|
* Program unavailable error reply
|
|
*/
|
|
void
|
|
svcerr_noprog(xprt)
|
|
SVCXPRT *xprt;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* Program version mismatch error reply
|
|
*/
|
|
void
|
|
svcerr_progvers(xprt, low_vers, high_vers)
|
|
SVCXPRT *xprt;
|
|
rpcvers_t low_vers;
|
|
rpcvers_t high_vers;
|
|
{
|
|
struct rpc_msg rply;
|
|
|
|
assert(xprt != NULL);
|
|
|
|
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 = (u_int32_t)low_vers;
|
|
rply.acpted_rply.ar_vers.high = (u_int32_t)high_vers;
|
|
SVC_REPLY(xprt, &rply);
|
|
}
|
|
|
|
/* ******************* 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(rdfds)
|
|
int rdfds;
|
|
{
|
|
fd_set readfds;
|
|
|
|
FD_ZERO(&readfds);
|
|
readfds.fds_bits[0] = rdfds;
|
|
svc_getreqset(&readfds);
|
|
}
|
|
|
|
void
|
|
svc_getreqset(readfds)
|
|
fd_set *readfds;
|
|
{
|
|
int bit, fd;
|
|
fd_mask mask, *maskp;
|
|
int sock;
|
|
|
|
assert(readfds != NULL);
|
|
|
|
maskp = readfds->fds_bits;
|
|
for (sock = 0; sock < FD_SETSIZE; sock += NFDBITS) {
|
|
for (mask = *maskp++; (bit = ffs(mask)) != 0;
|
|
mask ^= (1 << (bit - 1))) {
|
|
/* sock has input waiting */
|
|
fd = sock + bit - 1;
|
|
svc_getreq_common(fd);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
svc_getreq_common(fd)
|
|
int fd;
|
|
{
|
|
SVCXPRT *xprt;
|
|
struct svc_req r;
|
|
struct rpc_msg msg;
|
|
int prog_found;
|
|
rpcvers_t low_vers;
|
|
rpcvers_t high_vers;
|
|
enum xprt_stat stat;
|
|
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]);
|
|
r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);
|
|
|
|
rwlock_rdlock(&svc_fd_lock);
|
|
xprt = xports[fd];
|
|
rwlock_unlock(&svc_fd_lock);
|
|
if (xprt == NULL)
|
|
/* But do we control sock? */
|
|
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;
|
|
enum auth_stat why;
|
|
|
|
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 */
|
|
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 = (rpcvers_t) -1L;
|
|
high_vers = (rpcvers_t) 0L;
|
|
for (s = svc_head; s != NULL; 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 ... */
|
|
}
|
|
/*
|
|
* Check if the xprt has been disconnected in a
|
|
* recursive call in the service dispatch routine.
|
|
* If so, then break.
|
|
*/
|
|
rwlock_rdlock(&svc_fd_lock);
|
|
if (xprt != xports[fd]) {
|
|
rwlock_unlock(&svc_fd_lock);
|
|
break;
|
|
}
|
|
rwlock_unlock(&svc_fd_lock);
|
|
call_done:
|
|
if ((stat = SVC_STAT(xprt)) == XPRT_DIED){
|
|
SVC_DESTROY(xprt);
|
|
break;
|
|
}
|
|
} while (stat == XPRT_MOREREQS);
|
|
}
|
|
|
|
|
|
void
|
|
svc_getreq_poll(pfdp, pollretval)
|
|
struct pollfd *pfdp;
|
|
int pollretval;
|
|
{
|
|
int i;
|
|
int fds_found;
|
|
|
|
for (i = fds_found = 0; fds_found < pollretval; i++) {
|
|
struct pollfd *p = &pfdp[i];
|
|
|
|
if (p->revents) {
|
|
/* fd has input waiting */
|
|
fds_found++;
|
|
/*
|
|
* We assume that this function is only called
|
|
* via someone _select()ing from svc_fdset or
|
|
* _poll()ing from svc_pollset[]. Thus it's safe
|
|
* to handle the POLLNVAL event by simply turning
|
|
* the corresponding bit off in svc_fdset. The
|
|
* svc_pollset[] array is derived from svc_fdset
|
|
* and so will also be updated eventually.
|
|
*
|
|
* XXX Should we do an xprt_unregister() instead?
|
|
*/
|
|
if (p->revents & POLLNVAL) {
|
|
rwlock_wrlock(&svc_fd_lock);
|
|
FD_CLR(p->fd, &svc_fdset);
|
|
rwlock_unlock(&svc_fd_lock);
|
|
} else
|
|
svc_getreq_common(p->fd);
|
|
}
|
|
}
|
|
}
|