sunrpc/clnt_unix.c

   1 /*
   2  * clnt_unix.c, Implements a TCP/IP based, client side RPC.
   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  * TCP based RPC supports 'batched calls'.
  34  * A sequence of calls may be batched-up in a send buffer.  The rpc call
  35  * return immediately to the client even though the call was not necessarily
  36  * sent.  The batching occurs if the results' xdr routine is NULL (0) AND
  37  * the rpc timeout value is zero (see clnt.h, rpc).
  38  *
  39  * Clients should NOT casually batch calls that in fact return results; that is,
  40  * the server side should be aware that a call is batched and not produce any
  41  * return message.  Batched calls that produce many result messages can
  42  * deadlock (netlock) the client and the server....
  43  *
  44  * Now go hang yourself.
  45  */
  46
  47 #include <netdb.h>
  48 #include <errno.h>
  49 #include <stdio.h>
  50 #include <unistd.h>
  51 #include <libintl.h>
  52 #include <rpc/rpc.h>
  53 #include <sys/uio.h>
  54 #include <sys/poll.h>
  55 #include <sys/socket.h>
  56 #include <rpc/pmap_clnt.h>
  57 #include <wchar.h>
  58
  59 extern u_long _create_xid (void);
  60
  61 #define MCALL_MSG_SIZE 24
  62
  63 struct ct_data
  64   {
  65     int ct_sock;
  66     bool_t ct_closeit;
  67     struct timeval ct_wait;
  68     bool_t ct_waitset;          /* wait set by clnt_control? */
  69     struct sockaddr_un ct_addr;
  70     struct rpc_err ct_error;
  71     char ct_mcall[MCALL_MSG_SIZE];      /* marshalled callmsg */
  72     u_int ct_mpos;              /* pos after marshal */
  73     XDR ct_xdrs;
  74   };
  75
  76 static int readunix (char *, char *, int);
  77 static int writeunix (char *, char *, int);
  78
  79 static enum clnt_stat clntunix_call (CLIENT *, u_long, xdrproc_t, caddr_t,
  80                                     xdrproc_t, caddr_t, struct timeval);
  81 static void clntunix_abort (void);
  82 static void clntunix_geterr (CLIENT *, struct rpc_err *);
  83 static bool_t clntunix_freeres (CLIENT *, xdrproc_t, caddr_t);
  84 static bool_t clntunix_control (CLIENT *, int, char *);
  85 static void clntunix_destroy (CLIENT *);
  86
  87 static const struct clnt_ops unix_ops =
  88 {
  89   clntunix_call,
  90   clntunix_abort,
  91   clntunix_geterr,
  92   clntunix_freeres,
  93   clntunix_destroy,
  94   clntunix_control
  95 };
  96
  97 /*
  98  * Create a client handle for a tcp/ip connection.
  99  * If *sockp<0, *sockp is set to a newly created TCP socket and it is
 100  * connected to raddr.  If *sockp non-negative then
 101  * raddr is ignored.  The rpc/tcp package does buffering
 102  * similar to stdio, so the client must pick send and receive buffer sizes,];
 103  * 0 => use the default.
 104  * If raddr->sin_port is 0, then a binder on the remote machine is
 105  * consulted for the right port number.
 106  * NB: *sockp is copied into a private area.
 107  * NB: It is the clients responsibility to close *sockp.
 108  * NB: The rpch->cl_auth is set null authentication.  Caller may wish to set this
 109  * something more useful.
 110  */
 111 CLIENT *
 112 clntunix_create (struct sockaddr_un *raddr, u_long prog, u_long vers,
 113                  int *sockp, u_int sendsz, u_int recvsz)
 114 {
 115   CLIENT *h;
 116   struct ct_data *ct = (struct ct_data *) mem_alloc (sizeof (*ct));
 117   struct rpc_msg call_msg;
 118   int len;
 119
 120   h = (CLIENT *) mem_alloc (sizeof (*h));
 121   if (h == NULL || ct == NULL)
 122     {
 123       struct rpc_createerr *ce = &get_rpc_createerr ();
 124       (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
 125       ce->cf_stat = RPC_SYSTEMERROR;
 126       ce->cf_error.re_errno = ENOMEM;
 127       goto fooy;
 128     }
 129
 130   /*
 131    * If no socket given, open one
 132    */
 133   if (*sockp < 0)
 134     {
 135       *sockp = __socket (AF_UNIX, SOCK_STREAM, 0);
 136       len = strlen (raddr->sun_path) + sizeof (raddr->sun_family) + 1;
 137       if (*sockp < 0
 138           || __connect (*sockp, (struct sockaddr *) raddr, len) < 0)
 139         {
 140           struct rpc_createerr *ce = &get_rpc_createerr ();
 141           ce->cf_stat = RPC_SYSTEMERROR;
 142           ce->cf_error.re_errno = errno;
 143           if (*sockp != -1)
 144             __close (*sockp);
 145           goto fooy;
 146         }
 147       ct->ct_closeit = TRUE;
 148     }
 149   else
 150     {
 151       ct->ct_closeit = FALSE;
 152     }
 153
 154   /*
 155    * Set up private data struct
 156    */
 157   ct->ct_sock = *sockp;
 158   ct->ct_wait.tv_usec = 0;
 159   ct->ct_waitset = FALSE;
 160   ct->ct_addr = *raddr;
 161
 162   /*
 163    * Initialize call message
 164    */
 165   call_msg.rm_xid = _create_xid ();
 166   call_msg.rm_direction = CALL;
 167   call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
 168   call_msg.rm_call.cb_prog = prog;
 169   call_msg.rm_call.cb_vers = vers;
 170
 171   /*
 172    * pre-serialize the static part of the call msg and stash it away
 173    */
 174   xdrmem_create (&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE, XDR_ENCODE);
 175   if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg))
 176     {
 177       if (ct->ct_closeit)
 178         __close (*sockp);
 179       goto fooy;
 180     }
 181   ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs));
 182   XDR_DESTROY (&(ct->ct_xdrs));
 183
 184   /*
 185    * Create a client handle which uses xdrrec for serialization
 186    * and authnone for authentication.
 187    */
 188   xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz,
 189                  (caddr_t) ct, readunix, writeunix);
 190   h->cl_ops = (struct clnt_ops *) &unix_ops;
 191   h->cl_private = (caddr_t) ct;
 192   h->cl_auth = authnone_create ();
 193   return h;
 194
 195 fooy:
 196   /*
 197    * Something goofed, free stuff and barf
 198    */
 199   mem_free ((caddr_t) ct, sizeof (struct ct_data));
 200   mem_free ((caddr_t) h, sizeof (CLIENT));
 201   return (CLIENT *) NULL;
 202 }
 203 libc_hidden_nolink (clntunix_create, GLIBC_2_1)
 204
 205 static enum clnt_stat
 206 clntunix_call (h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
 207      CLIENT *h;
 208      u_long proc;
 209      xdrproc_t xdr_args;
 210      caddr_t args_ptr;
 211      xdrproc_t xdr_results;
 212      caddr_t results_ptr;
 213      struct timeval timeout;
 214 {
 215   struct ct_data *ct = (struct ct_data *) h->cl_private;
 216   XDR *xdrs = &(ct->ct_xdrs);
 217   struct rpc_msg reply_msg;
 218   u_long x_id;
 219   u_int32_t *msg_x_id = (u_int32_t *) (ct->ct_mcall);   /* yuk */
 220   bool_t shipnow;
 221   int refreshes = 2;
 222
 223   if (!ct->ct_waitset)
 224     {
 225       ct->ct_wait = timeout;
 226     }
 227
 228   shipnow =
 229     (xdr_results == (xdrproc_t) 0 && ct->ct_wait.tv_sec == 0
 230      && ct->ct_wait.tv_usec == 0) ? FALSE : TRUE;
 231
 232 call_again:
 233   xdrs->x_op = XDR_ENCODE;
 234   ct->ct_error.re_status = RPC_SUCCESS;
 235   x_id = ntohl (--(*msg_x_id));
 236   if ((!XDR_PUTBYTES (xdrs, ct->ct_mcall, ct->ct_mpos)) ||
 237       (!XDR_PUTLONG (xdrs, (long *) &proc)) ||
 238       (!AUTH_MARSHALL (h->cl_auth, xdrs)) ||
 239       (!(*xdr_args) (xdrs, args_ptr)))
 240     {
 241       if (ct->ct_error.re_status == RPC_SUCCESS)
 242         ct->ct_error.re_status = RPC_CANTENCODEARGS;
 243       (void) xdrrec_endofrecord (xdrs, TRUE);
 244       return ct->ct_error.re_status;
 245     }
 246   if (!xdrrec_endofrecord (xdrs, shipnow))
 247     return ct->ct_error.re_status = RPC_CANTSEND;
 248   if (!shipnow)
 249     return RPC_SUCCESS;
 250   /*
 251    * Hack to provide rpc-based message passing
 252    */
 253   if (ct->ct_wait.tv_sec == 0 && ct->ct_wait.tv_usec == 0)
 254     return ct->ct_error.re_status = RPC_TIMEDOUT;
 255
 256
 257   /*
 258    * Keep receiving until we get a valid transaction id
 259    */
 260   xdrs->x_op = XDR_DECODE;
 261   while (TRUE)
 262     {
 263       reply_msg.acpted_rply.ar_verf = _null_auth;
 264       reply_msg.acpted_rply.ar_results.where = NULL;
 265       reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
 266       if (!xdrrec_skiprecord (xdrs))
 267         return ct->ct_error.re_status;
 268       /* now decode and validate the response header */
 269       if (!xdr_replymsg (xdrs, &reply_msg))
 270         {
 271           if (ct->ct_error.re_status == RPC_SUCCESS)
 272             continue;
 273           return ct->ct_error.re_status;
 274         }
 275       if (reply_msg.rm_xid == x_id)
 276         break;
 277     }
 278
 279   /*
 280    * process header
 281    */
 282   _seterr_reply (&reply_msg, &(ct->ct_error));
 283   if (ct->ct_error.re_status == RPC_SUCCESS)
 284     {
 285       if (!AUTH_VALIDATE (h->cl_auth, &reply_msg.acpted_rply.ar_verf))
 286         {
 287           ct->ct_error.re_status = RPC_AUTHERROR;
 288           ct->ct_error.re_why = AUTH_INVALIDRESP;
 289         }
 290       else if (!(*xdr_results) (xdrs, results_ptr))
 291         {
 292           if (ct->ct_error.re_status == RPC_SUCCESS)
 293             ct->ct_error.re_status = RPC_CANTDECODERES;
 294         }
 295       /* free verifier ... */
 296       if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
 297         {
 298           xdrs->x_op = XDR_FREE;
 299           (void) xdr_opaque_auth (xdrs, &(reply_msg.acpted_rply.ar_verf));
 300         }
 301     }                           /* end successful completion */
 302   else
 303     {
 304       /* maybe our credentials need to be refreshed ... */
 305       if (refreshes-- && AUTH_REFRESH (h->cl_auth))
 306         goto call_again;
 307     }                           /* end of unsuccessful completion */
 308   return ct->ct_error.re_status;
 309 }
 310
 311 static void
 312 clntunix_geterr (CLIENT *h, struct rpc_err *errp)
 313 {
 314   struct ct_data *ct = (struct ct_data *) h->cl_private;
 315
 316   *errp = ct->ct_error;
 317 }
 318
 319 static bool_t
 320 clntunix_freeres (cl, xdr_res, res_ptr)
 321      CLIENT *cl;
 322      xdrproc_t xdr_res;
 323      caddr_t res_ptr;
 324 {
 325   struct ct_data *ct = (struct ct_data *) cl->cl_private;
 326   XDR *xdrs = &(ct->ct_xdrs);
 327
 328   xdrs->x_op = XDR_FREE;
 329   return (*xdr_res) (xdrs, res_ptr);
 330 }
 331
 332 static void
 333 clntunix_abort ()
 334 {
 335 }
 336
 337 static bool_t
 338 clntunix_control (CLIENT *cl, int request, char *info)
 339 {
 340   struct ct_data *ct = (struct ct_data *) cl->cl_private;
 341
 342
 343   switch (request)
 344     {
 345     case CLSET_FD_CLOSE:
 346       ct->ct_closeit = TRUE;
 347       break;
 348     case CLSET_FD_NCLOSE:
 349       ct->ct_closeit = FALSE;
 350       break;
 351     case CLSET_TIMEOUT:
 352       ct->ct_wait = *(struct timeval *) info;
 353       break;
 354     case CLGET_TIMEOUT:
 355       *(struct timeval *) info = ct->ct_wait;
 356       break;
 357     case CLGET_SERVER_ADDR:
 358       *(struct sockaddr_un *) info = ct->ct_addr;
 359       break;
 360     case CLGET_FD:
 361       *(int *)info = ct->ct_sock;
 362       break;
 363     case CLGET_XID:
 364       /*
 365        * use the knowledge that xid is the
 366        * first element in the call structure *.
 367        * This will get the xid of the PREVIOUS call
 368        */
 369       *(u_long *) info = ntohl (*(u_long *)ct->ct_mcall);
 370       break;
 371     case CLSET_XID:
 372       /* This will set the xid of the NEXT call */
 373       *(u_long *) ct->ct_mcall =  htonl (*(u_long *)info - 1);
 374       /* decrement by 1 as clntunix_call() increments once */
 375       break;
 376     case CLGET_VERS:
 377       /*
 378        * This RELIES on the information that, in the call body,
 379        * the version number field is the fifth field from the
 380        * begining of the RPC header. MUST be changed if the
 381        * call_struct is changed
 382        */
 383       *(u_long *) info = ntohl (*(u_long *) (ct->ct_mcall
 384                                              + 4 * BYTES_PER_XDR_UNIT));
 385       break;
 386     case CLSET_VERS:
 387       *(u_long *) (ct->ct_mcall + 4 * BYTES_PER_XDR_UNIT)
 388         = htonl (*(u_long *) info);
 389       break;
 390     case CLGET_PROG:
 391       /*
 392        * This RELIES on the information that, in the call body,
 393        * the program number field is the  field from the
 394        * begining of the RPC header. MUST be changed if the
 395        * call_struct is changed
 396        */
 397       *(u_long *) info = ntohl (*(u_long *) (ct->ct_mcall
 398                                              + 3 * BYTES_PER_XDR_UNIT));
 399       break;
 400     case CLSET_PROG:
 401       *(u_long *) (ct->ct_mcall + 3 * BYTES_PER_XDR_UNIT)
 402         = htonl(*(u_long *) info);
 403       break;
 404     /* The following are only possible with TI-RPC */
 405     case CLGET_RETRY_TIMEOUT:
 406     case CLSET_RETRY_TIMEOUT:
 407     case CLGET_SVC_ADDR:
 408     case CLSET_SVC_ADDR:
 409     case CLSET_PUSH_TIMOD:
 410     case CLSET_POP_TIMOD:
 411     default:
 412       return FALSE;
 413     }
 414   return TRUE;
 415 }
 416
 417
 418 static void
 419 clntunix_destroy (CLIENT *h)
 420 {
 421   struct ct_data *ct =
 422   (struct ct_data *) h->cl_private;
 423
 424   if (ct->ct_closeit)
 425     {
 426       (void) __close (ct->ct_sock);
 427     }
 428   XDR_DESTROY (&(ct->ct_xdrs));
 429   mem_free ((caddr_t) ct, sizeof (struct ct_data));
 430   mem_free ((caddr_t) h, sizeof (CLIENT));
 431 }
 432
 433 static int
 434 __msgread (int sock, void *data, size_t cnt)
 435 {
 436   struct iovec iov;
 437   struct msghdr msg;
 438 #ifdef SCM_CREDENTIALS
 439   static char cm[CMSG_SPACE(sizeof (struct ucred))];
 440 #endif
 441   int len;
 442
 443   iov.iov_base = data;
 444   iov.iov_len = cnt;
 445
 446   msg.msg_iov = &iov;
 447   msg.msg_iovlen = 1;
 448   msg.msg_name = NULL;
 449   msg.msg_namelen = 0;
 450 #ifdef SCM_CREDENTIALS
 451   msg.msg_control = (caddr_t) &cm;
 452   msg.msg_controllen = CMSG_SPACE(sizeof (struct ucred));
 453 #endif
 454   msg.msg_flags = 0;
 455
 456 #ifdef SO_PASSCRED
 457   {
 458     int on = 1;
 459     if (__setsockopt (sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof (on)))
 460       return -1;
 461   }
 462 #endif
 463
 464  restart:
 465   len = __recvmsg (sock, &msg, 0);
 466   if (len >= 0)
 467     {
 468       if (msg.msg_flags & MSG_CTRUNC || len == 0)
 469         return 0;
 470       else
 471         return len;
 472     }
 473   if (errno == EINTR)
 474     goto restart;
 475   return -1;
 476 }
 477
 478 static int
 479 __msgwrite (int sock, void *data, size_t cnt)
 480 {
 481 #ifndef SCM_CREDENTIALS
 482   /* We cannot implement this reliably.  */
 483   __set_errno (ENOSYS);
 484   return -1;
 485 #else
 486   struct iovec iov;
 487   struct msghdr msg;
 488   struct cmsghdr *cmsg = alloca (CMSG_SPACE(sizeof (struct ucred)));
 489   struct ucred cred;
 490   int len;
 491
 492   /* XXX I'm not sure, if gete?id() is always correct, or if we should use
 493      get?id(). But since keyserv needs geteuid(), we have no other chance.
 494      It would be much better, if the kernel could pass both to the server. */
 495   cred.pid = __getpid ();
 496   cred.uid = __geteuid ();
 497   cred.gid = __getegid ();
 498
 499   memcpy (CMSG_DATA(cmsg), &cred, sizeof (struct ucred));
 500   cmsg->cmsg_level = SOL_SOCKET;
 501   cmsg->cmsg_type = SCM_CREDENTIALS;
 502   cmsg->cmsg_len = sizeof(*cmsg) + sizeof(struct ucred);
 503
 504   iov.iov_base = data;
 505   iov.iov_len = cnt;
 506
 507   msg.msg_iov = &iov;
 508   msg.msg_iovlen = 1;
 509   msg.msg_name = NULL;
 510   msg.msg_namelen = 0;
 511   msg.msg_control = cmsg;
 512   msg.msg_controllen = CMSG_ALIGN(cmsg->cmsg_len);
 513   msg.msg_flags = 0;
 514
 515  restart:
 516   len = __sendmsg (sock, &msg, 0);
 517   if (len >= 0)
 518     return len;
 519   if (errno == EINTR)
 520     goto restart;
 521   return -1;
 522
 523 #endif
 524 }
 525
 526
 527 /*
 528  * Interface between xdr serializer and unix connection.
 529  * Behaves like the system calls, read & write, but keeps some error state
 530  * around for the rpc level.
 531  */
 532 static int
 533 readunix (char *ctptr, char *buf, int len)
 534 {
 535   struct ct_data *ct = (struct ct_data *) ctptr;
 536   struct pollfd fd;
 537   int milliseconds = ((ct->ct_wait.tv_sec * 1000)
 538                       + (ct->ct_wait.tv_usec / 1000));
 539
 540   if (len == 0)
 541     return 0;
 542
 543   fd.fd = ct->ct_sock;
 544   fd.events = POLLIN;
 545   while (TRUE)
 546     {
 547       switch (__poll (&fd, 1, milliseconds))
 548         {
 549         case 0:
 550           ct->ct_error.re_status = RPC_TIMEDOUT;
 551           return -1;
 552
 553         case -1:
 554           if (errno == EINTR)
 555             continue;
 556           ct->ct_error.re_status = RPC_CANTRECV;
 557           ct->ct_error.re_errno = errno;
 558           return -1;
 559         }
 560       break;
 561     }
 562   switch (len = __msgread (ct->ct_sock, buf, len))
 563     {
 564
 565     case 0:
 566       /* premature eof */
 567       ct->ct_error.re_errno = ECONNRESET;
 568       ct->ct_error.re_status = RPC_CANTRECV;
 569       len = -1;                 /* it's really an error */
 570       break;
 571
 572     case -1:
 573       ct->ct_error.re_errno = errno;
 574       ct->ct_error.re_status = RPC_CANTRECV;
 575       break;
 576     }
 577   return len;
 578 }
 579
 580 static int
 581 writeunix (char *ctptr, char *buf, int len)
 582 {
 583   int i, cnt;
 584   struct ct_data *ct = (struct ct_data *) ctptr;
 585
 586   for (cnt = len; cnt > 0; cnt -= i, buf += i)
 587     {
 588       if ((i = __msgwrite (ct->ct_sock, buf, cnt)) == -1)
 589         {
 590           ct->ct_error.re_errno = errno;
 591           ct->ct_error.re_status = RPC_CANTSEND;
 592           return -1;
 593         }
 594     }
 595   return len;
 596 }