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
 299   iov[0].iov_base = buf;
 300   iov[0].iov_len = cnt;
 301
 302   msg.msg_iov = iov;
 303   msg.msg_iovlen = 1;
 304   msg.msg_name = NULL;
 305   msg.msg_namelen = 0;
 306   msg.msg_control = (caddr_t) &cm;
 307   msg.msg_controllen = sizeof (struct cmessage);
 308   msg.msg_flags = 0;
 309
 310 #ifdef SO_PASSCRED
 311   {
 312     int on = 1;
 313     if (setsockopt (sock, SOL_SOCKET, SO_PASSCRED, &on, sizeof (on)))
 314       return -1;
 315   }
 316 #endif
 317
 318   return recvmsg (sock, &msg, 0);
 319 }
 320
 321 static int
 322 __msgwrite (int sock, void *buf, size_t cnt)
 323 {
 324 #ifndef SCM_CREDENTIALS
 325   /* We cannot implement this reliably.  */
 326   __set_errno (ENOSYS);
 327   return -1;
 328 #else
 329   struct iovec iov[1];
 330   struct msghdr msg;
 331
 332   iov[0].iov_base = buf;
 333   iov[0].iov_len = cnt;
 334
 335   cm.cmsg.cmsg_type = SCM_CREDENTIALS;
 336   cm.cmsg.cmsg_level = SOL_SOCKET;
 337   cm.cmsg.cmsg_len = sizeof (struct cmessage);
 338   /* XXX I'm not sure, if we really should use gete?id(), or get?id().
 339      It would be much better, if the kernel could pass both to the
 340      client. */
 341   cm.cmcred.pid = __getpid ();
 342   cm.cmcred.uid = __geteuid ();
 343   cm.cmcred.gid = __getegid ();
 344
 345   msg.msg_iov = iov;
 346   msg.msg_iovlen = 1;
 347   msg.msg_name = NULL;
 348   msg.msg_namelen = 0;
 349   msg.msg_control = (caddr_t) &cm;
 350   msg.msg_controllen = sizeof (struct cmessage);
 351   msg.msg_flags = 0;
 352
 353   return sendmsg (sock, &msg, 0);
 354 #endif
 355 }
 356
 357 /*
 358  * reads data from the unix connection.
 359  * any error is fatal and the connection is closed.
 360  * (And a read of zero bytes is a half closed stream => error.)
 361  */
 362 static int
 363 readunix (char *xprtptr, char *buf, int len)
 364 {
 365   SVCXPRT *xprt = (SVCXPRT *) xprtptr;
 366   int sock = xprt->xp_sock;
 367   int milliseconds = 35 * 1000;
 368   struct pollfd pollfd;
 369
 370   do
 371     {
 372       pollfd.fd = sock;
 373       pollfd.events = POLLIN;
 374       switch (__poll (&pollfd, 1, milliseconds))
 375         {
 376         case -1:
 377           if (errno == EINTR)
 378             continue;
 379           /*FALLTHROUGH*/
 380         case 0:
 381           goto fatal_err;
 382         default:
 383           if ((pollfd.revents & POLLERR) || (pollfd.revents & POLLHUP)
 384               || (pollfd.revents & POLLNVAL))
 385             goto fatal_err;
 386           break;
 387         }
 388     }
 389   while ((pollfd.revents & POLLIN) == 0);
 390
 391   if ((len = __msgread (sock, buf, len)) > 0)
 392     return len;
 393
 394  fatal_err:
 395   ((struct unix_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
 396   return -1;
 397 }
 398
 399 /*
 400  * writes data to the unix connection.
 401  * Any error is fatal and the connection is closed.
 402  */
 403 static int
 404 writeunix (char *xprtptr, char * buf, int len)
 405 {
 406   SVCXPRT *xprt = (SVCXPRT *) xprtptr;
 407   int i, cnt;
 408
 409   for (cnt = len; cnt > 0; cnt -= i, buf += i)
 410     {
 411       if ((i = __msgwrite (xprt->xp_sock, buf, cnt)) < 0)
 412         {
 413           ((struct unix_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
 414           return -1;
 415         }
 416     }
 417   return len;
 418 }
 419
 420 static enum xprt_stat
 421 svcunix_stat (SVCXPRT *xprt)
 422 {
 423   struct unix_conn *cd =
 424   (struct unix_conn *) (xprt->xp_p1);
 425
 426   if (cd->strm_stat == XPRT_DIED)
 427     return XPRT_DIED;
 428   if (!xdrrec_eof (&(cd->xdrs)))
 429     return XPRT_MOREREQS;
 430   return XPRT_IDLE;
 431 }
 432
 433 static bool_t
 434 svcunix_recv (SVCXPRT *xprt, struct rpc_msg *msg)
 435 {
 436   struct unix_conn *cd = (struct unix_conn *) (xprt->xp_p1);
 437   XDR *xdrs = &(cd->xdrs);
 438
 439   xdrs->x_op = XDR_DECODE;
 440   xdrrec_skiprecord (xdrs);
 441   if (xdr_callmsg (xdrs, msg))
 442     {
 443       cd->x_id = msg->rm_xid;
 444       /* set up verifiers */
 445       msg->rm_call.cb_verf.oa_flavor = AUTH_UNIX;
 446       msg->rm_call.cb_verf.oa_base = (caddr_t) &cm;
 447       msg->rm_call.cb_verf.oa_length = sizeof (cm);
 448       return TRUE;
 449     }
 450   cd->strm_stat = XPRT_DIED;    /* XXXX */
 451   return FALSE;
 452 }
 453
 454 static bool_t
 455 svcunix_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 456 {
 457   return (*xdr_args) (&(((struct unix_conn *) (xprt->xp_p1))->xdrs),
 458                       args_ptr);
 459 }
 460
 461 static bool_t
 462 svcunix_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
 463 {
 464   XDR *xdrs = &(((struct unix_conn *) (xprt->xp_p1))->xdrs);
 465
 466   xdrs->x_op = XDR_FREE;
 467   return (*xdr_args) (xdrs, args_ptr);
 468 }
 469
 470 static bool_t
 471 svcunix_reply (SVCXPRT *xprt, struct rpc_msg *msg)
 472 {
 473   struct unix_conn *cd = (struct unix_conn *) (xprt->xp_p1);
 474   XDR *xdrs = &(cd->xdrs);
 475   bool_t stat;
 476
 477   xdrs->x_op = XDR_ENCODE;
 478   msg->rm_xid = cd->x_id;
 479   stat = xdr_replymsg (xdrs, msg);
 480   (void) xdrrec_endofrecord (xdrs, TRUE);
 481   return stat;
 482 }