Gold Fish 3/goldfish_volume_3.bin/files/comm/tcp/amitcp-sdk/src/rpclib/clnt_raw.c

C/C++ Source or Header | 1994-09-29 | 5.0 KB | 222 lines

/*
 * $Id: clnt_raw.c,v 4.2 1994/09/29 23:48:50 jraja Exp $
 *
 * Copyright © 1994 AmiTCP/IP Group,
 *                  Network Solutions Development Inc.
 *                  All rights reserved.
 */

/* @(#)clnt_raw.c    2.2 88/08/01 4.0 RPCSRC */
#if !defined(lint) && defined(SCCSIDS)
static char sccsid[] = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro";
#endif

/*
 * Copyright (C) 1984, Sun Microsystems, Inc.
 *
 * Memory based rpc for simple testing and timing.
 * Interface to create an rpc client and server in the same process.
 * This lets us similate rpc and get round trip overhead, without
 * any interference from the kernal.
 */

#include <sys/param.h>
#include <rpc/rpc.h>

#define MCALL_MSG_SIZE 24

/*
 * This is the "network" we will be moving stuff over.
 */
static struct clntraw_private {
    CLIENT    client_object;
    XDR    xdr_stream;
    char    _raw_buf[UDPMSGSIZE];
    char    mashl_callmsg[MCALL_MSG_SIZE];
    u_int    mcnt;
} *clntraw_private;

static enum clnt_stat    clntraw_call(CLIENT * h, u_long proc,
                     xdrproc_t xdr_args, caddr_t args_ptr,
                     xdrproc_t xdr_results,
                     caddr_t results_ptr,
                     struct timeval timeout);
static void        clntraw_abort(CLIENT * h);
static void        clntraw_geterr(CLIENT * h, struct rpc_err * errp);
static bool_t        clntraw_freeres(CLIENT * cl,
                    xdrproc_t xdr_res, caddr_t res_ptr);
static bool_t        clntraw_control(CLIENT * cl,
                    u_int request, caddr_t info);
static void        clntraw_destroy(CLIENT * h);

static struct clnt_ops client_ops = {
    clntraw_call,
    clntraw_abort,
    clntraw_geterr,
    clntraw_freeres,
    clntraw_destroy,
    clntraw_control
};

/*
 * Create a client handle for memory based rpc.
 */
CLIENT *
clntraw_create(prog, vers)
    u_long prog;
    u_long vers;
{
    register struct clntraw_private *clp = clntraw_private;
    struct rpc_msg call_msg;
    XDR *xdrs = &clp->xdr_stream;
    CLIENT    *client = &clp->client_object;

    if (clp == 0) {
        clp = (struct clntraw_private *)mem_calloc(1, sizeof (*clp));
        if (clp == 0)
            return (0);
        clntraw_private = clp;
    }
    /*
     * pre-serialize the staic part of the call msg and stash it away
     */
    call_msg.rm_direction = CALL;
    call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
    call_msg.rm_call.cb_prog = prog;
    call_msg.rm_call.cb_vers = vers;
    xdrmem_create(xdrs, clp->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
    if (! xdr_callhdr(xdrs, &call_msg)) {
        perror("clnt_raw.c - Fatal header serialization error.");
    }
    clp->mcnt = XDR_GETPOS(xdrs);
    XDR_DESTROY(xdrs);

    /*
     * Set xdrmem for client/server shared buffer
     */
    xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);

    /*
     * create client handle
     */
    client->cl_ops = &client_ops;
    client->cl_auth = authnone_create();
    return (client);
}

static enum clnt_stat
clntraw_call(h, proc, xargs, argsp, xresults, resultsp, timeout)
    CLIENT *h;
    u_long proc;
    xdrproc_t xargs;
    caddr_t argsp;
    xdrproc_t xresults;
    caddr_t resultsp;
    struct timeval timeout;
{
    register struct clntraw_private *clp = clntraw_private;
    register XDR *xdrs = &clp->xdr_stream;
    struct rpc_msg msg;
    enum clnt_stat status;
    struct rpc_err error;

    if (clp == 0)
        return (RPC_FAILED);
call_again:
    /*
     * send request
     */
    xdrs->x_op = XDR_ENCODE;
    XDR_SETPOS(xdrs, 0);
    ((struct rpc_msg *)clp->mashl_callmsg)->rm_xid ++ ;
    if ((! XDR_PUTBYTES(xdrs, clp->mashl_callmsg, clp->mcnt)) ||
        (! XDR_PUTLONG(xdrs, (long *)&proc)) ||
        (! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
        (! (*xargs)(xdrs, argsp))) {
        return (RPC_CANTENCODEARGS);
    }
    (void)XDR_GETPOS(xdrs);  /* called just to cause overhead */

    /*
     * We have to call server input routine here because this is
     * all going on in one process. Yuk.
     */
    svc_getreq(1);

    /*
     * get results
     */
    xdrs->x_op = XDR_DECODE;
    XDR_SETPOS(xdrs, 0);
    msg.acpted_rply.ar_verf = _null_auth;
    msg.acpted_rply.ar_results.where = resultsp;
    msg.acpted_rply.ar_results.proc = xresults;
    if (! xdr_replymsg(xdrs, &msg))
        return (RPC_CANTDECODERES);
    _seterr_reply(&msg, &error);
    status = error.re_status;

    if (status == RPC_SUCCESS) {
        if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
            status = RPC_AUTHERROR;
        }
    }  /* end successful completion */
    else {
        if (AUTH_REFRESH(h->cl_auth))
            goto call_again;
    }  /* end of unsuccessful completion */

    if (status == RPC_SUCCESS) {
        if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
            status = RPC_AUTHERROR;
        }
        if (msg.acpted_rply.ar_verf.oa_base != NULL) {
            xdrs->x_op = XDR_FREE;
            (void)xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf));
        }
    }

    return (status);
}

static void
clntraw_geterr(CLIENT * h, struct rpc_err * errp)
{
}


static bool_t
clntraw_freeres(cl, xdr_res, res_ptr)
    CLIENT *cl;
    xdrproc_t xdr_res;
    caddr_t res_ptr;
{
    register struct clntraw_private *clp = clntraw_private;
    register XDR *xdrs = &clp->xdr_stream;
    bool_t rval;

    if (clp == 0)
    {
        rval = (bool_t) RPC_FAILED;
        return (rval);
    }
    xdrs->x_op = XDR_FREE;
    return ((*xdr_res)(xdrs, res_ptr));
}

static void
clntraw_abort(CLIENT * h)
{
}

static bool_t
clntraw_control(CLIENT * cl, u_int request, caddr_t info)
{
    return (FALSE);
}

static void
clntraw_destroy(CLIENT * h)
{
}