1 /* $NetBSD: rpc_prot.c,v 1.16 2000/06/02 23:11:13 fvdl Exp $ */
4 * SPDX-License-Identifier: BSD-3-Clause
6 * Copyright (c) 2009, Sun Microsystems, Inc.
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.
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.
33 #include <sys/cdefs.h>
37 * Copyright (C) 1984, Sun Microsystems, Inc.
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.
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
50 #include <sys/malloc.h>
52 #include <rpc/types.h>
56 #include <rpc/rpc_msg.h>
58 #define assert(exp) KASSERT(exp, ("bad arguments"))
60 static enum clnt_stat accepted(enum accept_stat, struct rpc_err *);
61 static enum clnt_stat rejected(enum reject_stat, struct rpc_err *);
63 /* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
65 struct opaque_auth _null_auth;
68 * XDR an opaque authentication struct
72 xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap)
78 if (xdr_enum(xdrs, &(ap->oa_flavor)))
79 return (xdr_bytes(xdrs, &ap->oa_base,
80 &ap->oa_length, MAX_AUTH_BYTES));
84 /* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
87 * XDR the MSG_ACCEPTED part of a reply message union
90 xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar)
92 enum accept_stat *par_stat;
97 par_stat = &ar->ar_stat;
99 /* personalized union, rather than calling xdr_union */
100 if (! xdr_opaque_auth(xdrs, &(ar->ar_verf)))
102 if (! xdr_enum(xdrs, (enum_t *) par_stat))
104 switch (ar->ar_stat) {
107 if (ar->ar_results.proc != (xdrproc_t) xdr_void)
108 return ((*(ar->ar_results.proc))(xdrs,
109 ar->ar_results.where));
114 if (! xdr_uint32_t(xdrs, &(ar->ar_vers.low)))
116 return (xdr_uint32_t(xdrs, &(ar->ar_vers.high)));
124 return (TRUE); /* TRUE => open ended set of problems */
128 * XDR the MSG_DENIED part of a reply message union
131 xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr)
133 enum reject_stat *prj_stat;
134 enum auth_stat *prj_why;
136 assert(xdrs != NULL);
139 prj_stat = &rr->rj_stat;
141 /* personalized union, rather than calling xdr_union */
142 if (! xdr_enum(xdrs, (enum_t *) prj_stat))
144 switch (rr->rj_stat) {
147 if (! xdr_uint32_t(xdrs, &(rr->rj_vers.low)))
149 return (xdr_uint32_t(xdrs, &(rr->rj_vers.high)));
152 prj_why = &rr->rj_why;
153 return (xdr_enum(xdrs, (enum_t *) prj_why));
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 } };
166 * XDR a reply message
169 xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg)
172 enum msg_type *prm_direction;
173 enum reply_stat *prp_stat;
175 assert(xdrs != NULL);
176 assert(rmsg != NULL);
178 if (xdrs->x_op == XDR_DECODE) {
179 buf = XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT);
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) {
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));
199 prm_direction = &rmsg->rm_direction;
200 prp_stat = &rmsg->rm_reply.rp_stat;
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,
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.
219 xdr_callhdr(XDR *xdrs, struct rpc_msg *cmsg)
221 enum msg_type *prm_direction;
223 assert(xdrs != NULL);
224 assert(cmsg != NULL);
226 prm_direction = &cmsg->rm_direction;
228 cmsg->rm_direction = CALL;
229 cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
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)));
240 /* ************************** Client utility routine ************* */
242 static enum clnt_stat
243 accepted(enum accept_stat acpt_stat, struct rpc_err *error)
246 assert(error != NULL);
251 error->re_status = RPC_PROGUNAVAIL;
252 return (RPC_PROGUNAVAIL);
255 error->re_status = RPC_PROGVERSMISMATCH;
256 return (RPC_PROGVERSMISMATCH);
259 return (RPC_PROCUNAVAIL);
262 return (RPC_CANTDECODEARGS);
265 return (RPC_SYSTEMERROR);
268 return (RPC_SUCCESS);
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;
277 static enum clnt_stat
278 rejected(enum reject_stat rjct_stat, struct rpc_err *error)
281 assert(error != NULL);
285 return (RPC_VERSMISMATCH);
288 return (RPC_AUTHERROR);
290 /* something's wrong, but we don't know what ... */
292 error->re_lb.s1 = (int32_t)MSG_DENIED;
293 error->re_lb.s2 = (int32_t)rjct_stat;
298 * given a reply message, fills in the error
301 _seterr_reply(struct rpc_msg *msg, struct rpc_err *error)
306 assert(error != NULL);
308 /* optimized for normal, SUCCESSful case */
309 switch (msg->rm_reply.rp_stat) {
312 if (msg->acpted_rply.ar_stat == SUCCESS) {
316 stat = accepted(msg->acpted_rply.ar_stat, error);
320 stat = rejected(msg->rjcted_rply.rj_stat, error);
325 error->re_lb.s1 = (int32_t)(msg->rm_reply.rp_stat);
328 error->re_status = stat;
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;
338 error->re_why = msg->rjcted_rply.rj_why;
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;
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:
359 case RPC_CANTDECODERES:
360 case RPC_CANTENCODEARGS: