lib/libc/rpc/svc_raw.c

   1 /*-
   2  * Copyright (c) 2009, Sun Microsystems, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  * - Redistributions of source code must retain the above copyright notice,
   8  *   this list of conditions and the following disclaimer.
   9  * - Redistributions in binary form must reproduce the above copyright notice,
  10  *   this list of conditions and the following disclaimer in the documentation
  11  *   and/or other materials provided with the distribution.
  12  * - Neither the name of Sun Microsystems, Inc. nor the names of its
  13  *   contributors may be used to endorse or promote products derived
  14  *   from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * @(#)svc_raw.c 1.25 89/01/31 Copyr 1984 Sun Micro
  29  * @(#)svc_raw.c        1.16    94/04/24 SMI
  30  * $NetBSD: svc_raw.c,v 1.14 2000/07/06 03:10:35 christos Exp $
  31  * $FreeBSD: src/lib/libc/rpc/svc_raw.c,v 1.15 2006/02/27 22:10:59 deischen Exp $
  32  */
  33 /*
  34  * Copyright (c) 1986-1991 by Sun Microsystems Inc.
  35  */
  36
  37 /*
  38  * svc_raw.c,   This a toy for simple testing and timing.
  39  * Interface to create an rpc client and server in the same UNIX process.
  40  * This lets us similate rpc and get rpc (round trip) overhead, without
  41  * any interference from the kernel.
  42  *
  43  */
  44
  45 #include "namespace.h"
  46 #include "reentrant.h"
  47 #include <rpc/rpc.h>
  48 #include <sys/types.h>
  49 #include <rpc/raw.h>
  50 #include <stdlib.h>
  51 #include "un-namespace.h"
  52 #include "mt_misc.h"
  53
  54 #ifndef UDPMSGSIZE
  55 #define UDPMSGSIZE 8800
  56 #endif
  57
  58 /*
  59  * This is the "network" that we will be moving data over
  60  */
  61 static struct svc_raw_private {
  62         char    *raw_buf;       /* should be shared with the cl handle */
  63         SVCXPRT server;
  64         XDR     xdr_stream;
  65         char    verf_body[MAX_AUTH_BYTES];
  66 } *svc_raw_private;
  67
  68 static enum xprt_stat svc_raw_stat(SVCXPRT *);
  69 static bool_t svc_raw_recv(SVCXPRT *, struct rpc_msg *);
  70 static bool_t svc_raw_reply(SVCXPRT *, struct rpc_msg *);
  71 static bool_t svc_raw_getargs(SVCXPRT *, xdrproc_t, void *);
  72 static bool_t svc_raw_freeargs(SVCXPRT *, xdrproc_t, void *);
  73 static void svc_raw_destroy(SVCXPRT *);
  74 static void svc_raw_ops(SVCXPRT *);
  75 static bool_t svc_raw_control(SVCXPRT *, const u_int, void *);
  76
  77 char *__rpc_rawcombuf = NULL;
  78
  79 SVCXPRT *
  80 svc_raw_create(void)
  81 {
  82         struct svc_raw_private *srp;
  83 /* VARIABLES PROTECTED BY svcraw_lock: svc_raw_private, srp */
  84
  85         mutex_lock(&svcraw_lock);
  86         srp = svc_raw_private;
  87         if (srp == NULL) {
  88                 srp = (struct svc_raw_private *)calloc(1, sizeof (*srp));
  89                 if (srp == NULL) {
  90                         mutex_unlock(&svcraw_lock);
  91                         return (NULL);
  92                 }
  93                 if (__rpc_rawcombuf == NULL)
  94                         __rpc_rawcombuf = calloc(UDPMSGSIZE, sizeof (char));
  95                 srp->raw_buf = __rpc_rawcombuf; /* Share it with the client */
  96                 svc_raw_private = srp;
  97         }
  98         srp->server.xp_fd = FD_SETSIZE;
  99         srp->server.xp_port = 0;
 100         srp->server.xp_p3 = NULL;
 101         svc_raw_ops(&srp->server);
 102         srp->server.xp_verf.oa_base = srp->verf_body;
 103         xdrmem_create(&srp->xdr_stream, srp->raw_buf, UDPMSGSIZE, XDR_DECODE);
 104         xprt_register(&srp->server);
 105         mutex_unlock(&svcraw_lock);
 106         return (&srp->server);
 107 }
 108
 109 /*ARGSUSED*/
 110 static enum xprt_stat
 111 svc_raw_stat(SVCXPRT *xprt __unused)
 112 {
 113         return (XPRT_IDLE);
 114 }
 115
 116 /*ARGSUSED*/
 117 static bool_t
 118 svc_raw_recv(SVCXPRT *xprt __unused, struct rpc_msg *msg)
 119 {
 120         struct svc_raw_private *srp;
 121         XDR *xdrs;
 122
 123         mutex_lock(&svcraw_lock);
 124         srp = svc_raw_private;
 125         if (srp == NULL) {
 126                 mutex_unlock(&svcraw_lock);
 127                 return (FALSE);
 128         }
 129         mutex_unlock(&svcraw_lock);
 130
 131         xdrs = &srp->xdr_stream;
 132         xdrs->x_op = XDR_DECODE;
 133         XDR_SETPOS(xdrs, 0);
 134         if (! xdr_callmsg(xdrs, msg)) {
 135                 return (FALSE);
 136         }
 137         return (TRUE);
 138 }
 139
 140 /*ARGSUSED*/
 141 static bool_t
 142 svc_raw_reply(SVCXPRT *xprt __unused, struct rpc_msg *msg)
 143 {
 144         struct svc_raw_private *srp;
 145         XDR *xdrs;
 146
 147         mutex_lock(&svcraw_lock);
 148         srp = svc_raw_private;
 149         if (srp == NULL) {
 150                 mutex_unlock(&svcraw_lock);
 151                 return (FALSE);
 152         }
 153         mutex_unlock(&svcraw_lock);
 154
 155         xdrs = &srp->xdr_stream;
 156         xdrs->x_op = XDR_ENCODE;
 157         XDR_SETPOS(xdrs, 0);
 158         if (! xdr_replymsg(xdrs, msg)) {
 159                 return (FALSE);
 160         }
 161         XDR_GETPOS(xdrs);  /* called just for overhead */
 162         return (TRUE);
 163 }
 164
 165 /*ARGSUSED*/
 166 static bool_t
 167 svc_raw_getargs(SVCXPRT *xprt __unused, xdrproc_t xdr_args, void *args_ptr)
 168 {
 169         struct svc_raw_private *srp;
 170
 171         mutex_lock(&svcraw_lock);
 172         srp = svc_raw_private;
 173         if (srp == NULL) {
 174                 mutex_unlock(&svcraw_lock);
 175                 return (FALSE);
 176         }
 177         mutex_unlock(&svcraw_lock);
 178         return (*xdr_args)(&srp->xdr_stream, args_ptr);
 179 }
 180
 181 /*ARGSUSED*/
 182 static bool_t
 183 svc_raw_freeargs(SVCXPRT *xprt __unused, xdrproc_t xdr_args, void *args_ptr)
 184 {
 185         struct svc_raw_private *srp;
 186         XDR *xdrs;
 187
 188         mutex_lock(&svcraw_lock);
 189         srp = svc_raw_private;
 190         if (srp == NULL) {
 191                 mutex_unlock(&svcraw_lock);
 192                 return (FALSE);
 193         }
 194         mutex_unlock(&svcraw_lock);
 195
 196         xdrs = &srp->xdr_stream;
 197         xdrs->x_op = XDR_FREE;
 198         return (*xdr_args)(xdrs, args_ptr);
 199 }
 200
 201 /*ARGSUSED*/
 202 static void
 203 svc_raw_destroy(SVCXPRT *xprt __unused)
 204 {
 205 }
 206
 207 /*ARGSUSED*/
 208 static bool_t
 209 svc_raw_control(SVCXPRT *xprt __unused, const u_int rq __unused,
 210     void *in __unused)
 211 {
 212         return (FALSE);
 213 }
 214
 215 static void
 216 svc_raw_ops(SVCXPRT *xprt)
 217 {
 218         static struct xp_ops ops;
 219         static struct xp_ops2 ops2;
 220
 221 /* VARIABLES PROTECTED BY ops_lock: ops */
 222
 223         mutex_lock(&ops_lock);
 224         if (ops.xp_recv == NULL) {
 225                 ops.xp_recv = svc_raw_recv;
 226                 ops.xp_stat = svc_raw_stat;
 227                 ops.xp_getargs = svc_raw_getargs;
 228                 ops.xp_reply = svc_raw_reply;
 229                 ops.xp_freeargs = svc_raw_freeargs;
 230                 ops.xp_destroy = svc_raw_destroy;
 231                 ops2.xp_control = svc_raw_control;
 232         }
 233         xprt->xp_ops = &ops;
 234         xprt->xp_ops2 = &ops2;
 235         mutex_unlock(&ops_lock);
 236 }