sunrpc/clnt_tcp.c

   1 /*
   2  * clnt_tcp.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/poll.h>
  54 #include <sys/socket.h>
  55 #include <rpc/pmap_clnt.h>
  56 #ifdef USE_IN_LIBIO
  57 # include <wchar.h>
  58 #endif
  59
  60 extern u_long _create_xid (void);
  61
  62 #define MCALL_MSG_SIZE 24
  63
  64 struct ct_data
  65   {
  66     int ct_sock;
  67     bool_t ct_closeit;
  68     struct timeval ct_wait;
  69     bool_t ct_waitset;          /* wait set by clnt_control? */
  70     struct sockaddr_in ct_addr;
  71     struct rpc_err ct_error;
  72     char ct_mcall[MCALL_MSG_SIZE];      /* marshalled callmsg */
  73     u_int ct_mpos;              /* pos after marshal */
  74     XDR ct_xdrs;
  75   };
  76
  77 static int readtcp (char *, char *, int);
  78 static int writetcp (char *, char *, int);
  79
  80 static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
  81                                     xdrproc_t, caddr_t, struct timeval);
  82 static void clnttcp_abort (void);
  83 static void clnttcp_geterr (CLIENT *, struct rpc_err *);
  84 static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, caddr_t);
  85 static bool_t clnttcp_control (CLIENT *, int, char *);
  86 static void clnttcp_destroy (CLIENT *);
  87
  88 static const struct clnt_ops tcp_ops =
  89 {
  90   clnttcp_call,
  91   clnttcp_abort,
  92   clnttcp_geterr,
  93   clnttcp_freeres,
  94   clnttcp_destroy,
  95   clnttcp_control
  96 };
  97
  98 /*
  99  * Create a client handle for a tcp/ip connection.
 100  * If *sockp<0, *sockp is set to a newly created TCP socket and it is
 101  * connected to raddr.  If *sockp non-negative then
 102  * raddr is ignored.  The rpc/tcp package does buffering
 103  * similar to stdio, so the client must pick send and receive buffer sizes,];
 104  * 0 => use the default.
 105  * If raddr->sin_port is 0, then a binder on the remote machine is
 106  * consulted for the right port number.
 107  * NB: *sockp is copied into a private area.
 108  * NB: It is the clients responsibility to close *sockp.
 109  * NB: The rpch->cl_auth is set null authentication.  Caller may wish to set this
 110  * something more useful.
 111  */
 112 CLIENT *
 113 clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
 114                 int *sockp, u_int sendsz, u_int recvsz)
 115 {
 116   CLIENT *h;
 117   struct ct_data *ct;
 118   struct rpc_msg call_msg;
 119
 120   h = (CLIENT *) mem_alloc (sizeof (*h));
 121   ct = (struct ct_data *) mem_alloc (sizeof (*ct));
 122   if (h == NULL || ct == NULL)
 123     {
 124       struct rpc_createerr *ce = &get_rpc_createerr ();
 125       (void) __fxprintf (NULL, "%s: %s", __func__, _("out of memory\n"));
 126       ce->cf_stat = RPC_SYSTEMERROR;
 127       ce->cf_error.re_errno = ENOMEM;
 128       goto fooy;
 129     }
 130
 131   /*
 132    * If no port number given ask the pmap for one
 133    */
 134   if (raddr->sin_port == 0)
 135     {
 136       u_short port;
 137       if ((port = pmap_getport (raddr, prog, vers, IPPROTO_TCP)) == 0)
 138         {
 139           mem_free ((caddr_t) ct, sizeof (struct ct_data));
 140           mem_free ((caddr_t) h, sizeof (CLIENT));
 141           return ((CLIENT *) NULL);
 142         }
 143       raddr->sin_port = htons (port);
 144     }
 145
 146   /*
 147    * If no socket given, open one
 148    */
 149   if (*sockp < 0)
 150     {
 151       *sockp = __socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
 152       (void) bindresvport (*sockp, (struct sockaddr_in *) 0);
 153       if ((*sockp < 0)
 154           || (__connect (*sockp, (struct sockaddr *) raddr,
 155                          sizeof (*raddr)) < 0))
 156         {
 157           struct rpc_createerr *ce = &get_rpc_createerr ();
 158           ce->cf_stat = RPC_SYSTEMERROR;
 159           ce->cf_error.re_errno = errno;
 160           if (*sockp >= 0)
 161             (void) __close (*sockp);
 162           goto fooy;
 163         }
 164       ct->ct_closeit = TRUE;
 165     }
 166   else
 167     {
 168       ct->ct_closeit = FALSE;
 169     }
 170
 171   /*
 172    * Set up private data struct
 173    */
 174   ct->ct_sock = *sockp;
 175   ct->ct_wait.tv_usec = 0;
 176   ct->ct_waitset = FALSE;
 177   ct->ct_addr = *raddr;
 178
 179   /*
 180    * Initialize call message
 181    */
 182   call_msg.rm_xid = _create_xid ();
 183   call_msg.rm_direction = CALL;
 184   call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
 185   call_msg.rm_call.cb_prog = prog;
 186   call_msg.rm_call.cb_vers = vers;
 187
 188   /*
 189    * pre-serialize the static part of the call msg and stash it away
 190    */
 191   xdrmem_create (&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE, XDR_ENCODE);
 192   if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg))
 193     {
 194       if (ct->ct_closeit)
 195         {
 196           (void) __close (*sockp);
 197         }
 198       goto fooy;
 199     }
 200   ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs));
 201   XDR_DESTROY (&(ct->ct_xdrs));
 202
 203   /*
 204    * Create a client handle which uses xdrrec for serialization
 205    * and authnone for authentication.
 206    */
 207   xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz,
 208                  (caddr_t) ct, readtcp, writetcp);
 209   h->cl_ops = (struct clnt_ops *) &tcp_ops;
 210   h->cl_private = (caddr_t) ct;
 211   h->cl_auth = authnone_create ();
 212   return h;
 213
 214 fooy:
 215   /*
 216    * Something goofed, free stuff and barf
 217    */
 218   mem_free ((caddr_t) ct, sizeof (struct ct_data));
 219   mem_free ((caddr_t) h, sizeof (CLIENT));
 220   return ((CLIENT *) NULL);
 221 }
 222 #ifdef EXPORT_RPC_SYMBOLS
 223 libc_hidden_def (clnttcp_create)
 224 #else
 225 libc_hidden_nolink (clnttcp_create, GLIBC_2_0)
 226 #endif
 227
 228 static enum clnt_stat
 229 clnttcp_call (h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
 230      CLIENT *h;
 231      u_long proc;
 232      xdrproc_t xdr_args;
 233      caddr_t args_ptr;
 234      xdrproc_t xdr_results;
 235      caddr_t results_ptr;
 236      struct timeval timeout;
 237 {
 238   struct ct_data *ct = (struct ct_data *) h->cl_private;
 239   XDR *xdrs = &(ct->ct_xdrs);
 240   struct rpc_msg reply_msg;
 241   u_long x_id;
 242   u_int32_t *msg_x_id = (u_int32_t *) (ct->ct_mcall);   /* yuk */
 243   bool_t shipnow;
 244   int refreshes = 2;
 245
 246   if (!ct->ct_waitset)
 247     {
 248       ct->ct_wait = timeout;
 249     }
 250
 251   shipnow =
 252     (xdr_results == (xdrproc_t) 0 && ct->ct_wait.tv_sec == 0
 253      && ct->ct_wait.tv_usec == 0) ? FALSE : TRUE;
 254
 255 call_again:
 256   xdrs->x_op = XDR_ENCODE;
 257   ct->ct_error.re_status = RPC_SUCCESS;
 258   x_id = ntohl (--(*msg_x_id));
 259   if ((!XDR_PUTBYTES (xdrs, ct->ct_mcall, ct->ct_mpos)) ||
 260       (!XDR_PUTLONG (xdrs, (long *) &proc)) ||
 261       (!AUTH_MARSHALL (h->cl_auth, xdrs)) ||
 262       (!(*xdr_args) (xdrs, args_ptr)))
 263     {
 264       if (ct->ct_error.re_status == RPC_SUCCESS)
 265         ct->ct_error.re_status = RPC_CANTENCODEARGS;
 266       (void) xdrrec_endofrecord (xdrs, TRUE);
 267       return (ct->ct_error.re_status);
 268     }
 269   if (!xdrrec_endofrecord (xdrs, shipnow))
 270     return ct->ct_error.re_status = RPC_CANTSEND;
 271   if (!shipnow)
 272     return RPC_SUCCESS;
 273   /*
 274    * Hack to provide rpc-based message passing
 275    */
 276   if (ct->ct_wait.tv_sec == 0 && ct->ct_wait.tv_usec == 0)
 277     {
 278       return ct->ct_error.re_status = RPC_TIMEDOUT;
 279     }
 280
 281
 282   /*
 283    * Keep receiving until we get a valid transaction id
 284    */
 285   xdrs->x_op = XDR_DECODE;
 286   while (TRUE)
 287     {
 288       reply_msg.acpted_rply.ar_verf = _null_auth;
 289       reply_msg.acpted_rply.ar_results.where = NULL;
 290       reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
 291       if (!xdrrec_skiprecord (xdrs))
 292         return (ct->ct_error.re_status);
 293       /* now decode and validate the response header */
 294       if (!xdr_replymsg (xdrs, &reply_msg))
 295         {
 296           if (ct->ct_error.re_status == RPC_SUCCESS)
 297             continue;
 298           return ct->ct_error.re_status;
 299         }
 300       if ((u_int32_t) reply_msg.rm_xid == (u_int32_t) x_id)
 301         break;
 302     }
 303
 304   /*
 305    * process header
 306    */
 307   _seterr_reply (&reply_msg, &(ct->ct_error));
 308   if (ct->ct_error.re_status == RPC_SUCCESS)
 309     {
 310       if (!AUTH_VALIDATE (h->cl_auth, &reply_msg.acpted_rply.ar_verf))
 311         {
 312           ct->ct_error.re_status = RPC_AUTHERROR;
 313           ct->ct_error.re_why = AUTH_INVALIDRESP;
 314         }
 315       else if (!(*xdr_results) (xdrs, results_ptr))
 316         {
 317           if (ct->ct_error.re_status == RPC_SUCCESS)
 318             ct->ct_error.re_status = RPC_CANTDECODERES;
 319         }
 320       /* free verifier ... */
 321       if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
 322         {
 323           xdrs->x_op = XDR_FREE;
 324           (void) xdr_opaque_auth (xdrs, &(reply_msg.acpted_rply.ar_verf));
 325         }
 326     }                           /* end successful completion */
 327   else
 328     {
 329       /* maybe our credentials need to be refreshed ... */
 330       if (refreshes-- && AUTH_REFRESH (h->cl_auth))
 331         goto call_again;
 332     }                           /* end of unsuccessful completion */
 333   return ct->ct_error.re_status;
 334 }
 335
 336 static void
 337 clnttcp_geterr (h, errp)
 338      CLIENT *h;
 339      struct rpc_err *errp;
 340 {
 341   struct ct_data *ct =
 342   (struct ct_data *) h->cl_private;
 343
 344   *errp = ct->ct_error;
 345 }
 346
 347 static bool_t
 348 clnttcp_freeres (cl, xdr_res, res_ptr)
 349      CLIENT *cl;
 350      xdrproc_t xdr_res;
 351      caddr_t res_ptr;
 352 {
 353   struct ct_data *ct = (struct ct_data *) cl->cl_private;
 354   XDR *xdrs = &(ct->ct_xdrs);
 355
 356   xdrs->x_op = XDR_FREE;
 357   return (*xdr_res) (xdrs, res_ptr);
 358 }
 359
 360 static void
 361 clnttcp_abort ()
 362 {
 363 }
 364
 365 static bool_t
 366 clnttcp_control (CLIENT *cl, int request, char *info)
 367 {
 368   struct ct_data *ct = (struct ct_data *) cl->cl_private;
 369
 370
 371   switch (request)
 372     {
 373     case CLSET_FD_CLOSE:
 374       ct->ct_closeit = TRUE;
 375       break;
 376     case CLSET_FD_NCLOSE:
 377       ct->ct_closeit = FALSE;
 378       break;
 379     case CLSET_TIMEOUT:
 380       ct->ct_wait = *(struct timeval *) info;
 381       ct->ct_waitset = TRUE;
 382       break;
 383     case CLGET_TIMEOUT:
 384       *(struct timeval *) info = ct->ct_wait;
 385       break;
 386     case CLGET_SERVER_ADDR:
 387       *(struct sockaddr_in *) info = ct->ct_addr;
 388       break;
 389     case CLGET_FD:
 390       *(int *)info = ct->ct_sock;
 391       break;
 392     case CLGET_XID:
 393       /*
 394        * use the knowledge that xid is the
 395        * first element in the call structure *.
 396        * This will get the xid of the PREVIOUS call
 397        */
 398       *(u_long *)info = ntohl (*(u_long *)ct->ct_mcall);
 399       break;
 400     case CLSET_XID:
 401       /* This will set the xid of the NEXT call */
 402       *(u_long *)ct->ct_mcall =  htonl (*(u_long *)info - 1);
 403       /* decrement by 1 as clnttcp_call() increments once */
 404       break;
 405     case CLGET_VERS:
 406       /*
 407        * This RELIES on the information that, in the call body,
 408        * the version number field is the fifth field from the
 409        * begining of the RPC header. MUST be changed if the
 410        * call_struct is changed
 411        */
 412       *(u_long *)info = ntohl (*(u_long *)(ct->ct_mcall +
 413                                            4 * BYTES_PER_XDR_UNIT));
 414       break;
 415     case CLSET_VERS:
 416       *(u_long *)(ct->ct_mcall + 4 * BYTES_PER_XDR_UNIT)
 417         = htonl (*(u_long *)info);
 418       break;
 419     case CLGET_PROG:
 420       /*
 421        * This RELIES on the information that, in the call body,
 422        * the program number field is the  field from the
 423        * begining of the RPC header. MUST be changed if the
 424        * call_struct is changed
 425        */
 426       *(u_long *)info = ntohl(*(u_long *)(ct->ct_mcall +
 427                                           3 * BYTES_PER_XDR_UNIT));
 428       break;
 429     case CLSET_PROG:
 430       *(u_long *)(ct->ct_mcall + 3 * BYTES_PER_XDR_UNIT)
 431         = htonl(*(u_long *)info);
 432       break;
 433     /* The following are only possible with TI-RPC */
 434     case CLGET_RETRY_TIMEOUT:
 435     case CLSET_RETRY_TIMEOUT:
 436     case CLGET_SVC_ADDR:
 437     case CLSET_SVC_ADDR:
 438     case CLSET_PUSH_TIMOD:
 439     case CLSET_POP_TIMOD:
 440     default:
 441       return FALSE;
 442     }
 443   return TRUE;
 444 }
 445
 446
 447 static void
 448 clnttcp_destroy (CLIENT *h)
 449 {
 450   struct ct_data *ct =
 451   (struct ct_data *) h->cl_private;
 452
 453   if (ct->ct_closeit)
 454     {
 455       (void) __close (ct->ct_sock);
 456     }
 457   XDR_DESTROY (&(ct->ct_xdrs));
 458   mem_free ((caddr_t) ct, sizeof (struct ct_data));
 459   mem_free ((caddr_t) h, sizeof (CLIENT));
 460 }
 461
 462 /*
 463  * Interface between xdr serializer and tcp connection.
 464  * Behaves like the system calls, read & write, but keeps some error state
 465  * around for the rpc level.
 466  */
 467 static int
 468 readtcp (char *ctptr, char *buf, int len)
 469 {
 470   struct ct_data *ct = (struct ct_data *)ctptr;
 471   struct pollfd fd;
 472   int milliseconds = (ct->ct_wait.tv_sec * 1000) +
 473     (ct->ct_wait.tv_usec / 1000);
 474
 475   if (len == 0)
 476     return 0;
 477
 478   fd.fd = ct->ct_sock;
 479   fd.events = POLLIN;
 480   while (TRUE)
 481     {
 482       switch (__poll(&fd, 1, milliseconds))
 483         {
 484         case 0:
 485           ct->ct_error.re_status = RPC_TIMEDOUT;
 486           return -1;
 487
 488         case -1:
 489           if (errno == EINTR)
 490             continue;
 491           ct->ct_error.re_status = RPC_CANTRECV;
 492           ct->ct_error.re_errno = errno;
 493           return -1;
 494         }
 495       break;
 496     }
 497   switch (len = __read (ct->ct_sock, buf, len))
 498     {
 499
 500     case 0:
 501       /* premature eof */
 502       ct->ct_error.re_errno = ECONNRESET;
 503       ct->ct_error.re_status = RPC_CANTRECV;
 504       len = -1;                 /* it's really an error */
 505       break;
 506
 507     case -1:
 508       ct->ct_error.re_errno = errno;
 509       ct->ct_error.re_status = RPC_CANTRECV;
 510       break;
 511     }
 512   return len;
 513 }
 514
 515 static int
 516 writetcp (char *ctptr, char *buf, int len)
 517 {
 518   int i, cnt;
 519   struct ct_data *ct = (struct ct_data*)ctptr;
 520
 521   for (cnt = len; cnt > 0; cnt -= i, buf += i)
 522     {
 523       if ((i = __write (ct->ct_sock, buf, cnt)) == -1)
 524         {
 525           ct->ct_error.re_errno = errno;
 526           ct->ct_error.re_status = RPC_CANTSEND;
 527           return -1;
 528         }
 529     }
 530   return len;
 531 }