sunrpc/svc_raw.c

   1 /*
   2  * svc_raw.c,   This a toy for simple testing and timing.
   3  * Interface to create an rpc client and server in the same UNIX process.
   4  * This lets us simulate rpc and get rpc (round trip) overhead, without
   5  * any interference from the kernel.
   6  *
   7  * Copyright (c) 2010, Oracle America, Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are
  11  * met:
  12  *
  13  *     * Redistributions of source code must retain the above copyright
  14  *       notice, this list of conditions and the following disclaimer.
  15  *     * Redistributions in binary form must reproduce the above
  16  *       copyright notice, this list of conditions and the following
  17  *       disclaimer in the documentation and/or other materials
  18  *       provided with the distribution.
  19  *     * Neither the name of the "Oracle America, Inc." nor the names of its
  20  *       contributors may be used to endorse or promote products derived
  21  *       from this software without specific prior written permission.
  22  *
  23  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  27  *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  28  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  30  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  32  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  33  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 #include <rpc/rpc.h>
  38 #include <rpc/svc.h>
  39
  40 /*
  41  * This is the "network" that we will be moving data over
  42  */
  43 struct svcraw_private_s
  44   {
  45     char _raw_buf[UDPMSGSIZE];
  46     SVCXPRT server;
  47     XDR xdr_stream;
  48     char verf_body[MAX_AUTH_BYTES];
  49   };
  50 #ifdef _RPC_THREAD_SAFE_
  51 #define svcraw_private RPC_THREAD_VARIABLE(svcraw_private_s)
  52 #else
  53 static struct svcraw_private_s *svcraw_private;
  54 #endif
  55
  56 static bool_t svcraw_recv (SVCXPRT *, struct rpc_msg *);
  57 static enum xprt_stat svcraw_stat (SVCXPRT *);
  58 static bool_t svcraw_getargs (SVCXPRT *, xdrproc_t, caddr_t);
  59 static bool_t svcraw_reply (SVCXPRT *, struct rpc_msg *);
  60 static bool_t svcraw_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
  61 static void svcraw_destroy (SVCXPRT *);
  62
  63 static const struct xp_ops server_ops =
  64 {
  65   svcraw_recv,
  66   svcraw_stat,
  67   svcraw_getargs,
  68   svcraw_reply,
  69   svcraw_freeargs,
  70   svcraw_destroy
  71 };
  72
  73 SVCXPRT *
  74 svcraw_create (void)
  75 {
  76   struct svcraw_private_s *srp = svcraw_private;
  77
  78   if (srp == 0)
  79     {
  80       srp = (struct svcraw_private_s *) calloc (1, sizeof (*srp));
  81       if (srp == 0)
  82         return NULL;
  83     }
  84   srp->server.xp_sock = 0;
  85   srp->server.xp_port = 0;
  86   srp->server.xp_ops = (struct xp_ops *) &server_ops;
  87   srp->server.xp_verf.oa_base = srp->verf_body;
  88   INTUSE(xdrmem_create) (&srp->xdr_stream, srp->_raw_buf, UDPMSGSIZE,
  89                          XDR_FREE);
  90   return &srp->server;
  91 }
  92
  93 static enum xprt_stat
  94 svcraw_stat (SVCXPRT *xprt)
  95 {
  96   return XPRT_IDLE;
  97 }
  98
  99 static bool_t
 100 svcraw_recv (xprt, msg)
 101      SVCXPRT *xprt;
 102      struct rpc_msg *msg;
 103 {
 104   struct svcraw_private_s *srp = svcraw_private;
 105   XDR *xdrs;
 106
 107   if (srp == 0)
 108     return FALSE;
 109   xdrs = &srp->xdr_stream;
 110   xdrs->x_op = XDR_DECODE;
 111   XDR_SETPOS (xdrs, 0);
 112   if (!INTUSE(xdr_callmsg) (xdrs, msg))
 113     return FALSE;
 114   return TRUE;
 115 }
 116
 117 static bool_t
 118 svcraw_reply (SVCXPRT *xprt, struct rpc_msg *msg)
 119 {
 120   struct svcraw_private_s *srp = svcraw_private;
 121   XDR *xdrs;
 122
 123   if (srp == 0)
 124     return FALSE;
 125   xdrs = &srp->xdr_stream;
 126   xdrs->x_op = XDR_ENCODE;
 127   XDR_SETPOS (xdrs, 0);
 128   if (!INTUSE(xdr_replymsg) (xdrs, msg))
 129     return FALSE;
 130   (void) XDR_GETPOS (xdrs);     /* called just for overhead */
 131   return TRUE;
 132 }
 133
 134 static bool_t
 135 svcraw_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 136 {
 137   struct svcraw_private_s *srp = svcraw_private;
 138
 139   if (srp == 0)
 140     return FALSE;
 141   return (*xdr_args) (&srp->xdr_stream, args_ptr);
 142 }
 143
 144 static bool_t
 145 svcraw_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 146 {
 147   struct svcraw_private_s *srp = svcraw_private;
 148   XDR *xdrs;
 149
 150   if (srp == 0)
 151     return FALSE;
 152   xdrs = &srp->xdr_stream;
 153   xdrs->x_op = XDR_FREE;
 154   return (*xdr_args) (xdrs, args_ptr);
 155 }
 156
 157 static void
 158 svcraw_destroy (SVCXPRT *xprt)
 159 {
 160 }