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 <stdlib.h> 46 #include <rpc/rpc.h> 47 #include <sys/socket.h> 48 #include <errno.h> 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 (bool_t (*)())abort, 80 (bool_t (*)())abort, 81 (bool_t (*)())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 } 420