svc_simple.c File Reference

#include <wintirpc.h>
#include <reentrant.h>
#include <sys/types.h>
#include <rpc/rpc.h>
#include <rpc/nettype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "rpc_com.h"

Include dependency graph for svc_simple.c:

Go to the source code of this file.

Classes
struct	proglst

Functions
static void	universal (struct svc_req *, SVCXPRT *)
int	rpc_reg (rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum, char **progname, xdrproc_t inproc, xdrproc_t outproc, char *nettype)

Variables
static struct proglst *	proglst
static const char	rpc_reg_err [] = "%s: %s"
static const char	rpc_reg_msg [] = "rpc_reg: "
static const char	__reg_err1 [] = "can't find appropriate transport"
static const char	__reg_err2 [] = "can't get protocol info"
static const char	__reg_err3 [] = "unsupported transport size"
static const char	__no_mem_str [] = "out of memory"

Function Documentation

rpc_reg()

int rpc_reg	(	rpcprog_t	prognum,
		rpcvers_t	versnum,
		rpcproc_t	procnum,
		char **	progname,
		xdrproc_t	inproc,
		xdrproc_t	outproc,
		char *	nettype
	)

Definition at line 92 of file svc_simple.c.

{
    struct netconfig *nconf;
    int done = FALSE;
    void *handle;
    extern mutex_t proglst_lock;
 
    if (procnum == NULLPROC) {
        // XXXwarnx("%s can't reassign procedure number %u", rpc_reg_msg,
//          NULLPROC);
        return (-1);
    }
 
    if (nettype == NULL)
        nettype = "netpath";        /* The default behavior */
    if ((handle = __rpc_setconf(nettype)) == NULL) {
        // XXX warnx(rpc_reg_err, rpc_reg_msg, __reg_err1);
        return (-1);
    }
/* VARIABLES PROTECTED BY proglst_lock: proglst */
    mutex_lock(&proglst_lock);
    while ((nconf = __rpc_getconf(handle)) != NULL) {
        struct proglst *pl;
        SVCXPRT *svcxprt;
        int madenow;
        u_int recvsz;
        char *xdrbuf;
        char *netid;
 
        madenow = FALSE;
        svcxprt = NULL;
        recvsz = 0;
        xdrbuf = netid = NULL;
        for (pl = proglst; pl; pl = pl->p_nxt) {
            if (strcmp(pl->p_netid, nconf->nc_netid) == 0) {
                svcxprt = pl->p_transp;
                xdrbuf = pl->p_xdrbuf;
                recvsz = pl->p_recvsz;
                netid = pl->p_netid;
                break;
            }
        }
 
        if (svcxprt == NULL) {
            struct __rpc_sockinfo si;
 
            svcxprt = svc_tli_create(RPC_ANYFD, nconf, NULL, 0, 0);
            if (svcxprt == NULL)
                continue;
            if (!__rpc_fd2sockinfo(svcxprt->xp_fd, &si)) {
                // XXX warnx(rpc_reg_err, rpc_reg_msg, __reg_err2);
                SVC_DESTROY(svcxprt);
                continue;
            }
            recvsz = __rpc_get_t_size(si.si_af, si.si_proto, 0);
            if (recvsz == 0) {
                // XXX warnx(rpc_reg_err, rpc_reg_msg, __reg_err3);
                SVC_DESTROY(svcxprt);
                continue;
            }
            if (((xdrbuf = malloc((unsigned)recvsz)) == NULL) ||
                ((netid = strdup(nconf->nc_netid)) == NULL)) {
                // XXX warnx(rpc_reg_err, rpc_reg_msg, __no_mem_str);
                SVC_DESTROY(svcxprt);
                break;
            }
            madenow = TRUE;
        }
        /*
         * Check if this (program, version, netid) had already been
         * registered.  The check may save a few RPC calls to rpcbind
         */
        for (pl = proglst; pl; pl = pl->p_nxt)
            if ((pl->p_prognum == prognum) &&
                (pl->p_versnum == versnum) &&
                (strcmp(pl->p_netid, netid) == 0))
                break;
        if (pl == NULL) { /* Not yet */
            (void) rpcb_unset(prognum, versnum, nconf);
        } else {
            /* so that svc_reg does not call rpcb_set() */
            nconf = NULL;
        }
 
        if (!svc_reg(svcxprt, prognum, versnum, universal, nconf)) {
            // XXX warnx("%s couldn't register prog %u vers %u for %s",
//              rpc_reg_msg, (unsigned)prognum,
//              (unsigned)versnum, netid);
            if (madenow) {
                SVC_DESTROY(svcxprt);
                free(xdrbuf);
                free(netid);
            }
            continue;
        }
 
        pl = malloc(sizeof (struct proglst));
        if (pl == NULL) {
            // XXX warnx(rpc_reg_err, rpc_reg_msg, __no_mem_str);
            if (madenow) {
                SVC_DESTROY(svcxprt);
                free(xdrbuf);
                free(netid);
            }
            break;
        }
        pl->p_progname = progname;
        pl->p_prognum = prognum;
        pl->p_versnum = versnum;
        pl->p_procnum = procnum;
        pl->p_inproc = inproc;
        pl->p_outproc = outproc;
        pl->p_transp = svcxprt;
        pl->p_xdrbuf = xdrbuf;
        pl->p_recvsz = recvsz;
        pl->p_netid = netid;
        pl->p_nxt = proglst;
        proglst = pl;
        done = TRUE;
    }
    __rpc_endconf(handle);
    mutex_unlock(&proglst_lock);
 
    if (done == FALSE) {
        // XXX warnx("%s cant find suitable transport for %s",
//          rpc_reg_msg, nettype);
        return (-1);
    }
    return (0);
}

universal()

static void universal ( struct svc_req *  rqstp, SVCXPRT *  transp  )

static

Definition at line 235 of file svc_simple.c.

{
    rpcprog_t prog;
    rpcvers_t vers;
    rpcproc_t proc;
    char *outdata;
    char *xdrbuf;
    struct proglst *pl;
    extern mutex_t proglst_lock;
 
    /*
     * enforce "procnum 0 is echo" convention
     */
    if (rqstp->rq_proc == NULLPROC) {
        if (svc_sendreply(transp, (xdrproc_t) xdr_void, NULL) ==
            FALSE) {
            // XXX warnx("svc_sendreply failed");
        }
        return;
    }
    prog = rqstp->rq_prog;
    vers = rqstp->rq_vers;
    proc = rqstp->rq_proc;
    mutex_lock(&proglst_lock);
    for (pl = proglst; pl; pl = pl->p_nxt)
        if (pl->p_prognum == prog && pl->p_procnum == proc &&
            pl->p_versnum == vers &&
            (strcmp(pl->p_netid, transp->xp_netid) == 0)) {
            /* decode arguments into a CLEAN buffer */
            xdrbuf = pl->p_xdrbuf;
            /* Zero the arguments: reqd ! */
            (void) memset(xdrbuf, 0, sizeof (pl->p_recvsz));
            /*
             * Assuming that sizeof (xdrbuf) would be enough
             * for the arguments; if not then the program
             * may bomb. BEWARE!
             */
            if (!svc_getargs(transp, pl->p_inproc, xdrbuf)) {
                svcerr_decode(transp);
                mutex_unlock(&proglst_lock);
                return;
            }
            outdata = (*(pl->p_progname))(xdrbuf);
            if (outdata == NULL &&
                pl->p_outproc != (xdrproc_t) xdr_void){
                /* there was an error */
                mutex_unlock(&proglst_lock);
                return;
            }
            if (!svc_sendreply(transp, pl->p_outproc, outdata)) {
                // XXX warnx(
//          "rpc: rpc_reg trouble replying to prog %u vers %u",
//              (unsigned)prog, (unsigned)vers);
                mutex_unlock(&proglst_lock);
                return;
            }
            /* free the decoded arguments */
            (void)svc_freeargs(transp, pl->p_inproc, xdrbuf);
            mutex_unlock(&proglst_lock);
            return;
        }
    mutex_unlock(&proglst_lock);
    /* This should never happen */
    // XXX warnx("rpc: rpc_reg: never registered prog %u vers %u",
//      (unsigned)prog, (unsigned)vers);
    return;
}

Referenced by rpc_reg().

Variable Documentation

__no_mem_str

const char __no_mem_str[] = "out of memory"

static

Definition at line 78 of file svc_simple.c.

__reg_err1

const char __reg_err1[] = "can't find appropriate transport"

static

Definition at line 75 of file svc_simple.c.

__reg_err2

const char __reg_err2[] = "can't get protocol info"

static

Definition at line 76 of file svc_simple.c.

__reg_err3

const char __reg_err3[] = "unsupported transport size"

static

Definition at line 77 of file svc_simple.c.

proglst

struct proglst * proglst

static

rpc_reg_err

const char rpc_reg_err[] = "%s: %s"

static

Definition at line 73 of file svc_simple.c.

rpc_reg_msg

const char rpc_reg_msg[] = "rpc_reg: "

static

Definition at line 74 of file svc_simple.c.