lib/libc/rpc/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 #if defined(LIBC_SCCS) && !defined(lint)
  31 /*static char *sccsid = "from: @(#)svc_unix.c 1.21 87/08/11 Copyr 1984 Sun Micro";*/
  32 /*static char *sccsid = "from: @(#)svc_unix.c   2.2 88/08/01 4.0 RPCSRC";*/
  33 static char *rcsid = "$FreeBSD: src/lib/libc/rpc/svc_unix.c,v 1.7.2.2 2001/09/05 22:29:23 dec Exp $";
  34 #endif
  35
  36 /*
  37  * svc_unix.c, Server side for TCP/IP based RPC.
  38  *
  39  * Copyright (C) 1984, Sun Microsystems, Inc.
  40  *
  41  * Actually implements two flavors of transporter -
  42  * a unix rendezvouser (a listner and connection establisher)
  43  * and a record/unix stream.
  44  */
  45
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <unistd.h>
  49 #include <string.h>
  50 #include <rpc/rpc.h>
  51 #include <sys/socket.h>
  52 #include <sys/un.h>
  53 #include <sys/uio.h>
  54 #include <errno.h>
  55
  56 /*
  57  * Ops vector for AF_UNIX based rpc service handle
  58  */
  59 static bool_t           svcunix_recv();
  60 static enum xprt_stat   svcunix_stat();
  61 static bool_t           svcunix_getargs();
  62 static bool_t           svcunix_reply();
  63 static bool_t           svcunix_freeargs();
  64 static void             svcunix_destroy();
  65
  66 static struct xp_ops svcunix_op = {
  67         svcunix_recv,
  68         svcunix_stat,
  69         svcunix_getargs,
  70         svcunix_reply,
  71         svcunix_freeargs,
  72         svcunix_destroy
  73 };
  74
  75 /*
  76  * Ops vector for TCP/IP rendezvous handler
  77  */
  78 static bool_t           rendezvous_request();
  79 static enum xprt_stat   rendezvous_stat();
  80
  81 static struct xp_ops svcunix_rendezvous_op = {
  82         rendezvous_request,
  83         rendezvous_stat,
  84         (bool_t (*)())abort,
  85         (bool_t (*)())abort,
  86         (bool_t (*)())abort,
  87         svcunix_destroy
  88 };
  89
  90 static int readunix(), writeunix();
  91 static SVCXPRT *makefd_xprt();
  92
  93 struct unix_rendezvous { /* kept in xprt->xp_p1 */
  94         u_int sendsize;
  95         u_int recvsize;
  96 };
  97
  98 struct unix_conn {  /* kept in xprt->xp_p1 */
  99         enum xprt_stat strm_stat;
 100         u_long x_id;
 101         XDR xdrs;
 102         char verf_body[MAX_AUTH_BYTES];
 103 };
 104
 105
 106 struct cmessage {
 107         struct cmsghdr cmsg;
 108         struct cmsgcred cmcred;
 109 };
 110
 111 static struct cmessage cm;
 112
 113 static int __msgread(sock, buf, cnt)
 114         int sock;
 115         void *buf;
 116         size_t cnt;
 117 {
 118         struct iovec iov[1];
 119         struct msghdr msg;
 120
 121         bzero((char *)&cm, sizeof(cm));
 122         iov[0].iov_base = buf;
 123         iov[0].iov_len = cnt;
 124
 125         msg.msg_iov = iov;
 126         msg.msg_iovlen = 1;
 127         msg.msg_name = NULL;
 128         msg.msg_namelen = 0;
 129         msg.msg_control = (caddr_t)&cm;
 130         msg.msg_controllen = sizeof(struct cmessage);
 131         msg.msg_flags = 0;
 132
 133         return(recvmsg(sock, &msg, 0));
 134 }
 135
 136 static int __msgwrite(sock, buf, cnt)
 137         int sock;
 138         void *buf;
 139         size_t cnt;
 140 {
 141         struct iovec iov[1];
 142         struct msghdr msg;
 143
 144         bzero((char *)&cm, sizeof(cm));
 145         iov[0].iov_base = buf;
 146         iov[0].iov_len = cnt;
 147
 148         cm.cmsg.cmsg_type = SCM_CREDS;
 149         cm.cmsg.cmsg_level = SOL_SOCKET;
 150         cm.cmsg.cmsg_len = sizeof(struct cmessage);
 151
 152         msg.msg_iov = iov;
 153         msg.msg_iovlen = 1;
 154         msg.msg_name = NULL;
 155         msg.msg_namelen = 0;
 156         msg.msg_control = (caddr_t)&cm;
 157         msg.msg_controllen = sizeof(struct cmessage);
 158         msg.msg_flags = 0;
 159
 160         return(sendmsg(sock, &msg, 0));
 161 }
 162
 163 /*
 164  * Usage:
 165  *      xprt = svcunix_create(sock, send_buf_size, recv_buf_size);
 166  *
 167  * Creates, registers, and returns a (rpc) unix based transporter.
 168  * Once *xprt is initialized, it is registered as a transporter
 169  * see (svc.h, xprt_register).  This routine returns
 170  * a NULL if a problem occurred.
 171  *
 172  * If sock<0 then a socket is created, else sock is used.
 173  * If the socket, sock is not bound to a port then svcunix_create
 174  * binds it to an arbitrary port.  The routine then starts a unix
 175  * listener on the socket's associated port.  In any (successful) case,
 176  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
 177  * associated port number.
 178  *
 179  * Since unix streams do buffered io similar to stdio, the caller can specify
 180  * how big the send and receive buffers are via the second and third parms;
 181  * 0 => use the system default.
 182  */
 183 SVCXPRT *
 184 svcunix_create(sock, sendsize, recvsize, path)
 185         register int sock;
 186         u_int sendsize;
 187         u_int recvsize;
 188         char *path;
 189 {
 190         bool_t madesock = FALSE;
 191         register SVCXPRT *xprt;
 192         register struct unix_rendezvous *r;
 193         struct sockaddr_un addr;
 194         int len = sizeof(struct sockaddr_un);
 195
 196         if (sock == RPC_ANYSOCK) {
 197                 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 198                         perror("svc_unix.c - AF_UNIX socket creation problem");
 199                         return ((SVCXPRT *)NULL);
 200                 }
 201                 madesock = TRUE;
 202         }
 203         memset(&addr, 0, sizeof (addr));
 204         addr.sun_family = AF_UNIX;
 205         strcpy(addr.sun_path, path);
 206         len = strlen(addr.sun_path) + sizeof(addr.sun_family) +
 207                 sizeof(addr.sun_len) + 1;
 208         addr.sun_len = len;
 209
 210         bind(sock, (struct sockaddr *)&addr, len);
 211
 212         if ((getsockname(sock, (struct sockaddr *)&addr, &len) != 0)  ||
 213             (listen(sock, 2) != 0)) {
 214                 perror("svc_unix.c - cannot getsockname or listen");
 215                 if (madesock)
 216                        (void)_close(sock);
 217                 return ((SVCXPRT *)NULL);
 218         }
 219         r = (struct unix_rendezvous *)mem_alloc(sizeof(*r));
 220         if (r == NULL) {
 221                 (void) fprintf(stderr, "svcunix_create: out of memory\n");
 222                 return (NULL);
 223         }
 224         r->sendsize = sendsize;
 225         r->recvsize = recvsize;
 226         xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
 227         if (xprt == NULL) {
 228                 (void) fprintf(stderr, "svcunix_create: out of memory\n");
 229                 return (NULL);
 230         }
 231         xprt->xp_p2 = NULL;
 232         xprt->xp_p1 = (caddr_t)r;
 233         xprt->xp_verf = _null_auth;
 234         xprt->xp_ops = &svcunix_rendezvous_op;
 235         xprt->xp_port = -1 /*ntohs(addr.sin_port)*/;
 236         xprt->xp_sock = sock;
 237         xprt_register(xprt);
 238         return (xprt);
 239 }
 240
 241 /*
 242  * Like svunix_create(), except the routine takes any *open* UNIX file
 243  * descriptor as its first input.
 244  */
 245 SVCXPRT *
 246 svcunixfd_create(fd, sendsize, recvsize)
 247         int fd;
 248         u_int sendsize;
 249         u_int recvsize;
 250 {
 251
 252         return (makefd_xprt(fd, sendsize, recvsize));
 253 }
 254
 255 static SVCXPRT *
 256 makefd_xprt(fd, sendsize, recvsize)
 257         int fd;
 258         u_int sendsize;
 259         u_int recvsize;
 260 {
 261         register SVCXPRT *xprt;
 262         register struct unix_conn *cd;
 263
 264         xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
 265         if (xprt == (SVCXPRT *)NULL) {
 266                 (void) fprintf(stderr, "svc_unix: makefd_xprt: out of memory\n");
 267                 goto done;
 268         }
 269         cd = (struct unix_conn *)mem_alloc(sizeof(struct unix_conn));
 270         if (cd == (struct unix_conn *)NULL) {
 271                 (void) fprintf(stderr, "svc_unix: makefd_xprt: out of memory\n");
 272                 mem_free((char *) xprt, sizeof(SVCXPRT));
 273                 xprt = (SVCXPRT *)NULL;
 274                 goto done;
 275         }
 276         cd->strm_stat = XPRT_IDLE;
 277         xdrrec_create(&(cd->xdrs), sendsize, recvsize,
 278             (caddr_t)xprt, readunix, writeunix);
 279         xprt->xp_p2 = NULL;
 280         xprt->xp_p1 = (caddr_t)cd;
 281         xprt->xp_verf.oa_base = cd->verf_body;
 282         xprt->xp_addrlen = 0;
 283         xprt->xp_ops = &svcunix_op;  /* truely deals with calls */
 284         xprt->xp_port = 0;  /* this is a connection, not a rendezvouser */
 285         xprt->xp_sock = fd;
 286         xprt_register(xprt);
 287     done:
 288         return (xprt);
 289 }
 290
 291 static bool_t
 292 rendezvous_request(xprt)
 293         register SVCXPRT *xprt;
 294 {
 295         int sock;
 296         struct unix_rendezvous *r;
 297         struct sockaddr_un addr;
 298         struct sockaddr_in in_addr;
 299         int len;
 300
 301         r = (struct unix_rendezvous *)xprt->xp_p1;
 302     again:
 303         len = sizeof(struct sockaddr_in);
 304         if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr,
 305             &len)) < 0) {
 306                 if (errno == EINTR)
 307                         goto again;
 308                return (FALSE);
 309         }
 310
 311         /*
 312          * make a new transporter (re-uses xprt)
 313          */
 314         bzero((char *)&in_addr, sizeof(in_addr));
 315         in_addr.sin_family = AF_UNIX;
 316         xprt = makefd_xprt(sock, r->sendsize, r->recvsize);
 317         xprt->xp_raddr = in_addr;
 318         xprt->xp_addrlen = len;
 319         return (FALSE); /* there is never an rpc msg to be processed */
 320 }
 321
 322 static enum xprt_stat
 323 rendezvous_stat()
 324 {
 325
 326         return (XPRT_IDLE);
 327 }
 328
 329 static void
 330 svcunix_destroy(xprt)
 331         register SVCXPRT *xprt;
 332 {
 333         register struct unix_conn *cd = (struct unix_conn *)xprt->xp_p1;
 334
 335         xprt_unregister(xprt);
 336         (void)_close(xprt->xp_sock);
 337         if (xprt->xp_port != 0) {
 338                 /* a rendezvouser socket */
 339                 xprt->xp_port = 0;
 340         } else {
 341                 /* an actual connection socket */
 342                 XDR_DESTROY(&(cd->xdrs));
 343         }
 344         mem_free((caddr_t)cd, sizeof(struct unix_conn));
 345         mem_free((caddr_t)xprt, sizeof(SVCXPRT));
 346 }
 347
 348 /*
 349  * All read operations timeout after 35 seconds.
 350  * A timeout is fatal for the connection.
 351  */
 352 static struct timeval wait_per_try = { 35, 0 };
 353
 354 /*
 355  * reads data from the unix conection.
 356  * any error is fatal and the connection is closed.
 357  * (And a read of zero bytes is a half closed stream => error.)
 358  *
 359  * Note: we have to be careful here not to allow ourselves to become
 360  * blocked too long in this routine. While we're waiting for data from one
 361  * client, another client may be trying to connect. To avoid this situation,
 362  * some code from svc_run() is transplanted here: the select() loop checks
 363  * all RPC descriptors including the one we want and calls svc_getreqset2()
 364  * to handle new requests if any are detected.
 365  */
 366 static int
 367 readunix(xprt, buf, len)
 368         register SVCXPRT *xprt;
 369         caddr_t buf;
 370         register int len;
 371 {
 372         register int sock = xprt->xp_sock;
 373         struct timeval start, delta, tv;
 374         struct timeval tmp1, tmp2;
 375         fd_set *fds;
 376         extern fd_set           *__svc_fdset;
 377         extern int              __svc_fdsetsize;
 378
 379         delta = wait_per_try;
 380         fds = NULL;
 381         gettimeofday(&start, NULL);
 382         do {
 383                 int bytes = howmany(__svc_fdsetsize, NFDBITS) *
 384                                 sizeof(fd_mask);
 385                 if (fds != NULL)
 386                         free(fds);
 387                 fds = (fd_set *)malloc(bytes);
 388                 if (fds == NULL)
 389                         goto fatal_err;
 390                 memcpy(fds, __svc_fdset, bytes);
 391
 392                 /* XXX we know the other bits are still clear */
 393                 FD_SET(sock, fds);
 394                 tv = delta;     /* in case select() implements writeback */
 395                 switch (select(svc_maxfd + 1, fds, NULL, NULL, &tv)) {
 396                 case -1:
 397                         memset(fds, 0, bytes);
 398                         if (errno != EINTR)
 399                                 goto fatal_err;
 400                         gettimeofday(&tmp1, NULL);
 401                         timersub(&tmp1, &start, &tmp2);
 402                         timersub(&wait_per_try, &tmp2, &tmp1);
 403                         if (tmp1.tv_sec < 0 || !timerisset(&tmp1))
 404                                 goto fatal_err;
 405                         delta = tmp1;
 406                         continue;
 407                 case 0:
 408                         goto fatal_err;
 409                 default:
 410                         if (!FD_ISSET(sock, fds)) {
 411                                 svc_getreqset2(fds, svc_maxfd + 1);
 412                                 gettimeofday(&tmp1, NULL);
 413                                 timersub(&tmp1, &start, &tmp2);
 414                                 timersub(&wait_per_try, &tmp2, &tmp1);
 415                                 if (tmp1.tv_sec < 0 || !timerisset(&tmp1))
 416                                         goto fatal_err;
 417                                 delta = tmp1;
 418                                 continue;
 419                         }
 420                 }
 421         } while (!FD_ISSET(sock, fds));
 422         if ((len = __msgread(sock, buf, len)) > 0) {
 423                 if (fds != NULL)
 424                         free(fds);
 425                 return (len);
 426         }
 427 fatal_err:
 428         ((struct unix_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
 429         if (fds != NULL)
 430                 free(fds);
 431         return (-1);
 432 }
 433
 434 /*
 435  * writes data to the unix connection.
 436  * Any error is fatal and the connection is closed.
 437  */
 438 static int
 439 writeunix(xprt, buf, len)
 440         register SVCXPRT *xprt;
 441         caddr_t buf;
 442         int len;
 443 {
 444         register int i, cnt;
 445
 446         for (cnt = len; cnt > 0; cnt -= i, buf += i) {
 447                 if ((i = __msgwrite(xprt->xp_sock, buf, cnt)) < 0) {
 448                         ((struct unix_conn *)(xprt->xp_p1))->strm_stat =
 449                             XPRT_DIED;
 450                         return (-1);
 451                 }
 452         }
 453         return (len);
 454 }
 455
 456 static enum xprt_stat
 457 svcunix_stat(xprt)
 458         SVCXPRT *xprt;
 459 {
 460         register struct unix_conn *cd =
 461             (struct unix_conn *)(xprt->xp_p1);
 462
 463         if (cd->strm_stat == XPRT_DIED)
 464                 return (XPRT_DIED);
 465         if (! xdrrec_eof(&(cd->xdrs)))
 466                 return (XPRT_MOREREQS);
 467         return (XPRT_IDLE);
 468 }
 469
 470 static bool_t
 471 svcunix_recv(xprt, msg)
 472         SVCXPRT *xprt;
 473         register struct rpc_msg *msg;
 474 {
 475         register struct unix_conn *cd =
 476             (struct unix_conn *)(xprt->xp_p1);
 477         register XDR *xdrs = &(cd->xdrs);
 478
 479         xdrs->x_op = XDR_DECODE;
 480         (void)xdrrec_skiprecord(xdrs);
 481         if (xdr_callmsg(xdrs, msg)) {
 482                 cd->x_id = msg->rm_xid;
 483                 /* set up verifiers */
 484                 msg->rm_call.cb_verf.oa_flavor = AUTH_UNIX;
 485                 msg->rm_call.cb_verf.oa_base = (caddr_t)&cm;
 486                 msg->rm_call.cb_verf.oa_length = sizeof(cm);
 487                 return (TRUE);
 488         }
 489         cd->strm_stat = XPRT_DIED;      /* XXXX */
 490         return (FALSE);
 491 }
 492
 493 static bool_t
 494 svcunix_getargs(xprt, xdr_args, args_ptr)
 495         SVCXPRT *xprt;
 496         xdrproc_t xdr_args;
 497         caddr_t args_ptr;
 498 {
 499
 500         return ((*xdr_args)(&(((struct unix_conn *)(xprt->xp_p1))->xdrs), args_ptr));
 501 }
 502
 503 static bool_t
 504 svcunix_freeargs(xprt, xdr_args, args_ptr)
 505         SVCXPRT *xprt;
 506         xdrproc_t xdr_args;
 507         caddr_t args_ptr;
 508 {
 509         register XDR *xdrs =
 510             &(((struct unix_conn *)(xprt->xp_p1))->xdrs);
 511
 512         xdrs->x_op = XDR_FREE;
 513         return ((*xdr_args)(xdrs, args_ptr));
 514 }
 515
 516 static bool_t
 517 svcunix_reply(xprt, msg)
 518         SVCXPRT *xprt;
 519         register struct rpc_msg *msg;
 520 {
 521         register struct unix_conn *cd =
 522             (struct unix_conn *)(xprt->xp_p1);
 523         register XDR *xdrs = &(cd->xdrs);
 524         register bool_t stat;
 525
 526         xdrs->x_op = XDR_ENCODE;
 527         msg->rm_xid = cd->x_id;
 528         stat = xdr_replymsg(xdrs, msg);
 529         (void)xdrrec_endofrecord(xdrs, TRUE);
 530         return (stat);
 531 }