sunrpc/svc_unix.c

   1 /*
   2  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   3  * unrestricted use provided that this legend is included on all tape
   4  * media and as a part of the software program in whole or part.  Users
   5  * may copy or modify Sun RPC without charge, but are not authorized
   6  * to license or distribute it to anyone else except as part of a product or
   7  * program developed by the user.
   8  *
   9  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  10  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  11  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  12  *
  13  * Sun RPC is provided with no support and without any obligation on the
  14  * part of Sun Microsystems, Inc. to assist in its use, correction,
  15  * modification or enhancement.
  16  *
  17  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  18  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  19  * OR ANY PART THEREOF.
  20  *
  21  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  22  * or profits or other special, indirect and consequential damages, even if
  23  * Sun has been advised of the possibility of such damages.
  24  *
  25  * Sun Microsystems, Inc.
  26  * 2550 Garcia Avenue
  27  * Mountain View, California  94043
  28  */
  29
  30 /*
  31  * svc_unix.c, Server side for TCP/IP based RPC.
  32  *
  33  * Copyright (C) 1984, Sun Microsystems, Inc.
  34  *
  35  * Actually implements two flavors of transporter -
  36  * a unix rendezvouser (a listener and connection establisher)
  37  * and a record/unix stream.
  38  */
  39
  40 #include <stdio.h>
  41 #include <unistd.h>
  42 #include <string.h>
  43 #include <rpc/rpc.h>
  44 #include <sys/socket.h>
  45 #include <sys/uio.h>
  46 #include <sys/poll.h>
  47 #include <errno.h>
  48 #include <stdlib.h>
  49
  50 /*
  51  * Ops vector for AF_UNIX based rpc service handle
  52  */
  53 static bool_t svcunix_recv (SVCXPRT *, struct rpc_msg *);
  54 static enum xprt_stat svcunix_stat (SVCXPRT *);
  55 static bool_t svcunix_getargs (SVCXPRT *, xdrproc_t, caddr_t);
  56 static bool_t svcunix_reply (SVCXPRT *, struct rpc_msg *);
  57 static bool_t svcunix_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
  58 static void svcunix_destroy (SVCXPRT *);
  59
  60 static const struct xp_ops svcunix_op =
  61 {
  62   svcunix_recv,
  63   svcunix_stat,
  64   svcunix_getargs,
  65   svcunix_reply,
  66   svcunix_freeargs,
  67   svcunix_destroy
  68 };
  69
  70 /*
  71  * Ops vector for AF_UNIX rendezvous handler
  72  */
  73 static bool_t rendezvous_request (SVCXPRT *, struct rpc_msg *);
  74 static enum xprt_stat rendezvous_stat (SVCXPRT *);
  75
  76 static const struct xp_ops svcunix_rendezvous_op =
  77 {
  78   rendezvous_request,
  79   rendezvous_stat,
  80   (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) abort,
  81   (bool_t (*) (SVCXPRT *, struct rpc_msg *)) abort,
  82   (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) abort,
  83   svcunix_destroy
  84 };
  85
  86 static int readunix (char*, char *, int);
  87 static int writeunix (char *, char *, int);
  88 static SVCXPRT *makefd_xprt (int, u_int, u_int) internal_function;
  89
  90 struct unix_rendezvous {        /* kept in xprt->xp_p1 */
  91   u_int sendsize;
  92   u_int recvsize;
  93 };
  94
  95 struct unix_conn {              /* kept in xprt->xp_p1 */
  96   enum xprt_stat strm_stat;
  97   u_long x_id;
  98   XDR xdrs;
  99   char verf_body[MAX_AUTH_BYTES];
 100 };
 101
 102 /*
 103  * Usage:
 104  *      xprt = svcunix_create(sock, send_buf_size, recv_buf_size);
 105  *
 106  * Creates, registers, and returns a (rpc) unix based transporter.
 107  * Once *xprt is initialized, it is registered as a transporter
 108  * see (svc.h, xprt_register).  This routine returns
 109  * a NULL if a problem occurred.
 110  *
 111  * If sock<0 then a socket is created, else sock is used.
 112  * If the socket, sock is not bound to a port then svcunix_create
 113  * binds it to an arbitrary port.  The routine then starts a unix
 114  * listener on the socket's associated port.  In any (successful) case,
 115  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
 116  * associated port number.
 117  *
 118  * Since unix streams do buffered io similar to stdio, the caller can specify
 119  * how big the send and receive buffers are via the second and third parms;
 120  * 0 => use the system default.
 121  */
 122 SVCXPRT *
 123 svcunix_create (int sock, u_int sendsize, u_int recvsize, char *path)
 124 {
 125   bool_t madesock = FALSE;
 126   SVCXPRT *xprt;
 127   struct unix_rendezvous *r;
 128   struct sockaddr_un addr;
 129   socklen_t len = sizeof (struct sockaddr_in);
 130
 131   if (sock == RPC_ANYSOCK)
 132     {
 133       if ((sock = __socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
 134         {
 135           perror (_("svc_unix.c - AF_UNIX socket creation problem"));
 136           return (SVCXPRT *) NULL;
 137         }
 138       madesock = TRUE;
 139     }
 140   memset (&addr, '\0', sizeof (addr));
 141   addr.sun_family = AF_UNIX;
 142   len = strlen (path) + 1;
 143   memcpy (addr.sun_path, path, len);
 144   len += sizeof (addr.sun_family);
 145
 146   bind (sock, (struct sockaddr *) &addr, len);
 147
 148   if (getsockname (sock, (struct sockaddr *) &addr, &len) != 0
 149       || listen (sock, 2) != 0)
 150     {
 151       perror (_("svc_unix.c - cannot getsockname or listen"));
 152       if (madesock)
 153         __close (sock);
 154       return (SVCXPRT *) NULL;
 155     }
 156
 157   r = (struct unix_rendezvous *) mem_alloc (sizeof (*r));
 158   if (r == NULL)
 159     {
 160       fputs (_("svcunix_create: out of memory\n"), stderr);
 161       return NULL;
 162     }
 163   r->sendsize = sendsize;
 164   r->recvsize = recvsize;
 165   xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
 166   if (xprt == NULL)
 167     {
 168       fputs (_("svcunix_create: out of memory\n"), stderr);
 169       return NULL;
 170     }
 171   xprt->xp_p2 = NULL;
 172   xprt->xp_p1 = (caddr_t) r;
 173   xprt->xp_verf = _null_auth;
 174   xprt->xp_ops = &svcunix_rendezvous_op;
 175   xprt->xp_port = -1;
 176   xprt->xp_sock = sock;
 177   xprt_register (xprt);
 178   return xprt;
 179 }
 180
 181 /*
 182  * Like svunix_create(), except the routine takes any *open* UNIX file
 183  * descriptor as its first input.
 184  */
 185 SVCXPRT *
 186 svcunixfd_create (int fd, u_int sendsize, u_int recvsize)
 187 {
 188   return makefd_xprt (fd, sendsize, recvsize);
 189 }
 190
 191 static SVCXPRT *
 192 internal_function
 193 makefd_xprt (int fd, u_int sendsize, u_int recvsize)
 194 {
 195   SVCXPRT *xprt;
 196   struct unix_conn *cd;
 197
 198   xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
 199   if (xprt == (SVCXPRT *) NULL)
 200     {
 201       (void) fputs (_("svc_unix: makefd_xprt: out of memory\n"), stderr);
 202       goto done;
 203     }
 204   cd = (struct unix_conn *) mem_alloc (sizeof (struct unix_conn));
 205   if (cd == (struct unix_conn *) NULL)
 206     {
 207       (void) fputs (_("svc_unix: makefd_xprt: out of memory\n"), stderr);
 208       mem_free ((char *) xprt, sizeof (SVCXPRT));
 209       xprt = (SVCXPRT *) NULL;
 210       goto done;
 211     }
 212   cd->strm_stat = XPRT_IDLE;
 213   xdrrec_create (&(cd->xdrs), sendsize, recvsize,
 214                  (caddr_t) xprt, readunix, writeunix);
 215   xprt->xp_p2 = NULL;
 216   xprt->xp_p1 = (caddr_t) cd;
 217   xprt->xp_verf.oa_base = cd->verf_body;
 218   xprt->xp_addrlen = 0;
 219   xprt->xp_ops = &svcunix_op;   /* truly deals with calls */
 220   xprt->xp_port = 0;            /* this is a connection, not a rendezvouser */
 221   xprt->xp_sock = fd;
 222   xprt_register (xprt);
 223 done:
 224   return xprt;
 225 }
 226
 227 static bool_t
 228 rendezvous_request (SVCXPRT *xprt, struct rpc_msg *errmsg)
 229 {
 230   int sock;
 231   struct unix_rendezvous *r;
 232   struct sockaddr_un addr;
 233   struct sockaddr_in in_addr;
 234   socklen_t len;
 235
 236   r = (struct unix_rendezvous *) xprt->xp_p1;
 237 again:
 238   len = sizeof (struct sockaddr_un);
 239   if ((sock = accept (xprt->xp_sock, (struct sockaddr *) &addr, &len)) < 0)
 240     {
 241       if (errno == EINTR)
 242         goto again;
 243       return FALSE;
 244     }
 245   /*
 246    * make a new transporter (re-uses xprt)
 247    */
 248   memset (&in_addr, '\0', sizeof (in_addr));
 249   in_addr.sin_family = AF_UNIX;
 250   xprt = makefd_xprt (sock, r->sendsize, r->recvsize);
 251   xprt->xp_raddr = in_addr;
 252   xprt->xp_addrlen = len;
 253   return FALSE;         /* there is never an rpc msg to be processed */
 254 }
 255
 256 static enum xprt_stat
 257 rendezvous_stat (SVCXPRT *xprt)
 258 {
 259   return XPRT_IDLE;
 260 }
 261
 262 static void
 263 svcunix_destroy (SVCXPRT *xprt)
 264 {
 265   struct unix_conn *cd = (struct unix_conn *) xprt->xp_p1;
 266
 267   xprt_unregister (xprt);
 268   __close (xprt->xp_sock);
 269   if (xprt->xp_port != 0)
 270     {
 271       /* a rendezvouser socket */
 272       xprt->xp_port = 0;
 273     }
 274   else
 275     {
 276       /* an actual connection socket */
 277       XDR_DESTROY (&(cd->xdrs));
 278     }
 279   mem_free ((caddr_t) cd, sizeof (struct unix_conn));
 280   mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
 281 }
 282
 283 struct cmessage {
 284   struct cmsghdr cmsg;
 285   struct ucred cmcred;
 286 };
 287
 288 /* XXX This is not thread safe, but since the main functions in svc.c
 289    and the rpcgen generated *_svc functions for the daemon are also not
 290    thread safe and uses static global variables, it doesn't matter. */
 291 static struct cmessage cm;
 292
 293 static int
 294 __msgread (int sock, void *buf, size_t cnt)
 295 {
 296   struct iovec iov[1];
 297   struct msghdr msg;
 298   int on = 1;
 299
 300   iov[0].iov_base = buf;
 301   iov[0].iov_len = cnt;
 302
 303   msg.msg_iov = iov;
 304   msg.msg_iovlen = 1;
 305   msg.msg_name = NULL;
 306   msg.msg_namelen = 0;
 307   msg.msg_control = (caddr_t) &cm;
 308   msg.msg_controllen = sizeof (struct cmessage);
 309   msg.msg_flags = 0;
 310
 311 #ifdef SO_PASSCRED
 312   if (setsockopt (sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof (on)))
 313     return -1;
 314 #endif
 315
 316   return recvmsg (sock, &msg, 0);
 317 }
 318
 319 static int
 320 __msgwrite (int sock, void *buf, size_t cnt)
 321 {
 322 #ifndef SCM_CREDENTIALS
 323   /* We cannot implement this reliably.  */
 324   __set_errno (ENOSYS);
 325   return -1;
 326 #else
 327   struct iovec iov[1];
 328   struct msghdr msg;
 329
 330   iov[0].iov_base = buf;
 331   iov[0].iov_len = cnt;
 332
 333   cm.cmsg.cmsg_type = SCM_CREDENTIALS;
 334   cm.cmsg.cmsg_level = SOL_SOCKET;
 335   cm.cmsg.cmsg_len = sizeof (struct cmessage);
 336   /* XXX I'm not sure, if we really should use gete?id(), or get?id().
 337      It would be much better, if the kernel could pass both to the
 338      client. */
 339   cm.cmcred.pid = __getpid ();
 340   cm.cmcred.uid = __geteuid ();
 341   cm.cmcred.gid = __getegid ();
 342
 343   msg.msg_iov = iov;
 344   msg.msg_iovlen = 1;
 345   msg.msg_name = NULL;
 346   msg.msg_namelen = 0;
 347   msg.msg_control = (caddr_t) &cm;
 348   msg.msg_controllen = sizeof (struct cmessage);
 349   msg.msg_flags = 0;
 350
 351   return sendmsg (sock, &msg, 0);
 352 #endif
 353 }
 354
 355 /*
 356  * reads data from the unix connection.
 357  * any error is fatal and the connection is closed.
 358  * (And a read of zero bytes is a half closed stream => error.)
 359  */
 360 static int
 361 readunix (char *xprtptr, char *buf, int len)
 362 {
 363   SVCXPRT *xprt = (SVCXPRT *) xprtptr;
 364   int sock = xprt->xp_sock;
 365   int milliseconds = 35 * 1000;
 366   struct pollfd pollfd;
 367
 368   do
 369     {
 370       pollfd.fd = sock;
 371       pollfd.events = POLLIN;
 372       switch (__poll (&pollfd, 1, milliseconds))
 373         {
 374         case -1:
 375           if (errno == EINTR)
 376             continue;
 377           /*FALLTHROUGH*/
 378         case 0:
 379           goto fatal_err;
 380         default:
 381           if ((pollfd.revents & POLLERR) || (pollfd.revents & POLLHUP)
 382               || (pollfd.revents & POLLNVAL))
 383             goto fatal_err;
 384           break;
 385         }
 386     }
 387   while ((pollfd.revents & POLLIN) == 0);
 388
 389   if ((len = __msgread (sock, buf, len)) > 0)
 390     return len;
 391
 392  fatal_err:
 393   ((struct unix_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
 394   return -1;
 395 }
 396
 397 /*
 398  * writes data to the unix connection.
 399  * Any error is fatal and the connection is closed.
 400  */
 401 static int
 402 writeunix (char *xprtptr, char * buf, int len)
 403 {
 404   SVCXPRT *xprt = (SVCXPRT *) xprtptr;
 405   int i, cnt;
 406
 407   for (cnt = len; cnt > 0; cnt -= i, buf += i)
 408     {
 409       if ((i = __msgwrite (xprt->xp_sock, buf, cnt)) < 0)
 410         {
 411           ((struct unix_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
 412           return -1;
 413         }
 414     }
 415   return len;
 416 }
 417
 418 static enum xprt_stat
 419 svcunix_stat (SVCXPRT *xprt)
 420 {
 421   struct unix_conn *cd =
 422   (struct unix_conn *) (xprt->xp_p1);
 423
 424   if (cd->strm_stat == XPRT_DIED)
 425     return XPRT_DIED;
 426   if (!xdrrec_eof (&(cd->xdrs)))
 427     return XPRT_MOREREQS;
 428   return XPRT_IDLE;
 429 }
 430
 431 static bool_t
 432 svcunix_recv (SVCXPRT *xprt, struct rpc_msg *msg)
 433 {
 434   struct unix_conn *cd = (struct unix_conn *) (xprt->xp_p1);
 435   XDR *xdrs = &(cd->xdrs);
 436
 437   xdrs->x_op = XDR_DECODE;
 438   xdrrec_skiprecord (xdrs);
 439   if (xdr_callmsg (xdrs, msg))
 440     {
 441       cd->x_id = msg->rm_xid;
 442       /* set up verifiers */
 443       msg->rm_call.cb_verf.oa_flavor = AUTH_UNIX;
 444       msg->rm_call.cb_verf.oa_base = (caddr_t) &cm;
 445       msg->rm_call.cb_verf.oa_length = sizeof (cm);
 446       return TRUE;
 447     }
 448   cd->strm_stat = XPRT_DIED;    /* XXXX */
 449   return FALSE;
 450 }
 451
 452 static bool_t
 453 svcunix_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 454 {
 455   return (*xdr_args) (&(((struct unix_conn *) (xprt->xp_p1))->xdrs),
 456                       args_ptr);
 457 }
 458
 459 static bool_t
 460 svcunix_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 461 {
 462   XDR *xdrs = &(((struct unix_conn *) (xprt->xp_p1))->xdrs);
 463
 464   xdrs->x_op = XDR_FREE;
 465   return (*xdr_args) (xdrs, args_ptr);
 466 }
 467
 468 static bool_t
 469 svcunix_reply (SVCXPRT *xprt, struct rpc_msg *msg)
 470 {
 471   struct unix_conn *cd = (struct unix_conn *) (xprt->xp_p1);
 472   XDR *xdrs = &(cd->xdrs);
 473   bool_t stat;
 474
 475   xdrs->x_op = XDR_ENCODE;
 476   msg->rm_xid = cd->x_id;
 477   stat = xdr_replymsg (xdrs, msg);
 478   (void) xdrrec_endofrecord (xdrs, TRUE);
 479   return stat;
 480 }