sunrpc/svc_tcp.c

   1 /* @(#)svc_tcp.c        2.2 88/08/01 4.0 RPCSRC */
   2 /*
   3  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   4  * unrestricted use provided that this legend is included on all tape
   5  * media and as a part of the software program in whole or part.  Users
   6  * may copy or modify Sun RPC without charge, but are not authorized
   7  * to license or distribute it to anyone else except as part of a product or
   8  * program developed by the user.
   9  *
  10  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  11  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  12  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  13  *
  14  * Sun RPC is provided with no support and without any obligation on the
  15  * part of Sun Microsystems, Inc. to assist in its use, correction,
  16  * modification or enhancement.
  17  *
  18  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  19  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  20  * OR ANY PART THEREOF.
  21  *
  22  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  23  * or profits or other special, indirect and consequential damages, even if
  24  * Sun has been advised of the possibility of such damages.
  25  *
  26  * Sun Microsystems, Inc.
  27  * 2550 Garcia Avenue
  28  * Mountain View, California  94043
  29  */
  30 #if !defined(lint) && defined(SCCSIDS)
  31 static char sccsid[] = "@(#)svc_tcp.c 1.21 87/08/11 Copyr 1984 Sun Micro";
  32 #endif
  33
  34 /*
  35  * svc_tcp.c, Server side for TCP/IP based RPC.
  36  *
  37  * Copyright (C) 1984, Sun Microsystems, Inc.
  38  *
  39  * Actually implements two flavors of transporter -
  40  * a tcp rendezvouser (a listner and connection establisher)
  41  * and a record/tcp stream.
  42  */
  43
  44 #include <stdio.h>
  45 #include <rpc/rpc.h>
  46 #include <sys/socket.h>
  47 #include <errno.h>
  48 extern bool_t abort();
  49 extern errno;
  50
  51 /*
  52  * Ops vector for TCP/IP based rpc service handle
  53  */
  54 static bool_t           svctcp_recv();
  55 static enum xprt_stat   svctcp_stat();
  56 static bool_t           svctcp_getargs();
  57 static bool_t           svctcp_reply();
  58 static bool_t           svctcp_freeargs();
  59 static void             svctcp_destroy();
  60
  61 static struct xp_ops svctcp_op = {
  62         svctcp_recv,
  63         svctcp_stat,
  64         svctcp_getargs,
  65         svctcp_reply,
  66         svctcp_freeargs,
  67         svctcp_destroy
  68 };
  69
  70 /*
  71  * Ops vector for TCP/IP rendezvous handler
  72  */
  73 static bool_t           rendezvous_request();
  74 static enum xprt_stat   rendezvous_stat();
  75
  76 static struct xp_ops svctcp_rendezvous_op = {
  77         rendezvous_request,
  78         rendezvous_stat,
  79         abort,
  80         abort,
  81         abort,
  82         svctcp_destroy
  83 };
  84
  85 static int readtcp(), writetcp();
  86 static SVCXPRT *makefd_xprt();
  87
  88 struct tcp_rendezvous { /* kept in xprt->xp_p1 */
  89         u_int sendsize;
  90         u_int recvsize;
  91 };
  92
  93 struct tcp_conn {  /* kept in xprt->xp_p1 */
  94         enum xprt_stat strm_stat;
  95         u_long x_id;
  96         XDR xdrs;
  97         char verf_body[MAX_AUTH_BYTES];
  98 };
  99
 100 /*
 101  * Usage:
 102  *      xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
 103  *
 104  * Creates, registers, and returns a (rpc) tcp based transporter.
 105  * Once *xprt is initialized, it is registered as a transporter
 106  * see (svc.h, xprt_register).  This routine returns
 107  * a NULL if a problem occurred.
 108  *
 109  * If sock<0 then a socket is created, else sock is used.
 110  * If the socket, sock is not bound to a port then svctcp_create
 111  * binds it to an arbitrary port.  The routine then starts a tcp
 112  * listener on the socket's associated port.  In any (successful) case,
 113  * xprt->xp_sock is the registered socket number and xprt->xp_port is the
 114  * associated port number.
 115  *
 116  * Since tcp streams do buffered io similar to stdio, the caller can specify
 117  * how big the send and receive buffers are via the second and third parms;
 118  * 0 => use the system default.
 119  */
 120 SVCXPRT *
 121 svctcp_create(sock, sendsize, recvsize)
 122         register int sock;
 123         u_int sendsize;
 124         u_int recvsize;
 125 {
 126         bool_t madesock = FALSE;
 127         register SVCXPRT *xprt;
 128         register struct tcp_rendezvous *r;
 129         struct sockaddr_in addr;
 130         int len = sizeof(struct sockaddr_in);
 131
 132         if (sock == RPC_ANYSOCK) {
 133                 if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
 134                         perror(_("svctcp_.c - udp socket creation problem"));
 135                         return ((SVCXPRT *)NULL);
 136                 }
 137                 madesock = TRUE;
 138         }
 139         bzero((char *)&addr, sizeof (addr));
 140         addr.sin_family = AF_INET;
 141         if (bindresvport(sock, &addr)) {
 142                 addr.sin_port = 0;
 143                 (void)bind(sock, (struct sockaddr *)&addr, len);
 144         }
 145         if ((getsockname(sock, (struct sockaddr *)&addr, &len) != 0)  ||
 146             (listen(sock, 2) != 0)) {
 147                 perror(_("svctcp_.c - cannot getsockname or listen"));
 148                 if (madesock)
 149                        (void)close(sock);
 150                 return ((SVCXPRT *)NULL);
 151         }
 152         r = (struct tcp_rendezvous *)mem_alloc(sizeof(*r));
 153         if (r == NULL) {
 154                 (void) fprintf(stderr, _("svctcp_create: out of memory\n"));
 155                 return (NULL);
 156         }
 157         r->sendsize = sendsize;
 158         r->recvsize = recvsize;
 159         xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
 160         if (xprt == NULL) {
 161                 (void) fprintf(stderr, _("svctcp_create: out of memory\n"));
 162                 return (NULL);
 163         }
 164         xprt->xp_p2 = NULL;
 165         xprt->xp_p1 = (caddr_t)r;
 166         xprt->xp_verf = _null_auth;
 167         xprt->xp_ops = &svctcp_rendezvous_op;
 168         xprt->xp_port = ntohs(addr.sin_port);
 169         xprt->xp_sock = sock;
 170         xprt_register(xprt);
 171         return (xprt);
 172 }
 173
 174 /*
 175  * Like svtcp_create(), except the routine takes any *open* UNIX file
 176  * descriptor as its first input.
 177  */
 178 SVCXPRT *
 179 svcfd_create(fd, sendsize, recvsize)
 180         int fd;
 181         u_int sendsize;
 182         u_int recvsize;
 183 {
 184
 185         return (makefd_xprt(fd, sendsize, recvsize));
 186 }
 187
 188 static SVCXPRT *
 189 makefd_xprt(fd, sendsize, recvsize)
 190         int fd;
 191         u_int sendsize;
 192         u_int recvsize;
 193 {
 194         register SVCXPRT *xprt;
 195         register struct tcp_conn *cd;
 196
 197         xprt = (SVCXPRT *)mem_alloc(sizeof(SVCXPRT));
 198         if (xprt == (SVCXPRT *)NULL) {
 199                 (void) fprintf(stderr, _("svc_tcp: makefd_xprt: out of memory\n"));
 200                 goto done;
 201         }
 202         cd = (struct tcp_conn *)mem_alloc(sizeof(struct tcp_conn));
 203         if (cd == (struct tcp_conn *)NULL) {
 204                 (void) fprintf(stderr, _("svc_tcp: makefd_xprt: out of memory\n"));
 205                 mem_free((char *) xprt, sizeof(SVCXPRT));
 206                 xprt = (SVCXPRT *)NULL;
 207                 goto done;
 208         }
 209         cd->strm_stat = XPRT_IDLE;
 210         xdrrec_create(&(cd->xdrs), sendsize, recvsize,
 211             (caddr_t)xprt, readtcp, writetcp);
 212         xprt->xp_p2 = NULL;
 213         xprt->xp_p1 = (caddr_t)cd;
 214         xprt->xp_verf.oa_base = cd->verf_body;
 215         xprt->xp_addrlen = 0;
 216         xprt->xp_ops = &svctcp_op;  /* truely deals with calls */
 217         xprt->xp_port = 0;  /* this is a connection, not a rendezvouser */
 218         xprt->xp_sock = fd;
 219         xprt_register(xprt);
 220     done:
 221         return (xprt);
 222 }
 223
 224 static bool_t
 225 rendezvous_request(xprt)
 226         register SVCXPRT *xprt;
 227 {
 228         int sock;
 229         struct tcp_rendezvous *r;
 230         struct sockaddr_in addr;
 231         int len;
 232
 233         r = (struct tcp_rendezvous *)xprt->xp_p1;
 234     again:
 235         len = sizeof(struct sockaddr_in);
 236         if ((sock = accept(xprt->xp_sock, (struct sockaddr *)&addr,
 237             &len)) < 0) {
 238                 if (errno == EINTR)
 239                         goto again;
 240                return (FALSE);
 241         }
 242         /*
 243          * make a new transporter (re-uses xprt)
 244          */
 245         xprt = makefd_xprt(sock, r->sendsize, r->recvsize);
 246         xprt->xp_raddr = addr;
 247         xprt->xp_addrlen = len;
 248         return (FALSE); /* there is never an rpc msg to be processed */
 249 }
 250
 251 static enum xprt_stat
 252 rendezvous_stat()
 253 {
 254
 255         return (XPRT_IDLE);
 256 }
 257
 258 static void
 259 svctcp_destroy(xprt)
 260         register SVCXPRT *xprt;
 261 {
 262         register struct tcp_conn *cd = (struct tcp_conn *)xprt->xp_p1;
 263
 264         xprt_unregister(xprt);
 265         (void)close(xprt->xp_sock);
 266         if (xprt->xp_port != 0) {
 267                 /* a rendezvouser socket */
 268                 xprt->xp_port = 0;
 269         } else {
 270                 /* an actual connection socket */
 271                 XDR_DESTROY(&(cd->xdrs));
 272         }
 273         mem_free((caddr_t)cd, sizeof(struct tcp_conn));
 274         mem_free((caddr_t)xprt, sizeof(SVCXPRT));
 275 }
 276
 277 /*
 278  * All read operations timeout after 35 seconds.
 279  * A timeout is fatal for the connection.
 280  */
 281 static struct timeval wait_per_try = { 35, 0 };
 282
 283 /*
 284  * reads data from the tcp conection.
 285  * any error is fatal and the connection is closed.
 286  * (And a read of zero bytes is a half closed stream => error.)
 287  */
 288 static int
 289 readtcp(xprt, buf, len)
 290         register SVCXPRT *xprt;
 291         caddr_t buf;
 292         register int len;
 293 {
 294         register int sock = xprt->xp_sock;
 295 #ifdef FD_SETSIZE
 296         fd_set mask;
 297         fd_set readfds;
 298
 299         FD_ZERO(&mask);
 300         FD_SET(sock, &mask);
 301 #else
 302         register int mask = 1 << sock;
 303         int readfds;
 304 #endif /* def FD_SETSIZE */
 305         do {
 306                 readfds = mask;
 307                 if (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL,
 308                            &wait_per_try) <= 0) {
 309                         if (errno == EINTR) {
 310                                 continue;
 311                         }
 312                         goto fatal_err;
 313                 }
 314 #ifdef FD_SETSIZE
 315         } while (!FD_ISSET(sock, &readfds));
 316 #else
 317         } while (readfds != mask);
 318 #endif /* def FD_SETSIZE */
 319         if ((len = read(sock, buf, len)) > 0) {
 320                 return (len);
 321         }
 322 fatal_err:
 323         ((struct tcp_conn *)(xprt->xp_p1))->strm_stat = XPRT_DIED;
 324         return (-1);
 325 }
 326
 327 /*
 328  * writes data to the tcp connection.
 329  * Any error is fatal and the connection is closed.
 330  */
 331 static int
 332 writetcp(xprt, buf, len)
 333         register SVCXPRT *xprt;
 334         caddr_t buf;
 335         int len;
 336 {
 337         register int i, cnt;
 338
 339         for (cnt = len; cnt > 0; cnt -= i, buf += i) {
 340                 if ((i = write(xprt->xp_sock, buf, cnt)) < 0) {
 341                         ((struct tcp_conn *)(xprt->xp_p1))->strm_stat =
 342                             XPRT_DIED;
 343                         return (-1);
 344                 }
 345         }
 346         return (len);
 347 }
 348
 349 static enum xprt_stat
 350 svctcp_stat(xprt)
 351         SVCXPRT *xprt;
 352 {
 353         register struct tcp_conn *cd =
 354             (struct tcp_conn *)(xprt->xp_p1);
 355
 356         if (cd->strm_stat == XPRT_DIED)
 357                 return (XPRT_DIED);
 358         if (! xdrrec_eof(&(cd->xdrs)))
 359                 return (XPRT_MOREREQS);
 360         return (XPRT_IDLE);
 361 }
 362
 363 static bool_t
 364 svctcp_recv(xprt, msg)
 365         SVCXPRT *xprt;
 366         register struct rpc_msg *msg;
 367 {
 368         register struct tcp_conn *cd =
 369             (struct tcp_conn *)(xprt->xp_p1);
 370         register XDR *xdrs = &(cd->xdrs);
 371
 372         xdrs->x_op = XDR_DECODE;
 373         (void)xdrrec_skiprecord(xdrs);
 374         if (xdr_callmsg(xdrs, msg)) {
 375                 cd->x_id = msg->rm_xid;
 376                 return (TRUE);
 377         }
 378         return (FALSE);
 379 }
 380
 381 static bool_t
 382 svctcp_getargs(xprt, xdr_args, args_ptr)
 383         SVCXPRT *xprt;
 384         xdrproc_t xdr_args;
 385         caddr_t args_ptr;
 386 {
 387
 388         return ((*xdr_args)(&(((struct tcp_conn *)(xprt->xp_p1))->xdrs), args_ptr));
 389 }
 390
 391 static bool_t
 392 svctcp_freeargs(xprt, xdr_args, args_ptr)
 393         SVCXPRT *xprt;
 394         xdrproc_t xdr_args;
 395         caddr_t args_ptr;
 396 {
 397         register XDR *xdrs =
 398             &(((struct tcp_conn *)(xprt->xp_p1))->xdrs);
 399
 400         xdrs->x_op = XDR_FREE;
 401         return ((*xdr_args)(xdrs, args_ptr));
 402 }
 403
 404 static bool_t
 405 svctcp_reply(xprt, msg)
 406         SVCXPRT *xprt;
 407         register struct rpc_msg *msg;
 408 {
 409         register struct tcp_conn *cd =
 410             (struct tcp_conn *)(xprt->xp_p1);
 411         register XDR *xdrs = &(cd->xdrs);
 412         register bool_t stat;
 413
 414         xdrs->x_op = XDR_ENCODE;
 415         msg->rm_xid = cd->x_id;
 416         stat = xdr_replymsg(xdrs, msg);
 417         (void)xdrrec_endofrecord(xdrs, TRUE);
 418         return (stat);
 419 }