1 /* $NetBSD: rpc_prot.c,v 1.16 2000/06/02 23:11:13 fvdl Exp $ */
2
3 /*-
4 * SPDX-License-Identifier: BSD-3-Clause
5 *
6 * Copyright (c) 2009, Sun Microsystems, Inc.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 * - Redistributions of source code must retain the above copyright notice,
12 * this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright notice,
14 * this list of conditions and the following disclaimer in the documentation
15 * and/or other materials provided with the distribution.
16 * - Neither the name of Sun Microsystems, 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 "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 /*
35 * rpc_prot.c
36 *
37 * Copyright (C) 1984, Sun Microsystems, Inc.
38 *
39 * This set of routines implements the rpc message definition,
40 * its serializer and some common rpc utility routines.
41 * The routines are meant for various implementations of rpc -
42 * they are NOT for the rpc client or rpc service implementations!
43 * Because authentication stuff is easy and is part of rpc, the opaque
44 * routines are also in this program.
45 */
46
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
50 #include <sys/malloc.h>
51
52 #include <rpc/types.h>
53 #include <rpc/xdr.h>
54 #include <rpc/auth.h>
55 #include <rpc/clnt.h>
56 #include <rpc/rpc_msg.h>
57
58 #define assert(exp) KASSERT(exp, ("bad arguments"))
59
60 static enum clnt_stat accepted(enum accept_stat, struct rpc_err *);
61 static enum clnt_stat rejected(enum reject_stat, struct rpc_err *);
62
63 /* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
64
65 struct opaque_auth _null_auth;
66
67 /*
68 * XDR an opaque authentication struct
69 * (see auth.h)
70 */
71 bool_t
xdr_opaque_auth(XDR * xdrs,struct opaque_auth * ap)72 xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap)
73 {
74
75 assert(xdrs != NULL);
76 assert(ap != NULL);
77
78 if (xdr_enum(xdrs, &(ap->oa_flavor)))
79 return (xdr_bytes(xdrs, &ap->oa_base,
80 &ap->oa_length, MAX_AUTH_BYTES));
81 return (FALSE);
82 }
83
84 /* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
85
86 /*
87 * XDR the MSG_ACCEPTED part of a reply message union
88 */
89 bool_t
xdr_accepted_reply(XDR * xdrs,struct accepted_reply * ar)90 xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar)
91 {
92 enum accept_stat *par_stat;
93
94 assert(xdrs != NULL);
95 assert(ar != NULL);
96
97 par_stat = &ar->ar_stat;
98
99 /* personalized union, rather than calling xdr_union */
100 if (! xdr_opaque_auth(xdrs, &(ar->ar_verf)))
101 return (FALSE);
102 if (! xdr_enum(xdrs, (enum_t *) par_stat))
103 return (FALSE);
104 switch (ar->ar_stat) {
105
106 case SUCCESS:
107 if (ar->ar_results.proc != (xdrproc_t) xdr_void)
108 return ((*(ar->ar_results.proc))(xdrs,
109 ar->ar_results.where));
110 else
111 return (TRUE);
112
113 case PROG_MISMATCH:
114 if (! xdr_uint32_t(xdrs, &(ar->ar_vers.low)))
115 return (FALSE);
116 return (xdr_uint32_t(xdrs, &(ar->ar_vers.high)));
117
118 case GARBAGE_ARGS:
119 case SYSTEM_ERR:
120 case PROC_UNAVAIL:
121 case PROG_UNAVAIL:
122 break;
123 }
124 return (TRUE); /* TRUE => open ended set of problems */
125 }
126
127 /*
128 * XDR the MSG_DENIED part of a reply message union
129 */
130 bool_t
xdr_rejected_reply(XDR * xdrs,struct rejected_reply * rr)131 xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr)
132 {
133 enum reject_stat *prj_stat;
134 enum auth_stat *prj_why;
135
136 assert(xdrs != NULL);
137 assert(rr != NULL);
138
139 prj_stat = &rr->rj_stat;
140
141 /* personalized union, rather than calling xdr_union */
142 if (! xdr_enum(xdrs, (enum_t *) prj_stat))
143 return (FALSE);
144 switch (rr->rj_stat) {
145
146 case RPC_MISMATCH:
147 if (! xdr_uint32_t(xdrs, &(rr->rj_vers.low)))
148 return (FALSE);
149 return (xdr_uint32_t(xdrs, &(rr->rj_vers.high)));
150
151 case AUTH_ERROR:
152 prj_why = &rr->rj_why;
153 return (xdr_enum(xdrs, (enum_t *) prj_why));
154 }
155 /* NOTREACHED */
156 assert(0);
157 return (FALSE);
158 }
159
160 static const struct xdr_discrim reply_dscrm[3] = {
161 { (int)MSG_ACCEPTED, (xdrproc_t)xdr_accepted_reply },
162 { (int)MSG_DENIED, (xdrproc_t)xdr_rejected_reply },
163 { __dontcare__, NULL_xdrproc_t } };
164
165 /*
166 * XDR a reply message
167 */
168 bool_t
xdr_replymsg(XDR * xdrs,struct rpc_msg * rmsg)169 xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg)
170 {
171 int32_t *buf;
172 enum msg_type *prm_direction;
173 enum reply_stat *prp_stat;
174
175 assert(xdrs != NULL);
176 assert(rmsg != NULL);
177
178 if (xdrs->x_op == XDR_DECODE) {
179 buf = XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT);
180 if (buf != NULL) {
181 rmsg->rm_xid = IXDR_GET_UINT32(buf);
182 rmsg->rm_direction = IXDR_GET_ENUM(buf, enum msg_type);
183 if (rmsg->rm_direction != REPLY) {
184 return (FALSE);
185 }
186 rmsg->rm_reply.rp_stat =
187 IXDR_GET_ENUM(buf, enum reply_stat);
188 if (rmsg->rm_reply.rp_stat == MSG_ACCEPTED)
189 return (xdr_accepted_reply(xdrs,
190 &rmsg->acpted_rply));
191 else if (rmsg->rm_reply.rp_stat == MSG_DENIED)
192 return (xdr_rejected_reply(xdrs,
193 &rmsg->rjcted_rply));
194 else
195 return (FALSE);
196 }
197 }
198
199 prm_direction = &rmsg->rm_direction;
200 prp_stat = &rmsg->rm_reply.rp_stat;
201
202 if (
203 xdr_uint32_t(xdrs, &(rmsg->rm_xid)) &&
204 xdr_enum(xdrs, (enum_t *) prm_direction) &&
205 (rmsg->rm_direction == REPLY) )
206 return (xdr_union(xdrs, (enum_t *) prp_stat,
207 (caddr_t)(void *)&(rmsg->rm_reply.ru), reply_dscrm,
208 NULL_xdrproc_t));
209 return (FALSE);
210 }
211
212
213 /*
214 * Serializes the "static part" of a call message header.
215 * The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
216 * The rm_xid is not really static, but the user can easily munge on the fly.
217 */
218 bool_t
xdr_callhdr(XDR * xdrs,struct rpc_msg * cmsg)219 xdr_callhdr(XDR *xdrs, struct rpc_msg *cmsg)
220 {
221 enum msg_type *prm_direction;
222
223 assert(xdrs != NULL);
224 assert(cmsg != NULL);
225
226 prm_direction = &cmsg->rm_direction;
227
228 cmsg->rm_direction = CALL;
229 cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
230 if (
231 (xdrs->x_op == XDR_ENCODE) &&
232 xdr_uint32_t(xdrs, &(cmsg->rm_xid)) &&
233 xdr_enum(xdrs, (enum_t *) prm_direction) &&
234 xdr_uint32_t(xdrs, &(cmsg->rm_call.cb_rpcvers)) &&
235 xdr_uint32_t(xdrs, &(cmsg->rm_call.cb_prog)) )
236 return (xdr_uint32_t(xdrs, &(cmsg->rm_call.cb_vers)));
237 return (FALSE);
238 }
239
240 /* ************************** Client utility routine ************* */
241
242 static enum clnt_stat
accepted(enum accept_stat acpt_stat,struct rpc_err * error)243 accepted(enum accept_stat acpt_stat, struct rpc_err *error)
244 {
245
246 assert(error != NULL);
247
248 switch (acpt_stat) {
249
250 case PROG_UNAVAIL:
251 error->re_status = RPC_PROGUNAVAIL;
252 return (RPC_PROGUNAVAIL);
253
254 case PROG_MISMATCH:
255 error->re_status = RPC_PROGVERSMISMATCH;
256 return (RPC_PROGVERSMISMATCH);
257
258 case PROC_UNAVAIL:
259 return (RPC_PROCUNAVAIL);
260
261 case GARBAGE_ARGS:
262 return (RPC_CANTDECODEARGS);
263
264 case SYSTEM_ERR:
265 return (RPC_SYSTEMERROR);
266
267 case SUCCESS:
268 return (RPC_SUCCESS);
269 }
270 /* NOTREACHED */
271 /* something's wrong, but we don't know what ... */
272 error->re_lb.s1 = (int32_t)MSG_ACCEPTED;
273 error->re_lb.s2 = (int32_t)acpt_stat;
274 return (RPC_FAILED);
275 }
276
277 static enum clnt_stat
rejected(enum reject_stat rjct_stat,struct rpc_err * error)278 rejected(enum reject_stat rjct_stat, struct rpc_err *error)
279 {
280
281 assert(error != NULL);
282
283 switch (rjct_stat) {
284 case RPC_MISMATCH:
285 return (RPC_VERSMISMATCH);
286
287 case AUTH_ERROR:
288 return (RPC_AUTHERROR);
289 }
290 /* something's wrong, but we don't know what ... */
291 /* NOTREACHED */
292 error->re_lb.s1 = (int32_t)MSG_DENIED;
293 error->re_lb.s2 = (int32_t)rjct_stat;
294 return (RPC_FAILED);
295 }
296
297 /*
298 * given a reply message, fills in the error
299 */
300 enum clnt_stat
_seterr_reply(struct rpc_msg * msg,struct rpc_err * error)301 _seterr_reply(struct rpc_msg *msg, struct rpc_err *error)
302 {
303 enum clnt_stat stat;
304
305 assert(msg != NULL);
306 assert(error != NULL);
307
308 /* optimized for normal, SUCCESSful case */
309 switch (msg->rm_reply.rp_stat) {
310
311 case MSG_ACCEPTED:
312 if (msg->acpted_rply.ar_stat == SUCCESS) {
313 stat = RPC_SUCCESS;
314 return (stat);
315 }
316 stat = accepted(msg->acpted_rply.ar_stat, error);
317 break;
318
319 case MSG_DENIED:
320 stat = rejected(msg->rjcted_rply.rj_stat, error);
321 break;
322
323 default:
324 stat = RPC_FAILED;
325 error->re_lb.s1 = (int32_t)(msg->rm_reply.rp_stat);
326 break;
327 }
328 error->re_status = stat;
329
330 switch (stat) {
331
332 case RPC_VERSMISMATCH:
333 error->re_vers.low = msg->rjcted_rply.rj_vers.low;
334 error->re_vers.high = msg->rjcted_rply.rj_vers.high;
335 break;
336
337 case RPC_AUTHERROR:
338 error->re_why = msg->rjcted_rply.rj_why;
339 break;
340
341 case RPC_PROGVERSMISMATCH:
342 error->re_vers.low = msg->acpted_rply.ar_vers.low;
343 error->re_vers.high = msg->acpted_rply.ar_vers.high;
344 break;
345
346 case RPC_FAILED:
347 case RPC_SUCCESS:
348 case RPC_PROGNOTREGISTERED:
349 case RPC_PMAPFAILURE:
350 case RPC_UNKNOWNPROTO:
351 case RPC_UNKNOWNHOST:
352 case RPC_SYSTEMERROR:
353 case RPC_CANTDECODEARGS:
354 case RPC_PROCUNAVAIL:
355 case RPC_PROGUNAVAIL:
356 case RPC_TIMEDOUT:
357 case RPC_CANTRECV:
358 case RPC_CANTSEND:
359 case RPC_CANTDECODERES:
360 case RPC_CANTENCODEARGS:
361 default:
362 break;
363 }
364
365 return (stat);
366 }
367