sunrpc/rpc_prot.c

   1 /*
   2  * rpc_prot.c
   3  *
   4  * Copyright (c) 2010, Oracle America, Inc.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above
  13  *       copyright notice, this list of conditions and the following
  14  *       disclaimer in the documentation and/or other materials
  15  *       provided with the distribution.
  16  *     * Neither the name of the "Oracle America, 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
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  *   COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  *   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  27  *   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  *   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  *   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * This set of routines implements the rpc message definition,
  34  * its serializer and some common rpc utility routines.
  35  * The routines are meant for various implementations of rpc -
  36  * they are NOT for the rpc client or rpc service implementations!
  37  * Because authentication stuff is easy and is part of rpc, the opaque
  38  * routines are also in this program.
  39  */
  40
  41 #include <sys/param.h>
  42
  43 #include <rpc/rpc.h>
  44
  45 /* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
  46
  47 /*
  48  * XDR an opaque authentication struct
  49  * (see auth.h)
  50  */
  51 bool_t
  52 xdr_opaque_auth (XDR *xdrs, struct opaque_auth *ap)
  53 {
  54
  55   if (xdr_enum (xdrs, &(ap->oa_flavor)))
  56     return xdr_bytes (xdrs, &ap->oa_base,
  57                       &ap->oa_length, MAX_AUTH_BYTES);
  58   return FALSE;
  59 }
  60 libc_hidden_nolink_sunrpc (xdr_opaque_auth, GLIBC_2_0)
  61
  62 /*
  63  * XDR a DES block
  64  */
  65 bool_t
  66 xdr_des_block (XDR *xdrs, des_block *blkp)
  67 {
  68   return xdr_opaque (xdrs, (caddr_t) blkp, sizeof (des_block));
  69 }
  70 libc_hidden_nolink_sunrpc (xdr_des_block, GLIBC_2_0)
  71
  72 /* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
  73
  74 /*
  75  * XDR the MSG_ACCEPTED part of a reply message union
  76  */
  77 bool_t
  78 xdr_accepted_reply (XDR *xdrs, struct accepted_reply *ar)
  79 {
  80   /* personalized union, rather than calling xdr_union */
  81   if (!xdr_opaque_auth (xdrs, &(ar->ar_verf)))
  82     return FALSE;
  83   if (!xdr_enum (xdrs, (enum_t *) & (ar->ar_stat)))
  84     return FALSE;
  85   switch (ar->ar_stat)
  86     {
  87     case SUCCESS:
  88       return ((*(ar->ar_results.proc)) (xdrs, ar->ar_results.where));
  89     case PROG_MISMATCH:
  90       if (!xdr_u_long (xdrs, &(ar->ar_vers.low)))
  91         return FALSE;
  92       return (xdr_u_long (xdrs, &(ar->ar_vers.high)));
  93     default:
  94       return TRUE;
  95     }
  96   return TRUE;          /* TRUE => open ended set of problems */
  97 }
  98 libc_hidden_nolink_sunrpc (xdr_accepted_reply, GLIBC_2_0)
  99
 100 /*
 101  * XDR the MSG_DENIED part of a reply message union
 102  */
 103 bool_t
 104 xdr_rejected_reply (XDR *xdrs, struct rejected_reply *rr)
 105 {
 106   /* personalized union, rather than calling xdr_union */
 107   if (!xdr_enum (xdrs, (enum_t *) & (rr->rj_stat)))
 108     return FALSE;
 109   switch (rr->rj_stat)
 110     {
 111     case RPC_MISMATCH:
 112       if (!xdr_u_long (xdrs, &(rr->rj_vers.low)))
 113         return FALSE;
 114       return xdr_u_long (xdrs, &(rr->rj_vers.high));
 115
 116     case AUTH_ERROR:
 117       return xdr_enum (xdrs, (enum_t *) & (rr->rj_why));
 118     }
 119   return FALSE;
 120 }
 121 libc_hidden_nolink_sunrpc (xdr_rejected_reply, GLIBC_2_0)
 122
 123 static const struct xdr_discrim reply_dscrm[3] =
 124 {
 125   {(int) MSG_ACCEPTED, (xdrproc_t) xdr_accepted_reply},
 126   {(int) MSG_DENIED, (xdrproc_t) xdr_rejected_reply},
 127   {__dontcare__, NULL_xdrproc_t}};
 128
 129 /*
 130  * XDR a reply message
 131  */
 132 bool_t
 133 xdr_replymsg (XDR *xdrs, struct rpc_msg *rmsg)
 134 {
 135   if (xdr_u_long (xdrs, &(rmsg->rm_xid)) &&
 136       xdr_enum (xdrs, (enum_t *) & (rmsg->rm_direction)) &&
 137       (rmsg->rm_direction == REPLY))
 138     return xdr_union (xdrs, (enum_t *) & (rmsg->rm_reply.rp_stat),
 139                       (caddr_t) & (rmsg->rm_reply.ru), reply_dscrm,
 140                       NULL_xdrproc_t);
 141   return FALSE;
 142 }
 143 libc_hidden_nolink_sunrpc (xdr_replymsg, GLIBC_2_0)
 144
 145
 146 /*
 147  * Serializes the "static part" of a call message header.
 148  * The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
 149  * The rm_xid is not really static, but the user can easily munge on the fly.
 150  */
 151 bool_t
 152 xdr_callhdr (XDR *xdrs, struct rpc_msg *cmsg)
 153 {
 154
 155   cmsg->rm_direction = CALL;
 156   cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
 157   if (
 158        (xdrs->x_op == XDR_ENCODE) &&
 159        xdr_u_long (xdrs, &(cmsg->rm_xid)) &&
 160        xdr_enum (xdrs, (enum_t *) & (cmsg->rm_direction)) &&
 161        xdr_u_long (xdrs, &(cmsg->rm_call.cb_rpcvers)) &&
 162        xdr_u_long (xdrs, &(cmsg->rm_call.cb_prog)))
 163     return xdr_u_long (xdrs, &(cmsg->rm_call.cb_vers));
 164   return FALSE;
 165 }
 166 libc_hidden_nolink_sunrpc (xdr_callhdr, GLIBC_2_0)
 167
 168 /* ************************** Client utility routine ************* */
 169
 170 static void
 171 accepted (enum accept_stat acpt_stat,
 172           struct rpc_err *error)
 173 {
 174   switch (acpt_stat)
 175     {
 176
 177     case PROG_UNAVAIL:
 178       error->re_status = RPC_PROGUNAVAIL;
 179       return;
 180
 181     case PROG_MISMATCH:
 182       error->re_status = RPC_PROGVERSMISMATCH;
 183       return;
 184
 185     case PROC_UNAVAIL:
 186       error->re_status = RPC_PROCUNAVAIL;
 187       return;
 188
 189     case GARBAGE_ARGS:
 190       error->re_status = RPC_CANTDECODEARGS;
 191       return;
 192
 193     case SYSTEM_ERR:
 194       error->re_status = RPC_SYSTEMERROR;
 195       return;
 196
 197     case SUCCESS:
 198       error->re_status = RPC_SUCCESS;
 199       return;
 200     }
 201   /* something's wrong, but we don't know what ... */
 202   error->re_status = RPC_FAILED;
 203   error->re_lb.s1 = (long) MSG_ACCEPTED;
 204   error->re_lb.s2 = (long) acpt_stat;
 205 }
 206
 207 static void
 208 rejected (enum reject_stat rjct_stat,
 209           struct rpc_err *error)
 210 {
 211   switch (rjct_stat)
 212     {
 213     case RPC_MISMATCH:
 214       error->re_status = RPC_VERSMISMATCH;
 215       return;
 216     case AUTH_ERROR:
 217       error->re_status = RPC_AUTHERROR;
 218       return;
 219     default:
 220       /* something's wrong, but we don't know what ... */
 221       error->re_status = RPC_FAILED;
 222       error->re_lb.s1 = (long) MSG_DENIED;
 223       error->re_lb.s2 = (long) rjct_stat;
 224       return;
 225     }
 226 }
 227
 228 /*
 229  * given a reply message, fills in the error
 230  */
 231 void
 232 _seterr_reply (struct rpc_msg *msg,
 233                struct rpc_err *error)
 234 {
 235   /* optimized for normal, SUCCESSful case */
 236   switch (msg->rm_reply.rp_stat)
 237     {
 238     case MSG_ACCEPTED:
 239       if (msg->acpted_rply.ar_stat == SUCCESS)
 240         {
 241           error->re_status = RPC_SUCCESS;
 242           return;
 243         };
 244       accepted (msg->acpted_rply.ar_stat, error);
 245       break;
 246
 247     case MSG_DENIED:
 248       rejected (msg->rjcted_rply.rj_stat, error);
 249       break;
 250
 251     default:
 252       error->re_status = RPC_FAILED;
 253       error->re_lb.s1 = (long) (msg->rm_reply.rp_stat);
 254       break;
 255     }
 256   switch (error->re_status)
 257     {
 258
 259     case RPC_VERSMISMATCH:
 260       error->re_vers.low = msg->rjcted_rply.rj_vers.low;
 261       error->re_vers.high = msg->rjcted_rply.rj_vers.high;
 262       break;
 263
 264     case RPC_AUTHERROR:
 265       error->re_why = msg->rjcted_rply.rj_why;
 266       break;
 267
 268     case RPC_PROGVERSMISMATCH:
 269       error->re_vers.low = msg->acpted_rply.ar_vers.low;
 270       error->re_vers.high = msg->acpted_rply.ar_vers.high;
 271       break;
 272     default:
 273       break;
 274     }
 275 }
 276 libc_hidden_nolink_sunrpc (_seterr_reply, GLIBC_2_0)