* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
* unrestricted use provided that this legend is included on all tape
* media and as a part of the software program in whole or part. Users
* may copy or modify Sun RPC without charge, but are not authorized
* to license or distribute it to anyone else except as part of a product or
* program developed by the user.
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
* Sun RPC is provided with no support and without any obligation on the
* part of Sun Microsystems, Inc. to assist in its use, correction,
* modification or enhancement.
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
* or profits or other special, indirect and consequential damages, even if
* Sun has been advised of the possibility of such damages.
* Mountain View, California 94043
#if defined(LIBC_SCCS) && !defined(lint)
/*static char *sccsid = "from: @(#)rpc_prot.c 1.36 87/08/11 Copyr 1984 Sun Micro";*/
/*static char *sccsid = "from: @(#)rpc_prot.c 2.3 88/08/07 4.0 RPCSRC";*/
static char *rcsid
= "$Id: rpc_prot.c,v 1.3 1993/08/26 00:53:36 jtc Exp $";
* Copyright (C) 1984, Sun Microsystems, Inc.
* This set of routines implements the rpc message definition,
* its serializer and some common rpc utility routines.
* The routines are meant for various implementations of rpc -
* they are NOT for the rpc client or rpc service implementations!
* Because authentication stuff is easy and is part of rpc, the opaque
* routines are also in this program.
/* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
struct opaque_auth _null_auth
;
* XDR an opaque authentication struct
xdr_opaque_auth(xdrs
, ap
)
register struct opaque_auth
*ap
;
if (xdr_enum(xdrs
, &(ap
->oa_flavor
)))
return (xdr_bytes(xdrs
, &ap
->oa_base
,
&ap
->oa_length
, MAX_AUTH_BYTES
));
xdr_des_block(xdrs
, blkp
)
register des_block
*blkp
;
return (xdr_opaque(xdrs
, (caddr_t
)blkp
, sizeof(des_block
)));
/* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
* XDR the MSG_ACCEPTED part of a reply message union
xdr_accepted_reply(xdrs
, ar
)
register struct accepted_reply
*ar
;
/* personalized union, rather than calling xdr_union */
if (! xdr_opaque_auth(xdrs
, &(ar
->ar_verf
)))
if (! xdr_enum(xdrs
, (enum_t
*)&(ar
->ar_stat
)))
return ((*(ar
->ar_results
.proc
))(xdrs
, ar
->ar_results
.where
));
if (! xdr_u_long(xdrs
, &(ar
->ar_vers
.low
)))
return (xdr_u_long(xdrs
, &(ar
->ar_vers
.high
)));
return (TRUE
); /* TRUE => open ended set of problems */
* XDR the MSG_DENIED part of a reply message union
xdr_rejected_reply(xdrs
, rr
)
register struct rejected_reply
*rr
;
/* personalized union, rather than calling xdr_union */
if (! xdr_enum(xdrs
, (enum_t
*)&(rr
->rj_stat
)))
if (! xdr_u_long(xdrs
, &(rr
->rj_vers
.low
)))
return (xdr_u_long(xdrs
, &(rr
->rj_vers
.high
)));
return (xdr_enum(xdrs
, (enum_t
*)&(rr
->rj_why
)));
static struct xdr_discrim reply_dscrm
[3] = {
{ (int)MSG_ACCEPTED
, xdr_accepted_reply
},
{ (int)MSG_DENIED
, xdr_rejected_reply
},
{ __dontcare__
, NULL_xdrproc_t
} };
register struct rpc_msg
*rmsg
;
xdr_u_long(xdrs
, &(rmsg
->rm_xid
)) &&
xdr_enum(xdrs
, (enum_t
*)&(rmsg
->rm_direction
)) &&
(rmsg
->rm_direction
== REPLY
) )
return (xdr_union(xdrs
, (enum_t
*)&(rmsg
->rm_reply
.rp_stat
),
(caddr_t
)&(rmsg
->rm_reply
.ru
), reply_dscrm
, NULL_xdrproc_t
));
* Serializes the "static part" of a call message header.
* The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
* The rm_xid is not really static, but the user can easily munge on the fly.
register struct rpc_msg
*cmsg
;
cmsg
->rm_direction
= CALL
;
cmsg
->rm_call
.cb_rpcvers
= RPC_MSG_VERSION
;
(xdrs
->x_op
== XDR_ENCODE
) &&
xdr_u_long(xdrs
, &(cmsg
->rm_xid
)) &&
xdr_enum(xdrs
, (enum_t
*)&(cmsg
->rm_direction
)) &&
xdr_u_long(xdrs
, &(cmsg
->rm_call
.cb_rpcvers
)) &&
xdr_u_long(xdrs
, &(cmsg
->rm_call
.cb_prog
)) )
return (xdr_u_long(xdrs
, &(cmsg
->rm_call
.cb_vers
)));
/* ************************** Client utility routine ************* */
accepted(acpt_stat
, error
)
register enum accept_stat acpt_stat
;
register struct rpc_err
*error
;
error
->re_status
= RPC_PROGUNAVAIL
;
error
->re_status
= RPC_PROGVERSMISMATCH
;
error
->re_status
= RPC_PROCUNAVAIL
;
error
->re_status
= RPC_CANTDECODEARGS
;
error
->re_status
= RPC_SYSTEMERROR
;
error
->re_status
= RPC_SUCCESS
;
/* something's wrong, but we don't know what ... */
error
->re_status
= RPC_FAILED
;
error
->re_lb
.s1
= (long)MSG_ACCEPTED
;
error
->re_lb
.s2
= (long)acpt_stat
;
rejected(rjct_stat
, error
)
register enum reject_stat rjct_stat
;
register struct rpc_err
*error
;
error
->re_status
= RPC_VERSMISMATCH
;
error
->re_status
= RPC_AUTHERROR
;
/* something's wrong, but we don't know what ... */
error
->re_status
= RPC_FAILED
;
error
->re_lb
.s1
= (long)MSG_DENIED
;
error
->re_lb
.s2
= (long)rjct_stat
;
* given a reply message, fills in the error
_seterr_reply(msg
, error
)
register struct rpc_msg
*msg
;
register struct rpc_err
*error
;
/* optimized for normal, SUCCESSful case */
switch (msg
->rm_reply
.rp_stat
) {
if (msg
->acpted_rply
.ar_stat
== SUCCESS
) {
error
->re_status
= RPC_SUCCESS
;
accepted(msg
->acpted_rply
.ar_stat
, error
);
rejected(msg
->rjcted_rply
.rj_stat
, error
);
error
->re_status
= RPC_FAILED
;
error
->re_lb
.s1
= (long)(msg
->rm_reply
.rp_stat
);
switch (error
->re_status
) {
error
->re_vers
.low
= msg
->rjcted_rply
.rj_vers
.low
;
error
->re_vers
.high
= msg
->rjcted_rply
.rj_vers
.high
;
error
->re_why
= msg
->rjcted_rply
.rj_why
;
case RPC_PROGVERSMISMATCH
:
error
->re_vers
.low
= msg
->acpted_rply
.ar_vers
.low
;
error
->re_vers
.high
= msg
->acpted_rply
.ar_vers
.high
;