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