Update.
[glibc.git] / sunrpc / clnt_tcp.c
blob07224e313bb360713cb394fcfe10d6f93e6ab6d9
1 /* @(#)clnt_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.
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.
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.
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.
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.
26 * Sun Microsystems, Inc.
27 * 2550 Garcia Avenue
28 * Mountain View, California 94043
30 #if !defined(lint) && defined(SCCSIDS)
31 static char sccsid[] = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro";
32 #endif
35 * clnt_tcp.c, Implements a TCP/IP based, client side RPC.
37 * Copyright (C) 1984, Sun Microsystems, Inc.
39 * TCP based RPC supports 'batched calls'.
40 * A sequence of calls may be batched-up in a send buffer. The rpc call
41 * return immediately to the client even though the call was not necessarily
42 * sent. The batching occurs if the results' xdr routine is NULL (0) AND
43 * the rpc timeout value is zero (see clnt.h, rpc).
45 * Clients should NOT casually batch calls that in fact return results; that is,
46 * the server side should be aware that a call is batched and not produce any
47 * return message. Batched calls that produce many result messages can
48 * deadlock (netlock) the client and the server....
50 * Now go hang yourself.
53 #include <netdb.h>
54 #include <errno.h>
55 #include <stdio.h>
56 #include <unistd.h>
57 #include <rpc/rpc.h>
58 #include <sys/poll.h>
59 #include <sys/socket.h>
60 #include <rpc/pmap_clnt.h>
62 #define MCALL_MSG_SIZE 24
64 struct ct_data
66 int ct_sock;
67 bool_t ct_closeit;
68 struct timeval ct_wait;
69 bool_t ct_waitset; /* wait set by clnt_control? */
70 struct sockaddr_in ct_addr;
71 struct rpc_err ct_error;
72 char ct_mcall[MCALL_MSG_SIZE]; /* marshalled callmsg */
73 u_int ct_mpos; /* pos after marshal */
74 XDR ct_xdrs;
77 static int readtcp (char *, char *, int);
78 static int writetcp (char *, char *, int);
80 static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
81 xdrproc_t, caddr_t, struct timeval);
82 static void clnttcp_abort (void);
83 static void clnttcp_geterr (CLIENT *, struct rpc_err *);
84 static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, caddr_t);
85 static bool_t clnttcp_control (CLIENT *, int, char *);
86 static void clnttcp_destroy (CLIENT *);
88 static struct clnt_ops tcp_ops =
90 clnttcp_call,
91 clnttcp_abort,
92 clnttcp_geterr,
93 clnttcp_freeres,
94 clnttcp_destroy,
95 clnttcp_control
99 * Create a client handle for a tcp/ip connection.
100 * If *sockp<0, *sockp is set to a newly created TCP socket and it is
101 * connected to raddr. If *sockp non-negative then
102 * raddr is ignored. The rpc/tcp package does buffering
103 * similar to stdio, so the client must pick send and receive buffer sizes,];
104 * 0 => use the default.
105 * If raddr->sin_port is 0, then a binder on the remote machine is
106 * consulted for the right port number.
107 * NB: *sockp is copied into a private area.
108 * NB: It is the clients responsibility to close *sockp.
109 * NB: The rpch->cl_auth is set null authentication. Caller may wish to set this
110 * something more useful.
112 CLIENT *
113 clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
114 int *sockp, u_int sendsz, u_int recvsz)
116 CLIENT *h;
117 struct ct_data *ct = (struct ct_data *) mem_alloc (sizeof (*ct));
118 struct timeval now;
119 struct rpc_msg call_msg;
121 h = (CLIENT *) mem_alloc (sizeof (*h));
122 if (h == NULL)
124 (void) fprintf (stderr, _("clnttcp_create: out of memory\n"));
125 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
126 rpc_createerr.cf_error.re_errno = errno;
127 goto fooy;
129 /* ct = (struct ct_data *) mem_alloc (sizeof (*ct)); */
130 if (ct == NULL)
132 (void) fprintf (stderr, _("clnttcp_create: out of memory\n"));
133 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
134 rpc_createerr.cf_error.re_errno = errno;
135 goto fooy;
139 * If no port number given ask the pmap for one
141 if (raddr->sin_port == 0)
143 u_short port;
144 if ((port = pmap_getport (raddr, prog, vers, IPPROTO_TCP)) == 0)
146 mem_free ((caddr_t) ct, sizeof (struct ct_data));
147 mem_free ((caddr_t) h, sizeof (CLIENT));
148 return ((CLIENT *) NULL);
150 raddr->sin_port = htons (port);
154 * If no socket given, open one
156 if (*sockp < 0)
158 *sockp = __socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
159 (void) bindresvport (*sockp, (struct sockaddr_in *) 0);
160 if ((*sockp < 0)
161 || (__connect (*sockp, (struct sockaddr *) raddr,
162 sizeof (*raddr)) < 0))
164 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
165 rpc_createerr.cf_error.re_errno = errno;
166 if (*sockp >= 0)
167 (void) __close (*sockp);
168 goto fooy;
170 ct->ct_closeit = TRUE;
172 else
174 ct->ct_closeit = FALSE;
178 * Set up private data struct
180 ct->ct_sock = *sockp;
181 ct->ct_wait.tv_usec = 0;
182 ct->ct_waitset = FALSE;
183 ct->ct_addr = *raddr;
186 * Initialize call message
188 (void) __gettimeofday (&now, (struct timezone *) 0);
189 call_msg.rm_xid = __getpid () ^ now.tv_sec ^ now.tv_usec;
190 call_msg.rm_direction = CALL;
191 call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
192 call_msg.rm_call.cb_prog = prog;
193 call_msg.rm_call.cb_vers = vers;
196 * pre-serialize the static part of the call msg and stash it away
198 xdrmem_create (&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
199 XDR_ENCODE);
200 if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg))
202 if (ct->ct_closeit)
204 (void) __close (*sockp);
206 goto fooy;
208 ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs));
209 XDR_DESTROY (&(ct->ct_xdrs));
212 * Create a client handle which uses xdrrec for serialization
213 * and authnone for authentication.
215 xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz,
216 (caddr_t) ct, readtcp, writetcp);
217 h->cl_ops = &tcp_ops;
218 h->cl_private = (caddr_t) ct;
219 h->cl_auth = authnone_create ();
220 return h;
222 fooy:
224 * Something goofed, free stuff and barf
226 mem_free ((caddr_t) ct, sizeof (struct ct_data));
227 mem_free ((caddr_t) h, sizeof (CLIENT));
228 return ((CLIENT *) NULL);
231 static enum clnt_stat
232 clnttcp_call (h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
233 CLIENT *h;
234 u_long proc;
235 xdrproc_t xdr_args;
236 caddr_t args_ptr;
237 xdrproc_t xdr_results;
238 caddr_t results_ptr;
239 struct timeval timeout;
241 struct ct_data *ct = (struct ct_data *) h->cl_private;
242 XDR *xdrs = &(ct->ct_xdrs);
243 struct rpc_msg reply_msg;
244 u_long x_id;
245 u_int32_t *msg_x_id = (u_int32_t *) (ct->ct_mcall); /* yuk */
246 bool_t shipnow;
247 int refreshes = 2;
249 if (!ct->ct_waitset)
251 ct->ct_wait = timeout;
254 shipnow =
255 (xdr_results == (xdrproc_t) 0 && timeout.tv_sec == 0
256 && timeout.tv_usec == 0) ? FALSE : TRUE;
258 call_again:
259 xdrs->x_op = XDR_ENCODE;
260 ct->ct_error.re_status = RPC_SUCCESS;
261 x_id = ntohl (--(*msg_x_id));
262 if ((!XDR_PUTBYTES (xdrs, ct->ct_mcall, ct->ct_mpos)) ||
263 (!XDR_PUTLONG (xdrs, (long *) &proc)) ||
264 (!AUTH_MARSHALL (h->cl_auth, xdrs)) ||
265 (!(*xdr_args) (xdrs, args_ptr)))
267 if (ct->ct_error.re_status == RPC_SUCCESS)
268 ct->ct_error.re_status = RPC_CANTENCODEARGS;
269 (void) xdrrec_endofrecord (xdrs, TRUE);
270 return (ct->ct_error.re_status);
272 if (!xdrrec_endofrecord (xdrs, shipnow))
273 return ct->ct_error.re_status = RPC_CANTSEND;
274 if (!shipnow)
275 return RPC_SUCCESS;
277 * Hack to provide rpc-based message passing
279 if (timeout.tv_sec == 0 && timeout.tv_usec == 0)
281 return ct->ct_error.re_status = RPC_TIMEDOUT;
286 * Keep receiving until we get a valid transaction id
288 xdrs->x_op = XDR_DECODE;
289 while (TRUE)
291 reply_msg.acpted_rply.ar_verf = _null_auth;
292 reply_msg.acpted_rply.ar_results.where = NULL;
293 reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
294 if (!xdrrec_skiprecord (xdrs))
295 return (ct->ct_error.re_status);
296 /* now decode and validate the response header */
297 if (!xdr_replymsg (xdrs, &reply_msg))
299 if (ct->ct_error.re_status == RPC_SUCCESS)
300 continue;
301 return ct->ct_error.re_status;
303 if (reply_msg.rm_xid == x_id)
304 break;
308 * process header
310 _seterr_reply (&reply_msg, &(ct->ct_error));
311 if (ct->ct_error.re_status == RPC_SUCCESS)
313 if (!AUTH_VALIDATE (h->cl_auth, &reply_msg.acpted_rply.ar_verf))
315 ct->ct_error.re_status = RPC_AUTHERROR;
316 ct->ct_error.re_why = AUTH_INVALIDRESP;
318 else if (!(*xdr_results) (xdrs, results_ptr))
320 if (ct->ct_error.re_status == RPC_SUCCESS)
321 ct->ct_error.re_status = RPC_CANTDECODERES;
323 /* free verifier ... */
324 if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
326 xdrs->x_op = XDR_FREE;
327 (void) xdr_opaque_auth (xdrs, &(reply_msg.acpted_rply.ar_verf));
329 } /* end successful completion */
330 else
332 /* maybe our credentials need to be refreshed ... */
333 if (refreshes-- && AUTH_REFRESH (h->cl_auth))
334 goto call_again;
335 } /* end of unsuccessful completion */
336 return ct->ct_error.re_status;
339 static void
340 clnttcp_geterr (h, errp)
341 CLIENT *h;
342 struct rpc_err *errp;
344 struct ct_data *ct =
345 (struct ct_data *) h->cl_private;
347 *errp = ct->ct_error;
350 static bool_t
351 clnttcp_freeres (cl, xdr_res, res_ptr)
352 CLIENT *cl;
353 xdrproc_t xdr_res;
354 caddr_t res_ptr;
356 struct ct_data *ct = (struct ct_data *) cl->cl_private;
357 XDR *xdrs = &(ct->ct_xdrs);
359 xdrs->x_op = XDR_FREE;
360 return (*xdr_res) (xdrs, res_ptr);
363 static void
364 clnttcp_abort ()
368 static bool_t
369 clnttcp_control (CLIENT *cl, int request, char *info)
371 struct ct_data *ct = (struct ct_data *) cl->cl_private;
374 switch (request)
376 case CLSET_FD_CLOSE:
377 ct->ct_closeit = TRUE;
378 break;
379 case CLSET_FD_NCLOSE:
380 ct->ct_closeit = FALSE;
381 break;
382 case CLSET_TIMEOUT:
383 ct->ct_wait = *(struct timeval *) info;
384 ct->ct_waitset = TRUE;
385 break;
386 case CLGET_TIMEOUT:
387 *(struct timeval *) info = ct->ct_wait;
388 break;
389 case CLGET_SERVER_ADDR:
390 *(struct sockaddr_in *) info = ct->ct_addr;
391 break;
392 case CLGET_FD:
393 *(int *)info = ct->ct_sock;
394 break;
395 case CLGET_XID:
397 * use the knowledge that xid is the
398 * first element in the call structure *.
399 * This will get the xid of the PREVIOUS call
401 *(u_long *)info = ntohl (*(u_long *)ct->ct_mcall);
402 break;
403 case CLSET_XID:
404 /* This will set the xid of the NEXT call */
405 *(u_long *)ct->ct_mcall = htonl (*(u_long *)info - 1);
406 /* decrement by 1 as clnttcp_call() increments once */
407 case CLGET_VERS:
409 * This RELIES on the information that, in the call body,
410 * the version number field is the fifth field from the
411 * begining of the RPC header. MUST be changed if the
412 * call_struct is changed
414 *(u_long *)info = ntohl (*(u_long *)(ct->ct_mcall +
415 4 * BYTES_PER_XDR_UNIT));
416 break;
417 case CLSET_VERS:
418 *(u_long *)(ct->ct_mcall + 4 * BYTES_PER_XDR_UNIT)
419 = htonl (*(u_long *)info);
420 break;
421 case CLGET_PROG:
423 * This RELIES on the information that, in the call body,
424 * the program number field is the field from the
425 * begining of the RPC header. MUST be changed if the
426 * call_struct is changed
428 *(u_long *)info = ntohl(*(u_long *)(ct->ct_mcall +
429 3 * BYTES_PER_XDR_UNIT));
430 break;
431 case CLSET_PROG:
432 *(u_long *)(ct->ct_mcall + 3 * BYTES_PER_XDR_UNIT)
433 = htonl(*(u_long *)info);
434 break;
435 /* The following are only possible with TI-RPC */
436 case CLGET_RETRY_TIMEOUT:
437 case CLSET_RETRY_TIMEOUT:
438 case CLGET_SVC_ADDR:
439 case CLSET_SVC_ADDR:
440 case CLSET_PUSH_TIMOD:
441 case CLSET_POP_TIMOD:
442 default:
443 return FALSE;
445 return TRUE;
449 static void
450 clnttcp_destroy (CLIENT *h)
452 struct ct_data *ct =
453 (struct ct_data *) h->cl_private;
455 if (ct->ct_closeit)
457 (void) __close (ct->ct_sock);
459 XDR_DESTROY (&(ct->ct_xdrs));
460 mem_free ((caddr_t) ct, sizeof (struct ct_data));
461 mem_free ((caddr_t) h, sizeof (CLIENT));
465 * Interface between xdr serializer and tcp connection.
466 * Behaves like the system calls, read & write, but keeps some error state
467 * around for the rpc level.
469 static int
470 readtcp (char *ctptr, char *buf, int len)
472 struct ct_data *ct = (struct ct_data *)ctptr;
473 struct pollfd fd;
474 int milliseconds = (ct->ct_wait.tv_sec * 1000) +
475 (ct->ct_wait.tv_usec / 1000);
477 if (len == 0)
478 return 0;
480 fd.fd = ct->ct_sock;
481 fd.events = POLLIN;
482 while (TRUE)
484 switch (__poll(&fd, 1, milliseconds))
486 case 0:
487 ct->ct_error.re_status = RPC_TIMEDOUT;
488 return -1;
490 case -1:
491 if (errno == EINTR)
492 continue;
493 ct->ct_error.re_status = RPC_CANTRECV;
494 ct->ct_error.re_errno = errno;
495 return -1;
497 break;
499 switch (len = __read (ct->ct_sock, buf, len))
502 case 0:
503 /* premature eof */
504 ct->ct_error.re_errno = ECONNRESET;
505 ct->ct_error.re_status = RPC_CANTRECV;
506 len = -1; /* it's really an error */
507 break;
509 case -1:
510 ct->ct_error.re_errno = errno;
511 ct->ct_error.re_status = RPC_CANTRECV;
512 break;
514 return len;
517 static int
518 writetcp (char *ctptr, char *buf, int len)
520 int i, cnt;
521 struct ct_data *ct = (struct ct_data*)ctptr;
523 for (cnt = len; cnt > 0; cnt -= i, buf += i)
525 if ((i = __write (ct->ct_sock, buf, cnt)) == -1)
527 ct->ct_error.re_errno = errno;
528 ct->ct_error.re_status = RPC_CANTSEND;
529 return -1;
532 return len;