1 /* $NetBSD: clnt_raw.c,v 1.32 2013/03/11 20:19:29 tron 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.32 2013/03/11 20:19:29 tron 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 *
clnt_raw_create(rpcprog_t prog,rpcvers_t vers)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
clnt_raw_call(CLIENT * h,rpcproc_t proc,xdrproc_t xargs,const char * argsp,xdrproc_t xresults,caddr_t resultsp,struct timeval timeout)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
clnt_raw_geterr(CLIENT * cl,struct rpc_err * error)251 clnt_raw_geterr(CLIENT *cl, struct rpc_err *error)
252 {
253 }
254
255
256 /* ARGSUSED */
257 static bool_t
clnt_raw_freeres(CLIENT * cl,xdrproc_t xdr_res,caddr_t res_ptr)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
clnt_raw_abort(CLIENT * cl)277 clnt_raw_abort(CLIENT *cl)
278 {
279 }
280
281 /*ARGSUSED*/
282 static bool_t
clnt_raw_control(CLIENT * cl,u_int ui,char * str)283 clnt_raw_control(CLIENT *cl, u_int ui, char *str)
284 {
285 return (FALSE);
286 }
287
288 /*ARGSUSED*/
289 static void
clnt_raw_destroy(CLIENT * cl)290 clnt_raw_destroy(CLIENT *cl)
291 {
292 }
293
294 static struct clnt_ops *
clnt_raw_ops(void)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