clnt_raw.c revision 1.30.2.1
1 /* $NetBSD: clnt_raw.c,v 1.30.2.1 2013/06/23 06:21:05 tls Exp $ */ 2 3 /* 4 * Copyright (c) 2010, Oracle America, Inc. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above 13 * copyright notice, this list of conditions and the following 14 * disclaimer in the documentation and/or other materials 15 * provided with the distribution. 16 * * Neither the name of the "Oracle America, Inc." nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 27 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 #if defined(LIBC_SCCS) && !defined(lint) 36 #if 0 37 static char *sccsid = "@(#)clnt_raw.c 1.22 87/08/11 Copyr 1984 Sun Micro"; 38 static char *sccsid = "@(#)clnt_raw.c 2.2 88/08/01 4.0 RPCSRC"; 39 #else 40 __RCSID("$NetBSD: clnt_raw.c,v 1.30.2.1 2013/06/23 06:21:05 tls Exp $"); 41 #endif 42 #endif 43 44 /* 45 * clnt_raw.c 46 * 47 * Copyright (C) 1984, Sun Microsystems, Inc. 48 * 49 * Memory based rpc for simple testing and timing. 50 * Interface to create an rpc client and server in the same process. 51 * This lets us similate rpc and get round trip overhead, without 52 * any interference from the kernel. 53 */ 54 55 #include "namespace.h" 56 #include "reentrant.h" 57 #include <assert.h> 58 #include <err.h> 59 #include <stdio.h> 60 #include <stdlib.h> 61 62 #include <rpc/rpc.h> 63 #include <rpc/raw.h> 64 65 #ifdef __weak_alias 66 __weak_alias(clntraw_create,_clntraw_create) 67 __weak_alias(clnt_raw_create,_clnt_raw_create) 68 #endif 69 70 #ifdef _REENTRANT 71 extern mutex_t clntraw_lock; 72 #endif 73 74 #define MCALL_MSG_SIZE 24 75 76 /* 77 * This is the "network" we will be moving stuff over. 78 */ 79 static struct clntraw_private { 80 CLIENT client_object; 81 XDR xdr_stream; 82 char *_raw_buf; 83 union { 84 struct rpc_msg mashl_rpcmsg; 85 char mashl_callmsg[MCALL_MSG_SIZE]; 86 } u; 87 u_int mcnt; 88 } *clntraw_private; 89 90 static enum clnt_stat clnt_raw_call(CLIENT *, rpcproc_t, xdrproc_t, 91 const char *, xdrproc_t, caddr_t, struct timeval); 92 static void clnt_raw_geterr(CLIENT *, struct rpc_err *); 93 static bool_t clnt_raw_freeres(CLIENT *, xdrproc_t, caddr_t); 94 static void clnt_raw_abort(CLIENT *); 95 static bool_t clnt_raw_control(CLIENT *, u_int, char *); 96 static void clnt_raw_destroy(CLIENT *); 97 static struct clnt_ops *clnt_raw_ops(void); 98 99 /* 100 * Create a client handle for memory based rpc. 101 */ 102 CLIENT * 103 clnt_raw_create(rpcprog_t prog, rpcvers_t vers) 104 { 105 struct clntraw_private *clp = clntraw_private; 106 struct rpc_msg call_msg; 107 XDR *xdrs = &clp->xdr_stream; 108 CLIENT *client = &clp->client_object; 109 110 mutex_lock(&clntraw_lock); 111 if (clp == NULL) { 112 clp = calloc((size_t)1, sizeof (*clp)); 113 if (clp == NULL) 114 goto out; 115 if (__rpc_rawcombuf == NULL) 116 __rpc_rawcombuf = 117 malloc(UDPMSGSIZE); 118 if (__rpc_rawcombuf == NULL) 119 goto out; 120 clp->_raw_buf = __rpc_rawcombuf; 121 clntraw_private = clp; 122 } 123 /* 124 * pre-serialize the static part of the call msg and stash it away 125 */ 126 call_msg.rm_direction = CALL; 127 call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION; 128 /* XXX: prog and vers have been long historically :-( */ 129 call_msg.rm_call.cb_prog = (u_int32_t)prog; 130 call_msg.rm_call.cb_vers = (u_int32_t)vers; 131 xdrmem_create(xdrs, clp->u.mashl_callmsg, MCALL_MSG_SIZE, XDR_ENCODE); 132 if (! xdr_callhdr(xdrs, &call_msg)) 133 warnx("%s: Fatal header serialization error", __func__); 134 clp->mcnt = XDR_GETPOS(xdrs); 135 XDR_DESTROY(xdrs); 136 137 /* 138 * Set xdrmem for client/server shared buffer 139 */ 140 xdrmem_create(xdrs, clp->_raw_buf, UDPMSGSIZE, XDR_FREE); 141 142 /* 143 * create client handle 144 */ 145 client->cl_ops = clnt_raw_ops(); 146 client->cl_auth = authnone_create(); 147 mutex_unlock(&clntraw_lock); 148 return (client); 149 out: 150 if (clp) 151 free(clp); 152 mutex_unlock(&clntraw_lock); 153 return NULL; 154 155 } 156 157 /* ARGSUSED */ 158 static enum clnt_stat 159 clnt_raw_call(CLIENT *h, rpcproc_t proc, xdrproc_t xargs, const char *argsp, 160 xdrproc_t xresults, caddr_t resultsp, struct timeval timeout) 161 { 162 struct clntraw_private *clp = clntraw_private; 163 XDR *xdrs = &clp->xdr_stream; 164 struct rpc_msg msg; 165 enum clnt_stat status; 166 struct rpc_err error; 167 168 _DIAGASSERT(h != NULL); 169 170 mutex_lock(&clntraw_lock); 171 if (clp == NULL) { 172 mutex_unlock(&clntraw_lock); 173 return (RPC_FAILED); 174 } 175 mutex_unlock(&clntraw_lock); 176 177 call_again: 178 /* 179 * send request 180 */ 181 xdrs->x_op = XDR_ENCODE; 182 XDR_SETPOS(xdrs, 0); 183 clp->u.mashl_rpcmsg.rm_xid ++ ; 184 if ((! XDR_PUTBYTES(xdrs, clp->u.mashl_callmsg, clp->mcnt)) || 185 (! XDR_PUTINT32(xdrs, (int32_t *)&proc)) || 186 (! AUTH_MARSHALL(h->cl_auth, xdrs)) || 187 (! (*xargs)(xdrs, __UNCONST(argsp)))) { 188 return (RPC_CANTENCODEARGS); 189 } 190 (void)XDR_GETPOS(xdrs); /* called just to cause overhead */ 191 192 /* 193 * We have to call server input routine here because this is 194 * all going on in one process. Yuk. 195 */ 196 svc_getreq_common(FD_SETSIZE); 197 198 /* 199 * get results 200 */ 201 xdrs->x_op = XDR_DECODE; 202 XDR_SETPOS(xdrs, 0); 203 msg.acpted_rply.ar_verf = _null_auth; 204 msg.acpted_rply.ar_results.where = resultsp; 205 msg.acpted_rply.ar_results.proc = xresults; 206 if (! xdr_replymsg(xdrs, &msg)) { 207 /* 208 * It's possible for xdr_replymsg() to fail partway 209 * through its attempt to decode the result from the 210 * server. If this happens, it will leave the reply 211 * structure partially populated with dynamically 212 * allocated memory. (This can happen if someone uses 213 * clntudp_bufcreate() to create a CLIENT handle and 214 * specifies a receive buffer size that is too small.) 215 * This memory must be free()ed to avoid a leak. 216 */ 217 int op = xdrs->x_op; 218 xdrs->x_op = XDR_FREE; 219 xdr_replymsg(xdrs, &msg); 220 xdrs->x_op = op; 221 return (RPC_CANTDECODERES); 222 } 223 _seterr_reply(&msg, &error); 224 status = error.re_status; 225 226 if (status == RPC_SUCCESS) { 227 if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) { 228 status = RPC_AUTHERROR; 229 } 230 } /* end successful completion */ 231 else { 232 if (AUTH_REFRESH(h->cl_auth)) 233 goto call_again; 234 } /* end of unsuccessful completion */ 235 236 if (status == RPC_SUCCESS) { 237 if (! AUTH_VALIDATE(h->cl_auth, &msg.acpted_rply.ar_verf)) { 238 status = RPC_AUTHERROR; 239 } 240 if (msg.acpted_rply.ar_verf.oa_base != NULL) { 241 xdrs->x_op = XDR_FREE; 242 (void)xdr_opaque_auth(xdrs, &(msg.acpted_rply.ar_verf)); 243 } 244 } 245 246 return (status); 247 } 248 249 /*ARGSUSED*/ 250 static void 251 clnt_raw_geterr(CLIENT *cl, struct rpc_err *error) 252 { 253 } 254 255 256 /* ARGSUSED */ 257 static bool_t 258 clnt_raw_freeres(CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr) 259 { 260 struct clntraw_private *clp = clntraw_private; 261 XDR *xdrs = &clp->xdr_stream; 262 bool_t rval; 263 264 mutex_lock(&clntraw_lock); 265 if (clp == NULL) { 266 rval = (bool_t) RPC_FAILED; 267 mutex_unlock(&clntraw_lock); 268 return (rval); 269 } 270 mutex_unlock(&clntraw_lock); 271 xdrs->x_op = XDR_FREE; 272 return ((*xdr_res)(xdrs, res_ptr)); 273 } 274 275 /*ARGSUSED*/ 276 static void 277 clnt_raw_abort(CLIENT *cl) 278 { 279 } 280 281 /*ARGSUSED*/ 282 static bool_t 283 clnt_raw_control(CLIENT *cl, u_int ui, char *str) 284 { 285 return (FALSE); 286 } 287 288 /*ARGSUSED*/ 289 static void 290 clnt_raw_destroy(CLIENT *cl) 291 { 292 } 293 294 static struct clnt_ops * 295 clnt_raw_ops(void) 296 { 297 static struct clnt_ops ops; 298 #ifdef _REENTRANT 299 extern mutex_t ops_lock; 300 #endif 301 302 /* VARIABLES PROTECTED BY ops_lock: ops */ 303 304 mutex_lock(&ops_lock); 305 if (ops.cl_call == NULL) { 306 ops.cl_call = clnt_raw_call; 307 ops.cl_abort = clnt_raw_abort; 308 ops.cl_geterr = clnt_raw_geterr; 309 ops.cl_freeres = clnt_raw_freeres; 310 ops.cl_destroy = clnt_raw_destroy; 311 ops.cl_control = clnt_raw_control; 312 } 313 mutex_unlock(&ops_lock); 314 return (&ops); 315 } 316
Indexes created Mon Sep 29 21:09:56 GMT 2025