Thu May 9 09:17:46 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
[kopensolaris-gnu/glibc.git] / sunrpc / clnt_tcp.c
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.
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[] = "@(#)clnt_tcp.c 1.37 87/10/05 Copyr 1984 Sun Micro";
32 #endif
33
34 /*
35  * clnt_tcp.c, Implements a TCP/IP based, client side RPC.
36  *
37  * Copyright (C) 1984, Sun Microsystems, Inc.
38  *
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).
44  *
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....
49  *
50  * Now go hang yourself.
51  */
52
53 #include <stdio.h>
54 #include <rpc/rpc.h>
55 #include <sys/socket.h>
56 #include <netdb.h>
57 #include <errno.h>
58 #include <rpc/pmap_clnt.h>
59
60 #define MCALL_MSG_SIZE 24
61
62 extern int errno;
63
64 static int      readtcp();
65 static int      writetcp();
66
67 static enum clnt_stat   clnttcp_call();
68 static void             clnttcp_abort();
69 static void             clnttcp_geterr();
70 static bool_t           clnttcp_freeres();
71 static bool_t           clnttcp_control();
72 static void             clnttcp_destroy();
73
74 static struct clnt_ops tcp_ops = {
75         clnttcp_call,
76         clnttcp_abort,
77         clnttcp_geterr,
78         clnttcp_freeres,
79         clnttcp_destroy,
80         clnttcp_control
81 };
82
83 struct ct_data {
84         int             ct_sock;
85         bool_t          ct_closeit;
86         struct timeval  ct_wait;
87         bool_t          ct_waitset;       /* wait set by clnt_control? */
88         struct sockaddr_in ct_addr;
89         struct rpc_err  ct_error;
90         char            ct_mcall[MCALL_MSG_SIZE];       /* marshalled callmsg */
91         u_int           ct_mpos;                        /* pos after marshal */
92         XDR             ct_xdrs;
93 };
94
95 /*
96  * Create a client handle for a tcp/ip connection.
97  * If *sockp<0, *sockp is set to a newly created TCP socket and it is
98  * connected to raddr.  If *sockp non-negative then
99  * raddr is ignored.  The rpc/tcp package does buffering
100  * similar to stdio, so the client must pick send and receive buffer sizes,];
101  * 0 => use the default.
102  * If raddr->sin_port is 0, then a binder on the remote machine is
103  * consulted for the right port number.
104  * NB: *sockp is copied into a private area.
105  * NB: It is the clients responsibility to close *sockp.
106  * NB: The rpch->cl_auth is set null authentication.  Caller may wish to set this
107  * something more useful.
108  */
109 CLIENT *
110 clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz)
111         struct sockaddr_in *raddr;
112         u_long prog;
113         u_long vers;
114         register int *sockp;
115         u_int sendsz;
116         u_int recvsz;
117 {
118         CLIENT *h;
119         register struct ct_data *ct;
120         struct timeval now;
121         struct rpc_msg call_msg;
122
123         h  = (CLIENT *)mem_alloc(sizeof(*h));
124         if (h == NULL) {
125                 (void)fprintf(stderr, "clnttcp_create: out of memory\n");
126                 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
127                 rpc_createerr.cf_error.re_errno = errno;
128                 goto fooy;
129         }
130         ct = (struct ct_data *)mem_alloc(sizeof(*ct));
131         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;
136         }
137
138         /*
139          * If no port number given ask the pmap for one
140          */
141         if (raddr->sin_port == 0) {
142                 u_short port;
143                 if ((port = pmap_getport(raddr, prog, vers, IPPROTO_TCP)) == 0) {
144                         mem_free((caddr_t)ct, sizeof(struct ct_data));
145                         mem_free((caddr_t)h, sizeof(CLIENT));
146                         return ((CLIENT *)NULL);
147                 }
148                 raddr->sin_port = htons(port);
149         }
150
151         /*
152          * If no socket given, open one
153          */
154         if (*sockp < 0) {
155                 *sockp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
156                 (void)bindresvport(*sockp, (struct sockaddr_in *)0);
157                 if ((*sockp < 0)
158                     || (connect(*sockp, (struct sockaddr *)raddr,
159                     sizeof(*raddr)) < 0)) {
160                         rpc_createerr.cf_stat = RPC_SYSTEMERROR;
161                         rpc_createerr.cf_error.re_errno = errno;
162                         if (*sockp >= 0)
163                           (void)close(*sockp);
164                         goto fooy;
165                 }
166                 ct->ct_closeit = TRUE;
167         } else {
168                 ct->ct_closeit = FALSE;
169         }
170
171         /*
172          * Set up private data struct
173          */
174         ct->ct_sock = *sockp;
175         ct->ct_wait.tv_usec = 0;
176         ct->ct_waitset = FALSE;
177         ct->ct_addr = *raddr;
178
179         /*
180          * Initialize call message
181          */
182         (void)gettimeofday(&now, (struct timezone *)0);
183         call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec;
184         call_msg.rm_direction = CALL;
185         call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
186         call_msg.rm_call.cb_prog = prog;
187         call_msg.rm_call.cb_vers = vers;
188
189         /*
190          * pre-serialize the staic part of the call msg and stash it away
191          */
192         xdrmem_create(&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
193             XDR_ENCODE);
194         if (! xdr_callhdr(&(ct->ct_xdrs), &call_msg)) {
195                 if (ct->ct_closeit) {
196                         (void)close(*sockp);
197                 }
198                 goto fooy;
199         }
200         ct->ct_mpos = XDR_GETPOS(&(ct->ct_xdrs));
201         XDR_DESTROY(&(ct->ct_xdrs));
202
203         /*
204          * Create a client handle which uses xdrrec for serialization
205          * and authnone for authentication.
206          */
207         xdrrec_create(&(ct->ct_xdrs), sendsz, recvsz,
208             (caddr_t)ct, readtcp, writetcp);
209         h->cl_ops = &tcp_ops;
210         h->cl_private = (caddr_t) ct;
211         h->cl_auth = authnone_create();
212         return (h);
213
214 fooy:
215         /*
216          * Something goofed, free stuff and barf
217          */
218         mem_free((caddr_t)ct, sizeof(struct ct_data));
219         mem_free((caddr_t)h, sizeof(CLIENT));
220         return ((CLIENT *)NULL);
221 }
222
223 static enum clnt_stat
224 clnttcp_call(h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
225         register CLIENT *h;
226         u_long proc;
227         xdrproc_t xdr_args;
228         caddr_t args_ptr;
229         xdrproc_t xdr_results;
230         caddr_t results_ptr;
231         struct timeval timeout;
232 {
233         register struct ct_data *ct = (struct ct_data *) h->cl_private;
234         register XDR *xdrs = &(ct->ct_xdrs);
235         struct rpc_msg reply_msg;
236         u_long x_id;
237         u_int32_t *msg_x_id = (u_int32_t *)(ct->ct_mcall);      /* yuk */
238         register bool_t shipnow;
239         int refreshes = 2;
240
241         if (!ct->ct_waitset) {
242                 ct->ct_wait = timeout;
243         }
244
245         shipnow =
246             (xdr_results == (xdrproc_t)0 && timeout.tv_sec == 0
247             && timeout.tv_usec == 0) ? FALSE : TRUE;
248
249 call_again:
250         xdrs->x_op = XDR_ENCODE;
251         ct->ct_error.re_status = RPC_SUCCESS;
252         x_id = ntohl(--(*msg_x_id));
253         if ((! XDR_PUTBYTES(xdrs, ct->ct_mcall, ct->ct_mpos)) ||
254             (! XDR_PUTLONG(xdrs, (long *)&proc)) ||
255             (! AUTH_MARSHALL(h->cl_auth, xdrs)) ||
256             (! (*xdr_args)(xdrs, args_ptr))) {
257                 if (ct->ct_error.re_status == RPC_SUCCESS)
258                         ct->ct_error.re_status = RPC_CANTENCODEARGS;
259                 (void)xdrrec_endofrecord(xdrs, TRUE);
260                 return (ct->ct_error.re_status);
261         }
262         if (! xdrrec_endofrecord(xdrs, shipnow))
263                 return (ct->ct_error.re_status = RPC_CANTSEND);
264         if (! shipnow)
265                 return (RPC_SUCCESS);
266         /*
267          * Hack to provide rpc-based message passing
268          */
269         if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
270                 return(ct->ct_error.re_status = RPC_TIMEDOUT);
271         }
272
273
274         /*
275          * Keep receiving until we get a valid transaction id
276          */
277         xdrs->x_op = XDR_DECODE;
278         while (TRUE) {
279                 reply_msg.acpted_rply.ar_verf = _null_auth;
280                 reply_msg.acpted_rply.ar_results.where = NULL;
281                 reply_msg.acpted_rply.ar_results.proc = xdr_void;
282                 if (! xdrrec_skiprecord(xdrs))
283                         return (ct->ct_error.re_status);
284                 /* now decode and validate the response header */
285                 if (! xdr_replymsg(xdrs, &reply_msg)) {
286                         if (ct->ct_error.re_status == RPC_SUCCESS)
287                                 continue;
288                         return (ct->ct_error.re_status);
289                 }
290                 if (reply_msg.rm_xid == x_id)
291                         break;
292         }
293
294         /*
295          * process header
296          */
297         _seterr_reply(&reply_msg, &(ct->ct_error));
298         if (ct->ct_error.re_status == RPC_SUCCESS) {
299                 if (! AUTH_VALIDATE(h->cl_auth, &reply_msg.acpted_rply.ar_verf)) {
300                         ct->ct_error.re_status = RPC_AUTHERROR;
301                         ct->ct_error.re_why = AUTH_INVALIDRESP;
302                 } else if (! (*xdr_results)(xdrs, results_ptr)) {
303                         if (ct->ct_error.re_status == RPC_SUCCESS)
304                                 ct->ct_error.re_status = RPC_CANTDECODERES;
305                 }
306                 /* free verifier ... */
307                 if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
308                         xdrs->x_op = XDR_FREE;
309                         (void)xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf));
310                 }
311         }  /* end successful completion */
312         else {
313                 /* maybe our credentials need to be refreshed ... */
314                 if (refreshes-- && AUTH_REFRESH(h->cl_auth))
315                         goto call_again;
316         }  /* end of unsuccessful completion */
317         return (ct->ct_error.re_status);
318 }
319
320 static void
321 clnttcp_geterr(h, errp)
322         CLIENT *h;
323         struct rpc_err *errp;
324 {
325         register struct ct_data *ct =
326             (struct ct_data *) h->cl_private;
327
328         *errp = ct->ct_error;
329 }
330
331 static bool_t
332 clnttcp_freeres(cl, xdr_res, res_ptr)
333         CLIENT *cl;
334         xdrproc_t xdr_res;
335         caddr_t res_ptr;
336 {
337         register struct ct_data *ct = (struct ct_data *)cl->cl_private;
338         register XDR *xdrs = &(ct->ct_xdrs);
339
340         xdrs->x_op = XDR_FREE;
341         return ((*xdr_res)(xdrs, res_ptr));
342 }
343
344 static void
345 clnttcp_abort()
346 {
347 }
348
349 static bool_t
350 clnttcp_control(cl, request, info)
351         CLIENT *cl;
352         int request;
353         char *info;
354 {
355         register struct ct_data *ct = (struct ct_data *)cl->cl_private;
356
357         switch (request) {
358         case CLSET_TIMEOUT:
359                 ct->ct_wait = *(struct timeval *)info;
360                 ct->ct_waitset = TRUE;
361                 break;
362         case CLGET_TIMEOUT:
363                 *(struct timeval *)info = ct->ct_wait;
364                 break;
365         case CLGET_SERVER_ADDR:
366                 *(struct sockaddr_in *)info = ct->ct_addr;
367                 break;
368         default:
369                 return (FALSE);
370         }
371         return (TRUE);
372 }
373
374
375 static void
376 clnttcp_destroy(h)
377         CLIENT *h;
378 {
379         register struct ct_data *ct =
380             (struct ct_data *) h->cl_private;
381
382         if (ct->ct_closeit) {
383                 (void)close(ct->ct_sock);
384         }
385         XDR_DESTROY(&(ct->ct_xdrs));
386         mem_free((caddr_t)ct, sizeof(struct ct_data));
387         mem_free((caddr_t)h, sizeof(CLIENT));
388 }
389
390 /*
391  * Interface between xdr serializer and tcp connection.
392  * Behaves like the system calls, read & write, but keeps some error state
393  * around for the rpc level.
394  */
395 static int
396 readtcp(ct, buf, len)
397         register struct ct_data *ct;
398         caddr_t buf;
399         register int len;
400 {
401 #ifdef FD_SETSIZE
402         fd_set mask;
403         fd_set readfds;
404
405         if (len == 0)
406                 return (0);
407         FD_ZERO(&mask);
408         FD_SET(ct->ct_sock, &mask);
409 #else
410         register int mask = 1 << (ct->ct_sock);
411         int readfds;
412
413         if (len == 0)
414                 return (0);
415
416 #endif /* def FD_SETSIZE */
417         while (TRUE) {
418                 readfds = mask;
419                 switch (select(_rpc_dtablesize(), &readfds, (int*)NULL, (int*)NULL,
420                                &(ct->ct_wait))) {
421                 case 0:
422                         ct->ct_error.re_status = RPC_TIMEDOUT;
423                         return (-1);
424
425                 case -1:
426                         if (errno == EINTR)
427                                 continue;
428                         ct->ct_error.re_status = RPC_CANTRECV;
429                         ct->ct_error.re_errno = errno;
430                         return (-1);
431                 }
432                 break;
433         }
434         switch (len = read(ct->ct_sock, buf, len)) {
435
436         case 0:
437                 /* premature eof */
438                 ct->ct_error.re_errno = ECONNRESET;
439                 ct->ct_error.re_status = RPC_CANTRECV;
440                 len = -1;  /* it's really an error */
441                 break;
442
443         case -1:
444                 ct->ct_error.re_errno = errno;
445                 ct->ct_error.re_status = RPC_CANTRECV;
446                 break;
447         }
448         return (len);
449 }
450
451 static int
452 writetcp(ct, buf, len)
453         struct ct_data *ct;
454         caddr_t buf;
455         int len;
456 {
457         register int i, cnt;
458
459         for (cnt = len; cnt > 0; cnt -= i, buf += i) {
460                 if ((i = write(ct->ct_sock, buf, cnt)) == -1) {
461                         ct->ct_error.re_errno = errno;
462                         ct->ct_error.re_status = RPC_CANTSEND;
463                         return (-1);
464                 }
465         }
466         return (len);
467 }