lib/libc/rpc/rpc_prot.c

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