svc_tcp.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426
  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 0
  31. static char sccsid[] = "@(#)svc_tcp.c 1.21 87/08/11 Copyr 1984 Sun Micro";
  32. #endif
  33. /*
  34. * svc_tcp.c, Server side for TCP/IP based RPC.
  35. *
  36. * Copyright (C) 1984, Sun Microsystems, Inc.
  37. *
  38. * Actually implements two flavors of transporter -
  39. * a tcp rendezvouser (a listener and connection establisher)
  40. * and a record/tcp stream.
  41. */
  42. #define __FORCE_GLIBC
  43. #define _GNU_SOURCE
  44. #include <features.h>
  45. #include <stdio.h>
  46. #include <unistd.h>
  47. #include <string.h>
  48. #include <rpc/rpc.h>
  49. #include <sys/socket.h>
  50. #include <sys/poll.h>
  51. #include <errno.h>
  52. #include <stdlib.h>
  53. #ifdef USE_IN_LIBIO
  54. # include <wchar.h>
  55. # include <libio/iolibio.h>
  56. # define fputs(s, f) _IO_fputs (s, f)
  57. #endif
  58. /*
  59. * Ops vector for TCP/IP based rpc service handle
  60. */
  61. static bool_t svctcp_recv (SVCXPRT *, struct rpc_msg *);
  62. static enum xprt_stat svctcp_stat (SVCXPRT *);
  63. static bool_t svctcp_getargs (SVCXPRT *, xdrproc_t, caddr_t);
  64. static bool_t svctcp_reply (SVCXPRT *, struct rpc_msg *);
  65. static bool_t svctcp_freeargs (SVCXPRT *, xdrproc_t, caddr_t);
  66. static void svctcp_destroy (SVCXPRT *);
  67. static const struct xp_ops svctcp_op =
  68. {
  69. svctcp_recv,
  70. svctcp_stat,
  71. svctcp_getargs,
  72. svctcp_reply,
  73. svctcp_freeargs,
  74. svctcp_destroy
  75. };
  76. /*
  77. * Ops vector for TCP/IP rendezvous handler
  78. */
  79. static bool_t rendezvous_request (SVCXPRT *, struct rpc_msg *);
  80. static enum xprt_stat rendezvous_stat (SVCXPRT *);
  81. static void svctcp_rendezvous_abort (void);
  82. /* This function makes sure abort() relocation goes through PLT
  83. and thus can be lazy bound. */
  84. static void
  85. svctcp_rendezvous_abort (void)
  86. {
  87. abort ();
  88. };
  89. static const struct xp_ops svctcp_rendezvous_op =
  90. {
  91. rendezvous_request,
  92. rendezvous_stat,
  93. (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) svctcp_rendezvous_abort,
  94. (bool_t (*) (SVCXPRT *, struct rpc_msg *)) svctcp_rendezvous_abort,
  95. (bool_t (*) (SVCXPRT *, xdrproc_t, caddr_t)) svctcp_rendezvous_abort,
  96. svctcp_destroy
  97. };
  98. static int readtcp (char*, char *, int);
  99. static int writetcp (char *, char *, int);
  100. static SVCXPRT *makefd_xprt (int, u_int, u_int) internal_function;
  101. struct tcp_rendezvous
  102. { /* kept in xprt->xp_p1 */
  103. u_int sendsize;
  104. u_int recvsize;
  105. };
  106. struct tcp_conn
  107. { /* kept in xprt->xp_p1 */
  108. enum xprt_stat strm_stat;
  109. u_long x_id;
  110. XDR xdrs;
  111. char verf_body[MAX_AUTH_BYTES];
  112. };
  113. /*
  114. * Usage:
  115. * xprt = svctcp_create(sock, send_buf_size, recv_buf_size);
  116. *
  117. * Creates, registers, and returns a (rpc) tcp based transporter.
  118. * Once *xprt is initialized, it is registered as a transporter
  119. * see (svc.h, xprt_register). This routine returns
  120. * a NULL if a problem occurred.
  121. *
  122. * If sock<0 then a socket is created, else sock is used.
  123. * If the socket, sock is not bound to a port then svctcp_create
  124. * binds it to an arbitrary port. The routine then starts a tcp
  125. * listener on the socket's associated port. In any (successful) case,
  126. * xprt->xp_sock is the registered socket number and xprt->xp_port is the
  127. * associated port number.
  128. *
  129. * Since tcp streams do buffered io similar to stdio, the caller can specify
  130. * how big the send and receive buffers are via the second and third parms;
  131. * 0 => use the system default.
  132. */
  133. SVCXPRT *
  134. svctcp_create (int sock, u_int sendsize, u_int recvsize)
  135. {
  136. bool_t madesock = FALSE;
  137. SVCXPRT *xprt;
  138. struct tcp_rendezvous *r;
  139. struct sockaddr_in addr;
  140. socklen_t len = sizeof (struct sockaddr_in);
  141. if (sock == RPC_ANYSOCK)
  142. {
  143. if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
  144. {
  145. perror (_("svc_tcp.c - tcp socket creation problem"));
  146. return (SVCXPRT *) NULL;
  147. }
  148. madesock = TRUE;
  149. }
  150. memset ((char *) &addr, 0, sizeof (addr));
  151. addr.sin_family = AF_INET;
  152. if (bindresvport (sock, &addr))
  153. {
  154. addr.sin_port = 0;
  155. (void) bind (sock, (struct sockaddr *) &addr, len);
  156. }
  157. if ((getsockname (sock, (struct sockaddr *) &addr, &len) != 0) ||
  158. (listen (sock, 2) != 0))
  159. {
  160. perror (_("svc_tcp.c - cannot getsockname or listen"));
  161. if (madesock)
  162. (void) close (sock);
  163. return (SVCXPRT *) NULL;
  164. }
  165. r = (struct tcp_rendezvous *) mem_alloc (sizeof (*r));
  166. xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
  167. if (r == NULL || xprt == NULL)
  168. {
  169. #ifdef USE_IN_LIBIO
  170. if (_IO_fwide (stderr, 0) > 0)
  171. (void) __fwprintf (stderr, L"%s", _("svctcp_create: out of memory\n"));
  172. else
  173. #endif
  174. (void) fputs (_("svctcp_create: out of memory\n"), stderr);
  175. mem_free (r, sizeof (*r));
  176. mem_free (xprt, sizeof (SVCXPRT));
  177. return NULL;
  178. }
  179. r->sendsize = sendsize;
  180. r->recvsize = recvsize;
  181. xprt->xp_p2 = NULL;
  182. xprt->xp_p1 = (caddr_t) r;
  183. xprt->xp_verf = _null_auth;
  184. xprt->xp_ops = &svctcp_rendezvous_op;
  185. xprt->xp_port = ntohs (addr.sin_port);
  186. xprt->xp_sock = sock;
  187. xprt_register (xprt);
  188. return xprt;
  189. }
  190. /*
  191. * Like svtcp_create(), except the routine takes any *open* UNIX file
  192. * descriptor as its first input.
  193. */
  194. SVCXPRT *
  195. svcfd_create (int fd, u_int sendsize, u_int recvsize)
  196. {
  197. return makefd_xprt (fd, sendsize, recvsize);
  198. }
  199. static SVCXPRT *
  200. internal_function
  201. makefd_xprt (int fd, u_int sendsize, u_int recvsize)
  202. {
  203. SVCXPRT *xprt;
  204. struct tcp_conn *cd;
  205. xprt = (SVCXPRT *) mem_alloc (sizeof (SVCXPRT));
  206. cd = (struct tcp_conn *) mem_alloc (sizeof (struct tcp_conn));
  207. if (xprt == (SVCXPRT *) NULL || cd == NULL)
  208. {
  209. #ifdef USE_IN_LIBIO
  210. if (_IO_fwide (stderr, 0) > 0)
  211. (void) __fwprintf (stderr, L"%s",
  212. _("svc_tcp: makefd_xprt: out of memory\n"));
  213. else
  214. #endif
  215. (void) fputs (_("svc_tcp: makefd_xprt: out of memory\n"), stderr);
  216. mem_free (xprt, sizeof (SVCXPRT));
  217. mem_free (cd, sizeof (struct tcp_conn));
  218. return NULL;
  219. }
  220. cd->strm_stat = XPRT_IDLE;
  221. xdrrec_create (&(cd->xdrs), sendsize, recvsize,
  222. (caddr_t) xprt, readtcp, writetcp);
  223. xprt->xp_p2 = NULL;
  224. xprt->xp_p1 = (caddr_t) cd;
  225. xprt->xp_verf.oa_base = cd->verf_body;
  226. xprt->xp_addrlen = 0;
  227. xprt->xp_ops = &svctcp_op; /* truly deals with calls */
  228. xprt->xp_port = 0; /* this is a connection, not a rendezvouser */
  229. xprt->xp_sock = fd;
  230. xprt_register (xprt);
  231. return xprt;
  232. }
  233. static bool_t
  234. rendezvous_request (SVCXPRT *xprt, struct rpc_msg *errmsg)
  235. {
  236. int sock;
  237. struct tcp_rendezvous *r;
  238. struct sockaddr_in addr;
  239. socklen_t len;
  240. r = (struct tcp_rendezvous *) xprt->xp_p1;
  241. again:
  242. len = sizeof (struct sockaddr_in);
  243. if ((sock = accept (xprt->xp_sock, (struct sockaddr *) &addr, &len)) < 0)
  244. {
  245. if (errno == EINTR)
  246. goto again;
  247. return FALSE;
  248. }
  249. /*
  250. * make a new transporter (re-uses xprt)
  251. */
  252. xprt = makefd_xprt (sock, r->sendsize, r->recvsize);
  253. memcpy (&xprt->xp_raddr, &addr, sizeof (addr));
  254. xprt->xp_addrlen = len;
  255. return FALSE; /* there is never an rpc msg to be processed */
  256. }
  257. static enum xprt_stat
  258. rendezvous_stat (SVCXPRT *xprt)
  259. {
  260. return XPRT_IDLE;
  261. }
  262. static void
  263. svctcp_destroy (SVCXPRT *xprt)
  264. {
  265. struct tcp_conn *cd = (struct tcp_conn *) xprt->xp_p1;
  266. xprt_unregister (xprt);
  267. (void) close (xprt->xp_sock);
  268. if (xprt->xp_port != 0)
  269. {
  270. /* a rendezvouser socket */
  271. xprt->xp_port = 0;
  272. }
  273. else
  274. {
  275. /* an actual connection socket */
  276. XDR_DESTROY (&(cd->xdrs));
  277. }
  278. mem_free ((caddr_t) cd, sizeof (struct tcp_conn));
  279. mem_free ((caddr_t) xprt, sizeof (SVCXPRT));
  280. }
  281. /*
  282. * reads data from the tcp connection.
  283. * any error is fatal and the connection is closed.
  284. * (And a read of zero bytes is a half closed stream => error.)
  285. */
  286. static int
  287. readtcp (char *xprtptr, char *buf, int len)
  288. {
  289. SVCXPRT *xprt = (SVCXPRT *)xprtptr;
  290. int sock = xprt->xp_sock;
  291. int milliseconds = 35 * 1000;
  292. struct pollfd pollfd;
  293. do
  294. {
  295. pollfd.fd = sock;
  296. pollfd.events = POLLIN;
  297. switch (poll (&pollfd, 1, milliseconds))
  298. {
  299. case -1:
  300. if (errno == EINTR)
  301. continue;
  302. /*FALLTHROUGH*/
  303. case 0:
  304. goto fatal_err;
  305. default:
  306. if ((pollfd.revents & POLLERR) || (pollfd.revents & POLLHUP)
  307. || (pollfd.revents & POLLNVAL))
  308. goto fatal_err;
  309. break;
  310. }
  311. }
  312. while ((pollfd.revents & POLLIN) == 0);
  313. if ((len = read (sock, buf, len)) > 0)
  314. return len;
  315. fatal_err:
  316. ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
  317. return -1;
  318. }
  319. /*
  320. * writes data to the tcp connection.
  321. * Any error is fatal and the connection is closed.
  322. */
  323. static int
  324. writetcp (char *xprtptr, char * buf, int len)
  325. {
  326. SVCXPRT *xprt = (SVCXPRT *)xprtptr;
  327. int i, cnt;
  328. for (cnt = len; cnt > 0; cnt -= i, buf += i)
  329. {
  330. if ((i = write (xprt->xp_sock, buf, cnt)) < 0)
  331. {
  332. ((struct tcp_conn *) (xprt->xp_p1))->strm_stat = XPRT_DIED;
  333. return -1;
  334. }
  335. }
  336. return len;
  337. }
  338. static enum xprt_stat
  339. svctcp_stat (SVCXPRT *xprt)
  340. {
  341. struct tcp_conn *cd =
  342. (struct tcp_conn *) (xprt->xp_p1);
  343. if (cd->strm_stat == XPRT_DIED)
  344. return XPRT_DIED;
  345. if (!xdrrec_eof (&(cd->xdrs)))
  346. return XPRT_MOREREQS;
  347. return XPRT_IDLE;
  348. }
  349. static bool_t
  350. svctcp_recv (SVCXPRT *xprt, struct rpc_msg *msg)
  351. {
  352. struct tcp_conn *cd = (struct tcp_conn *) (xprt->xp_p1);
  353. XDR *xdrs = &(cd->xdrs);
  354. xdrs->x_op = XDR_DECODE;
  355. (void) xdrrec_skiprecord (xdrs);
  356. if (xdr_callmsg (xdrs, msg))
  357. {
  358. cd->x_id = msg->rm_xid;
  359. return TRUE;
  360. }
  361. cd->strm_stat = XPRT_DIED; /* XXXX */
  362. return FALSE;
  363. }
  364. static bool_t
  365. svctcp_getargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
  366. {
  367. return ((*xdr_args) (&(((struct tcp_conn *)
  368. (xprt->xp_p1))->xdrs), args_ptr));
  369. }
  370. static bool_t
  371. svctcp_freeargs (SVCXPRT *xprt, xdrproc_t xdr_args, caddr_t args_ptr)
  372. {
  373. XDR *xdrs = &(((struct tcp_conn *) (xprt->xp_p1))->xdrs);
  374. xdrs->x_op = XDR_FREE;
  375. return ((*xdr_args) (xdrs, args_ptr));
  376. }
  377. static bool_t
  378. svctcp_reply (SVCXPRT *xprt, struct rpc_msg *msg)
  379. {
  380. struct tcp_conn *cd = (struct tcp_conn *) (xprt->xp_p1);
  381. XDR *xdrs = &(cd->xdrs);
  382. bool_t stat;
  383. xdrs->x_op = XDR_ENCODE;
  384. msg->rm_xid = cd->x_id;
  385. stat = xdr_replymsg (xdrs, msg);
  386. (void) xdrrec_endofrecord (xdrs, TRUE);
  387. return stat;
  388. }