(clnttcp_call): Resolve 32-64 comparison conflict for 64 bit platforms.
[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 <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>
61
62 extern u_long _create_xid (void);
63
64 #define MCALL_MSG_SIZE 24
65
66 struct ct_data
67   {
68     int ct_sock;
69     bool_t ct_closeit;
70     struct timeval ct_wait;
71     bool_t ct_waitset;          /* wait set by clnt_control? */
72     struct sockaddr_in ct_addr;
73     struct rpc_err ct_error;
74     char ct_mcall[MCALL_MSG_SIZE];      /* marshalled callmsg */
75     u_int ct_mpos;              /* pos after marshal */
76     XDR ct_xdrs;
77   };
78
79 static int readtcp (char *, char *, int);
80 static int writetcp (char *, char *, int);
81
82 static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
83                                     xdrproc_t, caddr_t, struct timeval);
84 static void clnttcp_abort (void);
85 static void clnttcp_geterr (CLIENT *, struct rpc_err *);
86 static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, caddr_t);
87 static bool_t clnttcp_control (CLIENT *, int, char *);
88 static void clnttcp_destroy (CLIENT *);
89
90 static struct clnt_ops tcp_ops =
91 {
92   clnttcp_call,
93   clnttcp_abort,
94   clnttcp_geterr,
95   clnttcp_freeres,
96   clnttcp_destroy,
97   clnttcp_control
98 };
99
100 /*
101  * Create a client handle for a tcp/ip connection.
102  * If *sockp<0, *sockp is set to a newly created TCP socket and it is
103  * connected to raddr.  If *sockp non-negative then
104  * raddr is ignored.  The rpc/tcp package does buffering
105  * similar to stdio, so the client must pick send and receive buffer sizes,];
106  * 0 => use the default.
107  * If raddr->sin_port is 0, then a binder on the remote machine is
108  * consulted for the right port number.
109  * NB: *sockp is copied into a private area.
110  * NB: It is the clients responsibility to close *sockp.
111  * NB: The rpch->cl_auth is set null authentication.  Caller may wish to set this
112  * something more useful.
113  */
114 CLIENT *
115 clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
116                 int *sockp, u_int sendsz, u_int recvsz)
117 {
118   CLIENT *h;
119   struct ct_data *ct = (struct ct_data *) mem_alloc (sizeof (*ct));
120   struct rpc_msg call_msg;
121
122   h = (CLIENT *) mem_alloc (sizeof (*h));
123   if (h == NULL)
124     {
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     {
133       (void) fprintf (stderr, _("clnttcp_create: out of memory\n"));
134       rpc_createerr.cf_stat = RPC_SYSTEMERROR;
135       rpc_createerr.cf_error.re_errno = errno;
136       goto fooy;
137     }
138
139   /*
140    * If no port number given ask the pmap for one
141    */
142   if (raddr->sin_port == 0)
143     {
144       u_short port;
145       if ((port = pmap_getport (raddr, prog, vers, IPPROTO_TCP)) == 0)
146         {
147           mem_free ((caddr_t) ct, sizeof (struct ct_data));
148           mem_free ((caddr_t) h, sizeof (CLIENT));
149           return ((CLIENT *) NULL);
150         }
151       raddr->sin_port = htons (port);
152     }
153
154   /*
155    * If no socket given, open one
156    */
157   if (*sockp < 0)
158     {
159       *sockp = __socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
160       (void) bindresvport (*sockp, (struct sockaddr_in *) 0);
161       if ((*sockp < 0)
162           || (__connect (*sockp, (struct sockaddr *) raddr,
163                          sizeof (*raddr)) < 0))
164         {
165           rpc_createerr.cf_stat = RPC_SYSTEMERROR;
166           rpc_createerr.cf_error.re_errno = errno;
167           if (*sockp >= 0)
168             (void) __close (*sockp);
169           goto fooy;
170         }
171       ct->ct_closeit = TRUE;
172     }
173   else
174     {
175       ct->ct_closeit = FALSE;
176     }
177
178   /*
179    * Set up private data struct
180    */
181   ct->ct_sock = *sockp;
182   ct->ct_wait.tv_usec = 0;
183   ct->ct_waitset = FALSE;
184   ct->ct_addr = *raddr;
185
186   /*
187    * Initialize call message
188    */
189   call_msg.rm_xid = _create_xid ();
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;
194
195   /*
196    * pre-serialize the static part of the call msg and stash it away
197    */
198   xdrmem_create (&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
199                  XDR_ENCODE);
200   if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg))
201     {
202       if (ct->ct_closeit)
203         {
204           (void) __close (*sockp);
205         }
206       goto fooy;
207     }
208   ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs));
209   XDR_DESTROY (&(ct->ct_xdrs));
210
211   /*
212    * Create a client handle which uses xdrrec for serialization
213    * and authnone for authentication.
214    */
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;
221
222 fooy:
223   /*
224    * Something goofed, free stuff and barf
225    */
226   mem_free ((caddr_t) ct, sizeof (struct ct_data));
227   mem_free ((caddr_t) h, sizeof (CLIENT));
228   return ((CLIENT *) NULL);
229 }
230
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;
240 {
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;
248
249   if (!ct->ct_waitset)
250     {
251       ct->ct_wait = timeout;
252     }
253
254   shipnow =
255     (xdr_results == (xdrproc_t) 0 && timeout.tv_sec == 0
256      && timeout.tv_usec == 0) ? FALSE : TRUE;
257
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)))
266     {
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);
271     }
272   if (!xdrrec_endofrecord (xdrs, shipnow))
273     return ct->ct_error.re_status = RPC_CANTSEND;
274   if (!shipnow)
275     return RPC_SUCCESS;
276   /*
277    * Hack to provide rpc-based message passing
278    */
279   if (timeout.tv_sec == 0 && timeout.tv_usec == 0)
280     {
281       return ct->ct_error.re_status = RPC_TIMEDOUT;
282     }
283
284
285   /*
286    * Keep receiving until we get a valid transaction id
287    */
288   xdrs->x_op = XDR_DECODE;
289   while (TRUE)
290     {
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))
298         {
299           if (ct->ct_error.re_status == RPC_SUCCESS)
300             continue;
301           return ct->ct_error.re_status;
302         }
303       if ((u_int32_t) reply_msg.rm_xid == x_id)
304         break;
305     }
306
307   /*
308    * process header
309    */
310   _seterr_reply (&reply_msg, &(ct->ct_error));
311   if (ct->ct_error.re_status == RPC_SUCCESS)
312     {
313       if (!AUTH_VALIDATE (h->cl_auth, &reply_msg.acpted_rply.ar_verf))
314         {
315           ct->ct_error.re_status = RPC_AUTHERROR;
316           ct->ct_error.re_why = AUTH_INVALIDRESP;
317         }
318       else if (!(*xdr_results) (xdrs, results_ptr))
319         {
320           if (ct->ct_error.re_status == RPC_SUCCESS)
321             ct->ct_error.re_status = RPC_CANTDECODERES;
322         }
323       /* free verifier ... */
324       if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
325         {
326           xdrs->x_op = XDR_FREE;
327           (void) xdr_opaque_auth (xdrs, &(reply_msg.acpted_rply.ar_verf));
328         }
329     }                           /* end successful completion */
330   else
331     {
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;
337 }
338
339 static void
340 clnttcp_geterr (h, errp)
341      CLIENT *h;
342      struct rpc_err *errp;
343 {
344   struct ct_data *ct =
345   (struct ct_data *) h->cl_private;
346
347   *errp = ct->ct_error;
348 }
349
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;
355 {
356   struct ct_data *ct = (struct ct_data *) cl->cl_private;
357   XDR *xdrs = &(ct->ct_xdrs);
358
359   xdrs->x_op = XDR_FREE;
360   return (*xdr_res) (xdrs, res_ptr);
361 }
362
363 static void
364 clnttcp_abort ()
365 {
366 }
367
368 static bool_t
369 clnttcp_control (CLIENT *cl, int request, char *info)
370 {
371   struct ct_data *ct = (struct ct_data *) cl->cl_private;
372
373
374   switch (request)
375     {
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:
396       /*
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
400        */
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:
408       /*
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
413        */
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:
422       /*
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
427        */
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;
444     }
445   return TRUE;
446 }
447
448
449 static void
450 clnttcp_destroy (CLIENT *h)
451 {
452   struct ct_data *ct =
453   (struct ct_data *) h->cl_private;
454
455   if (ct->ct_closeit)
456     {
457       (void) __close (ct->ct_sock);
458     }
459   XDR_DESTROY (&(ct->ct_xdrs));
460   mem_free ((caddr_t) ct, sizeof (struct ct_data));
461   mem_free ((caddr_t) h, sizeof (CLIENT));
462 }
463
464 /*
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.
468  */
469 static int
470 readtcp (char *ctptr, char *buf, int len)
471 {
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);
476
477   if (len == 0)
478     return 0;
479
480   fd.fd = ct->ct_sock;
481   fd.events = POLLIN;
482   while (TRUE)
483     {
484       switch (__poll(&fd, 1, milliseconds))
485         {
486         case 0:
487           ct->ct_error.re_status = RPC_TIMEDOUT;
488           return -1;
489
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;
496         }
497       break;
498     }
499   switch (len = __read (ct->ct_sock, buf, len))
500     {
501
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;
508
509     case -1:
510       ct->ct_error.re_errno = errno;
511       ct->ct_error.re_status = RPC_CANTRECV;
512       break;
513     }
514   return len;
515 }
516
517 static int
518 writetcp (char *ctptr, char *buf, int len)
519 {
520   int i, cnt;
521   struct ct_data *ct = (struct ct_data*)ctptr;
522
523   for (cnt = len; cnt > 0; cnt -= i, buf += i)
524     {
525       if ((i = __write (ct->ct_sock, buf, cnt)) == -1)
526         {
527           ct->ct_error.re_errno = errno;
528           ct->ct_error.re_status = RPC_CANTSEND;
529           return -1;
530         }
531     }
532   return len;
533 }