sunrpc/clnt_raw.c

   1 /* @(#)clnt_raw.c       2.2 88/08/01 4.0 RPCSRC */
   2 /*
   3  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   4  * unrestricted use provided that this legend is included on all tape
   5  * media and as a part of the software program in whole or part.  Users
   6  * may copy or modify Sun RPC without charge, but are not authorized
   7  * to license or distribute it to anyone else except as part of a product or
   8  * program developed by the user.
   9  *
  10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  13  *
  14  * Sun RPC is provided with no support and without any obligation on the
  15  * part of Sun Microsystems, Inc. to assist in its use, correction,
  16  * modification or enhancement.
  17  *
  18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  20  * OR ANY PART THEREOF.
  21  *
  22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  23  * or profits or other special, indirect and consequential damages, even if
  24  * Sun has been advised of the possibility of such damages.
  25  *
  26  * Sun Microsystems, Inc.
  27  * 2550 Garcia Avenue
  28  * Mountain View, California  94043
  29  */
  30 #if !defined(lint) && defined(SCCSIDS)
  31 static char sccsid[] = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro";
  32 #endif
  33
  34 /*
  35  * clnt_raw.c
  36  *
  37  * Copyright (C) 1984, Sun Microsystems, Inc.
  38  *
  39  * Memory based rpc for simple testing and timing.
  40  * Interface to create an rpc client and server in the same process.
  41  * This lets us simulate rpc and get round trip overhead, without
  42  * any interference from the kernel.
  43  */
  44
  45 #include <rpc/rpc.h>
  46
  47 #define MCALL_MSG_SIZE 24
  48
  49 /*
  50  * This is the "network" we will be moving stuff over.
  51  */
  52 static struct clntraw_private {
  53         CLIENT  client_object;
  54         XDR     xdr_stream;
  55         char    _raw_buf[UDPMSGSIZE];
  56         char    mashl_callmsg[MCALL_MSG_SIZE];
  57         u_int   mcnt;
  58 } *clntraw_private;
  59
  60 static enum clnt_stat   clntraw_call();
  61 static void             clntraw_abort();
  62 static void             clntraw_geterr();
  63 static bool_t           clntraw_freeres();
  64 static bool_t           clntraw_control();
  65 static void             clntraw_destroy();
  66
  67 static struct clnt_ops client_ops = {
  68         clntraw_call,
  69         clntraw_abort,
  70         clntraw_geterr,
  71         clntraw_freeres,
  72         clntraw_destroy,
  73         clntraw_control
  74 };
  75
  76 void    svc_getreq();
  77
  78 /*
  79  * Create a client handle for memory based rpc.
  80  */
  81 CLIENT *
  82 clntraw_create(prog, vers)
  83         u_long prog;
  84         u_long vers;
  85 {
  86         register struct clntraw_private *clp = clntraw_private;
  87         struct rpc_msg call_msg;
  88         XDR *xdrs = &clp->xdr_stream;
  89         CLIENT  *client = &clp->client_object;
  90
  91         if (clp == 0) {
  92                 clp = (struct clntraw_private *)calloc(1, sizeof (*clp));
  93                 if (clp == 0)
  94                         return (0);
  95                 clntraw_private = clp;
  96         }
  97         /*
  98          * pre-serialize the static part of the call msg and stash it away
  99          */
 100         call_msg.rm_direction = CALL;
 101         call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
 102         call_msg.rm_call.cb_prog = prog;
 103         call_msg.rm_call.cb_vers = vers;
 104         xdrmem_create(xdrs, clp->mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE);
 105         if (! xdr_callhdr(xdrs, &call_msg)) {
 106                 perror(_("clnt_raw.c - Fatal header serialization error."));
 107         }
 108         clp->mcnt = XDR_GETPOS(xdrs);
 109         XDR_DESTROY(xdrs);
 110
 111         /*
 112          * Set xdrmem for client/server shared buffer
 113          */
 114         xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE);
 115
 116         /*
 117          * create client handle
 118          */
 119         client->cl_ops = &client_ops;
 120         client->cl_auth = authnone_create();
 121         return (client);
 122 }
 123
 124 static enum clnt_stat
 125 clntraw_call(h, proc, xargs, argsp, xresults, resultsp, timeout)
 126         CLIENT *h;
 127         u_long proc;
 128         xdrproc_t xargs;
 129         caddr_t argsp;
 130         xdrproc_t xresults;
 131         caddr_t resultsp;
 132         struct timeval timeout;
 133 {
 134         register struct clntraw_private *clp = clntraw_private;
 135         register XDR *xdrs = &clp->xdr_stream;
 136         struct rpc_msg msg;
 137         enum clnt_stat status;
 138         struct rpc_err error;
 139
 140         if (clp == 0)
 141                 return (RPC_FAILED);
 142 call_again:
 143         /*
 144          * send request
 145          */
 146         xdrs->x_op = XDR_ENCODE;
 147         XDR_SETPOS(xdrs, 0);
 148         ((struct rpc_msg *)clp->mashl_callmsg)->rm_xid ++ ;
 149         if ((! XDR_PUTBYTES(xdrs, clp->mashl_callmsg, clp->mcnt)) ||
 150             (! XDR_PUTLONG(xdrs, (long *)&proc)) ||
 151             (! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
 152             (! (*xargs)(xdrs, argsp))) {
 153                 return (RPC_CANTENCODEARGS);
 154         }
 155         (void)XDR_GETPOS(xdrs);  /* called just to cause overhead */
 156
 157         /*
 158          * We have to call server input routine here because this is
 159          * all going on in one process. Yuk.
 160          */
 161         svc_getreq(1);
 162
 163         /*
 164          * get results
 165          */
 166         xdrs->x_op = XDR_DECODE;
 167         XDR_SETPOS(xdrs, 0);
 168         msg.acpted_rply.ar_verf = _null_auth;
 169         msg.acpted_rply.ar_results.where = resultsp;
 170         msg.acpted_rply.ar_results.proc = xresults;
 171         if (! xdr_replymsg(xdrs, &msg))
 172                 return (RPC_CANTDECODERES);
 173         _seterr_reply(&msg, &error);
 174         status = error.re_status;
 175
 176         if (status == RPC_SUCCESS) {
 177                 if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
 178                         status = RPC_AUTHERROR;
 179                 }
 180         }  /* end successful completion */
 181         else {
 182                 if (AUTH_REFRESH(h->cl_auth))
 183                         goto call_again;
 184         }  /* end of unsuccessful completion */
 185
 186         if (status == RPC_SUCCESS) {
 187                 if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) {
 188                         status = RPC_AUTHERROR;
 189                 }
 190                 if (msg.acpted_rply.ar_verf.oa_base != NULL) {
 191                         xdrs->x_op = XDR_FREE;
 192                         (void)xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf));
 193                 }
 194         }
 195
 196         return (status);
 197 }
 198
 199 static void
 200 clntraw_geterr()
 201 {
 202 }
 203
 204
 205 static bool_t
 206 clntraw_freeres(cl, xdr_res, res_ptr)
 207         CLIENT *cl;
 208         xdrproc_t xdr_res;
 209         caddr_t res_ptr;
 210 {
 211         register struct clntraw_private *clp = clntraw_private;
 212         register XDR *xdrs = &clp->xdr_stream;
 213         bool_t rval;
 214
 215         if (clp == 0)
 216         {
 217                 rval = (bool_t) RPC_FAILED;
 218                 return (rval);
 219         }
 220         xdrs->x_op = XDR_FREE;
 221         return ((*xdr_res)(xdrs, res_ptr));
 222 }
 223
 224 static void
 225 clntraw_abort()
 226 {
 227 }
 228
 229 static bool_t
 230 clntraw_control()
 231 {
 232         return (FALSE);
 233 }
 234
 235 static void
 236 clntraw_destroy()
 237 {
 238 }