svc.c

VXWORKS源代码

/* svc.c - server-side remote procedure call interface */

/* Copyright 1984-2000 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
 * Copyright (C) 1984, Sun Microsystems, Inc.
 *
 * 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
 */

/*
modification history
--------------------
01q,15oct01,rae  merge from truestack ver 01r, base 01p (AE / 5_X)
01p,12oct94,ism  Added Chris Ford's symptom fix for SPR#3269 (more to come)
01o,26may92,rrr  the tree shuffle
		  -changed includes to have absolute path from h/
01n,04oct91,rrr  passed through the ansification filter
		  -changed includes to have absolute path from h/
		  -changed copyright notice
01m,25oct90,dnw  removed include of utime.h.
01l,10may90,dnw  moved moduleStatics to rpcGbl; removed init/exit routines
		 changed taskModuleList to taskRpcStatics
		 changed to use rpcErrnoGet instead of errnoGet
01k,11may90,yao  added missing modification history (01j) for the last checkin.
01j,09may90,yao  typecasted malloc to (char *).
01i,19apr90,hjb   de-linted.
01h,27oct89,hjb   upgraded to 4.0
01g,19arp89,gae   added svcExit to do tidy cleanup for tasks.
		  changed svcInit to return pointer to moduleStatics.
01f,30may88,dnw   changed to v4 names.
01e,25apr88,gae   oops! forgot name change in svc_run().
01d,23apr88,gae   fixed svc_getreq()/svc_getreqset().
01c,05apr88,gae   updated select() to BSD4.3, i.e. used "fd_set".
01b,11nov87,jlf   added wrs copyright, title, mod history, etc.
01a,01nov87,rdc   first VxWorks version
*/

#ifndef lint
/* static char sccsid[] = "@(#)svc.c 1.1 86/02/03 Copyr 1984 Sun Micro"; */
#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.
 *
 */

#include "rpc/rpctypes.h"
#include "errno.h"
#include "netinet/in.h"
#include "rpc/xdr.h"
#include "rpc/auth.h"
#include "rpc/clnt.h"
#include "rpc/rpc_msg.h"
#include "rpc/svc.h"
#include "rpc/svc_auth.h"
#include "rpc/pmap_clnt.h"
#include "vxWorks.h"
#include "memLib.h"
#include "rpc/rpcGbl.h"
#include "memPartLib.h"
#include "rpcLib.h"
#include "stdio.h"


#define NULL_SVC ((struct svc_callout *)0)
#define	RQCRED_SIZE	400

struct svc_callout *svc_find();

/* ***************  SVCXPRT related stuff **************** */

/*
 * Activate a transport handle.
 */
void
xprt_register(xprt)
	SVCXPRT *xprt;
{
	register int sock = xprt->xp_sock;
	FAST struct svc *ms = &taskRpcStatics->svc;

	if (sock < FD_SETSIZE) {
		ms->xports[sock] = xprt;
		FD_SET(sock, &ms->svc_fdset);
	}
}

/*
 * De-activate a transport handle.
 */
void
xprt_unregister(xprt)
	SVCXPRT *xprt;
{
	register int sock = xprt->xp_sock;
	FAST struct svc *ms = &taskRpcStatics->svc;

	if (taskRpcStatics == 0x0)
        return;

	if ((sock < FD_SETSIZE) && (ms->xports[sock] == xprt)) {
		ms->xports[sock] = (SVCXPRT *)0;
		FD_CLR(sock, &ms->svc_fdset);
	}
}


/* ********************** CALLOUT list related stuff ************* */

/*
 * 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)();
	int protocol;
{
	struct svc_callout *prev;
	register struct svc_callout *s;
	FAST struct svc *ms = &taskRpcStatics->svc;

	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 = ms->svc_head;
	ms->svc_head = s;
pmap_it:
	/* now register the information with the local binder service */
	if (protocol) {
		return (pmap_set(prog, vers, (u_long) 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;
	register struct svc_callout *s;
	FAST struct svc *ms = &taskRpcStatics->svc;

	if ((s = svc_find(prog, vers, &prev)) == NULL_SVC)
		return;
	if (prev == NULL_SVC) {
		ms->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 */
	(void)pmap_unset(prog, vers);
}

/*
 * Search the callout list for a program number, return the callout
 * struct.
 */
struct svc_callout *
svc_find(prog, vers, prev)
	u_long prog;
	u_long vers;
	struct svc_callout **prev;
{
	register struct svc_callout *s, *p;
	FAST struct svc *ms = &taskRpcStatics->svc;

	p = NULL_SVC;
	for (s = ms->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);
}

/* ******************* REPLY GENERATION ROUTINES  ************ */

/*
 * Send a reply to an rpc request
 */
bool_t
svc_sendreply(xprt, xdr_results, xdr_location)
	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));
}

/*
 * No procedure error reply
 */
void
svcerr_noproc(xprt)
	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);
}

/*
 * Can't decode args error reply
 */
void
svcerr_decode(xprt)
	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);
}

/*
 * Some system error
 */
void
svcerr_systemerr(xprt)
	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);
}

/*
 * Authentication error reply
 */
void
svcerr_auth(xprt, why)
	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);
}

/*
 * Auth too weak error reply
 */
void
svcerr_weakauth(xprt)
	SVCXPRT *xprt;
{

	svcerr_auth(xprt, AUTH_TOOWEAK);
}

/*
 * Program unavailable error reply
 */
void
svcerr_noprog(xprt)
	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);
}

/*
 * Program version mismatch error reply
 */
void
svcerr_progvers(xprt, low_vers, high_vers)
	register SVCXPRT *xprt;
	u_long low_vers;
	u_long 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);
}

/* ******************* 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 two assumptions: a) the structure is contiguous (no pointers), and
 * b) the 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;					/* 4.0 */

    FD_ZERO (&readFds);					/* 4.0 */
    readFds.fds_bits[0] = rdfds;			/* 4.0 */
    svc_getreqset (&readFds);				/* 4.0 */
    }

void
svc_getreqset (rdfds)
	fd_set *rdfds;
{
	register enum xprt_stat stat;
	struct rpc_msg msg;
	int prog_found;
	u_long low_vers;
	u_long high_vers;
	struct svc_req r;
	register int sock;
	register SVCXPRT *xprt;
	/* XXX char cred_area[2*MAX_AUTH_BYTES + RQCRED_SIZE]; */
	char *cred_area = (char *) KHEAP_ALLOC(2*MAX_AUTH_BYTES + RQCRED_SIZE);
	FAST struct svc *ms = &taskRpcStatics->svc;
	fd_set readFds;

	if (cred_area == 0)					/* 4.0 */
	    {							/* 4.0 */
	    panic ("rpc: svc_getreq: out of memory.\n");	/* 4.0 */
	    return;						/* 4.0 */
	    }							/* 4.0 */

	msg.rm_call.cb_cred.oa_base = cred_area;		/* 4.0 */
	msg.rm_call.cb_verf.oa_base = &(cred_area[MAX_AUTH_BYTES]); /* 4.0 */
	r.rq_clntcred = &(cred_area[2*MAX_AUTH_BYTES]);		/* 4.0 */

	/*
	 * The following is the code that gets a list of socket ports
	 * that are ready for input.  In comments is the RPC 4.0 optimized
	 * version that makes use of getdtablesize() and ffs() which VxWorks
	 * doesn't have yet.  So we use the 3.9 unoptimized version instead.
	 * The code here replaces the code between MARK-A and MARK-B.
	 *
	 * setsize = _rpc_dtablesize();  // or just call getdtablesize ()
	 * maskp = (u_long *) readFds->fds_bits;
	 * for (sock = 0; sock < setsize; sock += NFDBITS)
	 *    {
	 *    for (mask = *maskp++; bit = ffs (mask); mask ^= (1 << (bit - 1)))
	 *        {
	 *        // sock has input waiting
	 *        xprt = xports [sock + bit - 1];
	 */

/* MARK-A     see the comment above */

	FD_ZERO(&readFds);
	for (sock = 0; sock < FD_SETSIZE; sock++)
	    if (FD_ISSET(sock, &ms->svc_fdset) && FD_ISSET(sock, rdfds))
		FD_SET(sock, &readFds);

	for (sock = 0; sock < FD_SETSIZE; sock++) {
	    if (FD_ISSET(sock, &readFds)) {
		/* sock has input waiting */
		xprt = ms->xports[sock];

/* MARK-B     see the comment above */

		/* now receive msgs from xprtprt (support batch calls) */
		do {
			if (SVC_RECV(xprt, &msg)) {

				/* now find the exported program and call it */
				register 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 = 0 - 1;
				high_vers = 0;
				for (s = ms->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);
	    }
	}
    KHEAP_FREE(cred_area);
}

/*
 * This is the rpc server side idle loop
 * Wait for input, call server program.
 */
void
svc_run()
{
	fd_set readFds;
	FAST struct svc *ms = &taskRpcStatics->svc;

	while (TRUE) {
		readFds = ms->svc_fdset;

		switch (select (FD_SETSIZE, &readFds, (fd_set *)NULL,
				(fd_set *)NULL, (struct timeval *)0))
		{

		case -1:
			if (rpcErrnoGet () == EINTR)
				continue;
			else {
				perror("svc.c: - Select failed");
				return;
			}
		case 0:
			continue;
		default:
			svc_getreqset (&readFds);
		}
	}
}