source: rtems/cpukit/librpc/src/rpc/rpc_prot.c @ 5220ae2

4.104.114.84.95
Last change on this file since 5220ae2 was df49c60, checked in by Joel Sherrill <joel.sherrill@…>, on 06/12/00 at 15:00:15

Merged from 4.5.0-beta3a

  • Property mode set to 100644
File size: 7.3 KB
Line 
1/*
2 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3 * unrestricted use provided that this legend is included on all tape
4 * media and as a part of the software program in whole or part.  Users
5 * may copy or modify Sun RPC without charge, but are not authorized
6 * to license or distribute it to anyone else except as part of a product or
7 * program developed by the user.
8 *
9 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12 *
13 * Sun RPC is provided with no support and without any obligation on the
14 * part of Sun Microsystems, Inc. to assist in its use, correction,
15 * modification or enhancement.
16 *
17 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19 * OR ANY PART THEREOF.
20 *
21 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22 * or profits or other special, indirect and consequential damages, even if
23 * Sun has been advised of the possibility of such damages.
24 *
25 * Sun Microsystems, Inc.
26 * 2550 Garcia Avenue
27 * Mountain View, California  94043
28 */
29
30#if defined(LIBC_SCCS) && !defined(lint)
31/*static char *sccsid = "from: @(#)rpc_prot.c 1.36 87/08/11 Copyr 1984 Sun Micro";*/
32/*static char *sccsid = "from: @(#)rpc_prot.c   2.3 88/08/07 4.0 RPCSRC";*/
33static char *rcsid = "$FreeBSD: src/lib/libc/rpc/rpc_prot.c,v 1.8 1999/08/28 00:00:46 peter Exp $";
34#endif
35
36/*
37 * rpc_prot.c
38 *
39 * Copyright (C) 1984, Sun Microsystems, Inc.
40 *
41 * This set of routines implements the rpc message definition,
42 * its serializer and some common rpc utility routines.
43 * The routines are meant for various implementations of rpc -
44 * they are NOT for the rpc client or rpc service implementations!
45 * Because authentication stuff is easy and is part of rpc, the opaque
46 * routines are also in this program.
47 */
48
49#include <sys/param.h>
50
51#include <rpc/rpc.h>
52
53/* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
54
55struct opaque_auth _null_auth;
56
57/*
58 * XDR an opaque authentication struct
59 * (see auth.h)
60 */
61bool_t
62xdr_opaque_auth(xdrs, ap)
63        register XDR *xdrs;
64        register struct opaque_auth *ap;
65{
66
67        if (xdr_enum(xdrs, &(ap->oa_flavor)))
68                return (xdr_bytes(xdrs, &ap->oa_base,
69                        &ap->oa_length, MAX_AUTH_BYTES));
70        return (FALSE);
71}
72
73/*
74 * XDR a DES block
75 */
76bool_t
77xdr_des_block(xdrs, blkp)
78        register XDR *xdrs;
79        register des_block *blkp;
80{
81        return (xdr_opaque(xdrs, (caddr_t)blkp, sizeof(des_block)));
82}
83
84/* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
85
86/*
87 * XDR the MSG_ACCEPTED part of a reply message union
88 */
89bool_t
90xdr_accepted_reply(xdrs, ar)
91        register XDR *xdrs;
92        register struct accepted_reply *ar;
93{
94
95        /* personalized union, rather than calling xdr_union */
96        if (! xdr_opaque_auth(xdrs, &(ar->ar_verf)))
97                return (FALSE);
98        if (! xdr_enum(xdrs, (enum_t *)&(ar->ar_stat)))
99                return (FALSE);
100        switch (ar->ar_stat) {
101
102        case SUCCESS:
103                return ((*(ar->ar_results.proc))(xdrs, ar->ar_results.where));
104
105        case PROG_MISMATCH:
106                if (! xdr_u_int32_t(xdrs, &(ar->ar_vers.low)))
107                        return (FALSE);
108                return (xdr_u_int32_t(xdrs, &(ar->ar_vers.high)));
109        default:
110                break;
111        }
112        return (TRUE);  /* TRUE => open ended set of problems */
113}
114
115/*
116 * XDR the MSG_DENIED part of a reply message union
117 */
118bool_t
119xdr_rejected_reply(xdrs, rr)
120        register XDR *xdrs;
121        register struct rejected_reply *rr;
122{
123
124        /* personalized union, rather than calling xdr_union */
125        if (! xdr_enum(xdrs, (enum_t *)&(rr->rj_stat)))
126                return (FALSE);
127        switch (rr->rj_stat) {
128
129        case RPC_MISMATCH:
130                if (! xdr_u_int32_t(xdrs, &(rr->rj_vers.low)))
131                        return (FALSE);
132                return (xdr_u_int32_t(xdrs, &(rr->rj_vers.high)));
133
134        case AUTH_ERROR:
135                return (xdr_enum(xdrs, (enum_t *)&(rr->rj_why)));
136        }
137        return (FALSE);
138}
139
140static struct xdr_discrim reply_dscrm[3] = {
141        { (int)MSG_ACCEPTED, xdr_accepted_reply },
142        { (int)MSG_DENIED, xdr_rejected_reply },
143        { __dontcare__, NULL_xdrproc_t } };
144
145/*
146 * XDR a reply message
147 */
148bool_t
149xdr_replymsg(xdrs, rmsg)
150        register XDR *xdrs;
151        register struct rpc_msg *rmsg;
152{
153        if (
154            xdr_u_int32_t(xdrs, &(rmsg->rm_xid)) &&
155            xdr_enum(xdrs, (enum_t *)&(rmsg->rm_direction)) &&
156            (rmsg->rm_direction == REPLY) )
157                return (xdr_union(xdrs, (enum_t *)&(rmsg->rm_reply.rp_stat),
158                   (caddr_t)&(rmsg->rm_reply.ru), reply_dscrm, NULL_xdrproc_t));
159        return (FALSE);
160}
161
162
163/*
164 * Serializes the "static part" of a call message header.
165 * The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
166 * The rm_xid is not really static, but the user can easily munge on the fly.
167 */
168bool_t
169xdr_callhdr(xdrs, cmsg)
170        register XDR *xdrs;
171        register struct rpc_msg *cmsg;
172{
173
174        cmsg->rm_direction = CALL;
175        cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
176        if (
177            (xdrs->x_op == XDR_ENCODE) &&
178            xdr_u_int32_t(xdrs, &(cmsg->rm_xid)) &&
179            xdr_enum(xdrs, (enum_t *)&(cmsg->rm_direction)) &&
180            xdr_u_int32_t(xdrs, &(cmsg->rm_call.cb_rpcvers)) &&
181            xdr_u_int32_t(xdrs, &(cmsg->rm_call.cb_prog)) )
182            return (xdr_u_int32_t(xdrs, &(cmsg->rm_call.cb_vers)));
183        return (FALSE);
184}
185
186/* ************************** Client utility routine ************* */
187
188static void
189accepted(acpt_stat, error)
190        register enum accept_stat acpt_stat;
191        register struct rpc_err *error;
192{
193
194        switch (acpt_stat) {
195
196        case PROG_UNAVAIL:
197                error->re_status = RPC_PROGUNAVAIL;
198                return;
199
200        case PROG_MISMATCH:
201                error->re_status = RPC_PROGVERSMISMATCH;
202                return;
203
204        case PROC_UNAVAIL:
205                error->re_status = RPC_PROCUNAVAIL;
206                return;
207
208        case GARBAGE_ARGS:
209                error->re_status = RPC_CANTDECODEARGS;
210                return;
211
212        case SYSTEM_ERR:
213                error->re_status = RPC_SYSTEMERROR;
214                return;
215
216        case SUCCESS:
217                error->re_status = RPC_SUCCESS;
218                return;
219        }
220        /* something's wrong, but we don't know what ... */
221        error->re_status = RPC_FAILED;
222        error->re_lb.s1 = (long)MSG_ACCEPTED;
223        error->re_lb.s2 = (long)acpt_stat;
224}
225
226static void
227rejected(rjct_stat, error)
228        register enum reject_stat rjct_stat;
229        register struct rpc_err *error;
230{
231
232        switch (rjct_stat) {
233
234        case RPC_VERSMISMATCH:
235                error->re_status = RPC_VERSMISMATCH;
236                return;
237
238        case AUTH_ERROR:
239                error->re_status = RPC_AUTHERROR;
240                return;
241        default:
242                break;
243        }
244        /* something's wrong, but we don't know what ... */
245        error->re_status = RPC_FAILED;
246        error->re_lb.s1 = (long)MSG_DENIED;
247        error->re_lb.s2 = (long)rjct_stat;
248}
249
250/*
251 * given a reply message, fills in the error
252 */
253void
254_seterr_reply(msg, error)
255        register struct rpc_msg *msg;
256        register struct rpc_err *error;
257{
258
259        /* optimized for normal, SUCCESSful case */
260        switch (msg->rm_reply.rp_stat) {
261
262        case MSG_ACCEPTED:
263                if (msg->acpted_rply.ar_stat == SUCCESS) {
264                        error->re_status = RPC_SUCCESS;
265                        return;
266                };
267                accepted(msg->acpted_rply.ar_stat, error);
268                break;
269
270        case MSG_DENIED:
271                rejected(msg->rjcted_rply.rj_stat, error);
272                break;
273
274        default:
275                error->re_status = RPC_FAILED;
276                error->re_lb.s1 = (long)(msg->rm_reply.rp_stat);
277                break;
278        }
279        switch (error->re_status) {
280
281        case RPC_VERSMISMATCH:
282                error->re_vers.low = msg->rjcted_rply.rj_vers.low;
283                error->re_vers.high = msg->rjcted_rply.rj_vers.high;
284                break;
285
286        case RPC_AUTHERROR:
287                error->re_why = msg->rjcted_rply.rj_why;
288                break;
289
290        case RPC_PROGVERSMISMATCH:
291                error->re_vers.low = msg->acpted_rply.ar_vers.low;
292                error->re_vers.high = msg->acpted_rply.ar_vers.high;
293                break;
294        default:
295                break;
296        }
297}
Note: See TracBrowser for help on using the repository browser.