Include libintl.h.
[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 <libintl.h>
58 #include <rpc/rpc.h>
59 #include <sys/poll.h>
60 #include <sys/socket.h>
61 #include <rpc/pmap_clnt.h>
62
63 extern u_long _create_xid (void);
64
65 #define MCALL_MSG_SIZE 24
66
67 struct ct_data
68   {
69     int ct_sock;
70     bool_t ct_closeit;
71     struct timeval ct_wait;
72     bool_t ct_waitset;          /* wait set by clnt_control? */
73     struct sockaddr_in ct_addr;
74     struct rpc_err ct_error;
75     char ct_mcall[MCALL_MSG_SIZE];      /* marshalled callmsg */
76     u_int ct_mpos;              /* pos after marshal */
77     XDR ct_xdrs;
78   };
79
80 static int readtcp (char *, char *, int);
81 static int writetcp (char *, char *, int);
82
83 static enum clnt_stat clnttcp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
84                                     xdrproc_t, caddr_t, struct timeval);
85 static void clnttcp_abort (void);
86 static void clnttcp_geterr (CLIENT *, struct rpc_err *);
87 static bool_t clnttcp_freeres (CLIENT *, xdrproc_t, caddr_t);
88 static bool_t clnttcp_control (CLIENT *, int, char *);
89 static void clnttcp_destroy (CLIENT *);
90
91 static struct clnt_ops tcp_ops =
92 {
93   clnttcp_call,
94   clnttcp_abort,
95   clnttcp_geterr,
96   clnttcp_freeres,
97   clnttcp_destroy,
98   clnttcp_control
99 };
100
101 /*
102  * Create a client handle for a tcp/ip connection.
103  * If *sockp<0, *sockp is set to a newly created TCP socket and it is
104  * connected to raddr.  If *sockp non-negative then
105  * raddr is ignored.  The rpc/tcp package does buffering
106  * similar to stdio, so the client must pick send and receive buffer sizes,];
107  * 0 => use the default.
108  * If raddr->sin_port is 0, then a binder on the remote machine is
109  * consulted for the right port number.
110  * NB: *sockp is copied into a private area.
111  * NB: It is the clients responsibility to close *sockp.
112  * NB: The rpch->cl_auth is set null authentication.  Caller may wish to set this
113  * something more useful.
114  */
115 CLIENT *
116 clnttcp_create (struct sockaddr_in *raddr, u_long prog, u_long vers,
117                 int *sockp, u_int sendsz, u_int recvsz)
118 {
119   CLIENT *h;
120   struct ct_data *ct = (struct ct_data *) mem_alloc (sizeof (*ct));
121   struct rpc_msg call_msg;
122
123   h = (CLIENT *) mem_alloc (sizeof (*h));
124   if (h == NULL)
125     {
126       (void) fprintf (stderr, _("clnttcp_create: out of memory\n"));
127       rpc_createerr.cf_stat = RPC_SYSTEMERROR;
128       rpc_createerr.cf_error.re_errno = errno;
129       goto fooy;
130     }
131   /*  ct = (struct ct_data *) mem_alloc (sizeof (*ct)); */
132   if (ct == NULL)
133     {
134       (void) fprintf (stderr, _("clnttcp_create: out of memory\n"));
135       rpc_createerr.cf_stat = RPC_SYSTEMERROR;
136       rpc_createerr.cf_error.re_errno = errno;
137       goto fooy;
138     }
139
140   /*
141    * If no port number given ask the pmap for one
142    */
143   if (raddr->sin_port == 0)
144     {
145       u_short port;
146       if ((port = pmap_getport (raddr, prog, vers, IPPROTO_TCP)) == 0)
147         {
148           mem_free ((caddr_t) ct, sizeof (struct ct_data));
149           mem_free ((caddr_t) h, sizeof (CLIENT));
150           return ((CLIENT *) NULL);
151         }
152       raddr->sin_port = htons (port);
153     }
154
155   /*
156    * If no socket given, open one
157    */
158   if (*sockp < 0)
159     {
160       *sockp = __socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
161       (void) bindresvport (*sockp, (struct sockaddr_in *) 0);
162       if ((*sockp < 0)
163           || (__connect (*sockp, (struct sockaddr *) raddr,
164                          sizeof (*raddr)) < 0))
165         {
166           rpc_createerr.cf_stat = RPC_SYSTEMERROR;
167           rpc_createerr.cf_error.re_errno = errno;
168           if (*sockp >= 0)
169             (void) __close (*sockp);
170           goto fooy;
171         }
172       ct->ct_closeit = TRUE;
173     }
174   else
175     {
176       ct->ct_closeit = FALSE;
177     }
178
179   /*
180    * Set up private data struct
181    */
182   ct->ct_sock = *sockp;
183   ct->ct_wait.tv_usec = 0;
184   ct->ct_waitset = FALSE;
185   ct->ct_addr = *raddr;
186
187   /*
188    * Initialize call message
189    */
190   call_msg.rm_xid = _create_xid ();
191   call_msg.rm_direction = CALL;
192   call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
193   call_msg.rm_call.cb_prog = prog;
194   call_msg.rm_call.cb_vers = vers;
195
196   /*
197    * pre-serialize the static part of the call msg and stash it away
198    */
199   xdrmem_create (&(ct->ct_xdrs), ct->ct_mcall, MCALL_MSG_SIZE,
200                  XDR_ENCODE);
201   if (!xdr_callhdr (&(ct->ct_xdrs), &call_msg))
202     {
203       if (ct->ct_closeit)
204         {
205           (void) __close (*sockp);
206         }
207       goto fooy;
208     }
209   ct->ct_mpos = XDR_GETPOS (&(ct->ct_xdrs));
210   XDR_DESTROY (&(ct->ct_xdrs));
211
212   /*
213    * Create a client handle which uses xdrrec for serialization
214    * and authnone for authentication.
215    */
216   xdrrec_create (&(ct->ct_xdrs), sendsz, recvsz,
217                  (caddr_t) ct, readtcp, writetcp);
218   h->cl_ops = &tcp_ops;
219   h->cl_private = (caddr_t) ct;
220   h->cl_auth = authnone_create ();
221   return h;
222
223 fooy:
224   /*
225    * Something goofed, free stuff and barf
226    */
227   mem_free ((caddr_t) ct, sizeof (struct ct_data));
228   mem_free ((caddr_t) h, sizeof (CLIENT));
229   return ((CLIENT *) NULL);
230 }
231
232 static enum clnt_stat
233 clnttcp_call (h, proc, xdr_args, args_ptr, xdr_results, results_ptr, timeout)
234      CLIENT *h;
235      u_long proc;
236      xdrproc_t xdr_args;
237      caddr_t args_ptr;
238      xdrproc_t xdr_results;
239      caddr_t results_ptr;
240      struct timeval timeout;
241 {
242   struct ct_data *ct = (struct ct_data *) h->cl_private;
243   XDR *xdrs = &(ct->ct_xdrs);
244   struct rpc_msg reply_msg;
245   u_long x_id;
246   u_int32_t *msg_x_id = (u_int32_t *) (ct->ct_mcall);   /* yuk */
247   bool_t shipnow;
248   int refreshes = 2;
249
250   if (!ct->ct_waitset)
251     {
252       ct->ct_wait = timeout;
253     }
254
255   shipnow =
256     (xdr_results == (xdrproc_t) 0 && timeout.tv_sec == 0
257      && timeout.tv_usec == 0) ? FALSE : TRUE;
258
259 call_again:
260   xdrs->x_op = XDR_ENCODE;
261   ct->ct_error.re_status = RPC_SUCCESS;
262   x_id = ntohl (--(*msg_x_id));
263   if ((!XDR_PUTBYTES (xdrs, ct->ct_mcall, ct->ct_mpos)) ||
264       (!XDR_PUTLONG (xdrs, (long *) &proc)) ||
265       (!AUTH_MARSHALL (h->cl_auth, xdrs)) ||
266       (!(*xdr_args) (xdrs, args_ptr)))
267     {
268       if (ct->ct_error.re_status == RPC_SUCCESS)
269         ct->ct_error.re_status = RPC_CANTENCODEARGS;
270       (void) xdrrec_endofrecord (xdrs, TRUE);
271       return (ct->ct_error.re_status);
272     }
273   if (!xdrrec_endofrecord (xdrs, shipnow))
274     return ct->ct_error.re_status = RPC_CANTSEND;
275   if (!shipnow)
276     return RPC_SUCCESS;
277   /*
278    * Hack to provide rpc-based message passing
279    */
280   if (timeout.tv_sec == 0 && timeout.tv_usec == 0)
281     {
282       return ct->ct_error.re_status = RPC_TIMEDOUT;
283     }
284
285
286   /*
287    * Keep receiving until we get a valid transaction id
288    */
289   xdrs->x_op = XDR_DECODE;
290   while (TRUE)
291     {
292       reply_msg.acpted_rply.ar_verf = _null_auth;
293       reply_msg.acpted_rply.ar_results.where = NULL;
294       reply_msg.acpted_rply.ar_results.proc = (xdrproc_t)xdr_void;
295       if (!xdrrec_skiprecord (xdrs))
296         return (ct->ct_error.re_status);
297       /* now decode and validate the response header */
298       if (!xdr_replymsg (xdrs, &reply_msg))
299         {
300           if (ct->ct_error.re_status == RPC_SUCCESS)
301             continue;
302           return ct->ct_error.re_status;
303         }
304       if ((u_int32_t) reply_msg.rm_xid == (u_int32_t) x_id)
305         break;
306     }
307
308   /*
309    * process header
310    */
311   _seterr_reply (&reply_msg, &(ct->ct_error));
312   if (ct->ct_error.re_status == RPC_SUCCESS)
313     {
314       if (!AUTH_VALIDATE (h->cl_auth, &reply_msg.acpted_rply.ar_verf))
315         {
316           ct->ct_error.re_status = RPC_AUTHERROR;
317           ct->ct_error.re_why = AUTH_INVALIDRESP;
318         }
319       else if (!(*xdr_results) (xdrs, results_ptr))
320         {
321           if (ct->ct_error.re_status == RPC_SUCCESS)
322             ct->ct_error.re_status = RPC_CANTDECODERES;
323         }
324       /* free verifier ... */
325       if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
326         {
327           xdrs->x_op = XDR_FREE;
328           (void) xdr_opaque_auth (xdrs, &(reply_msg.acpted_rply.ar_verf));
329         }
330     }                           /* end successful completion */
331   else
332     {
333       /* maybe our credentials need to be refreshed ... */
334       if (refreshes-- && AUTH_REFRESH (h->cl_auth))
335         goto call_again;
336     }                           /* end of unsuccessful completion */
337   return ct->ct_error.re_status;
338 }
339
340 static void
341 clnttcp_geterr (h, errp)
342      CLIENT *h;
343      struct rpc_err *errp;
344 {
345   struct ct_data *ct =
346   (struct ct_data *) h->cl_private;
347
348   *errp = ct->ct_error;
349 }
350
351 static bool_t
352 clnttcp_freeres (cl, xdr_res, res_ptr)
353      CLIENT *cl;
354      xdrproc_t xdr_res;
355      caddr_t res_ptr;
356 {
357   struct ct_data *ct = (struct ct_data *) cl->cl_private;
358   XDR *xdrs = &(ct->ct_xdrs);
359
360   xdrs->x_op = XDR_FREE;
361   return (*xdr_res) (xdrs, res_ptr);
362 }
363
364 static void
365 clnttcp_abort ()
366 {
367 }
368
369 static bool_t
370 clnttcp_control (CLIENT *cl, int request, char *info)
371 {
372   struct ct_data *ct = (struct ct_data *) cl->cl_private;
373
374
375   switch (request)
376     {
377     case CLSET_FD_CLOSE:
378       ct->ct_closeit = TRUE;
379       break;
380     case CLSET_FD_NCLOSE:
381       ct->ct_closeit = FALSE;
382       break;
383     case CLSET_TIMEOUT:
384       ct->ct_wait = *(struct timeval *) info;
385       ct->ct_waitset = TRUE;
386       break;
387     case CLGET_TIMEOUT:
388       *(struct timeval *) info = ct->ct_wait;
389       break;
390     case CLGET_SERVER_ADDR:
391       *(struct sockaddr_in *) info = ct->ct_addr;
392       break;
393     case CLGET_FD:
394       *(int *)info = ct->ct_sock;
395       break;
396     case CLGET_XID:
397       /*
398        * use the knowledge that xid is the
399        * first element in the call structure *.
400        * This will get the xid of the PREVIOUS call
401        */
402       *(u_long *)info = ntohl (*(u_long *)ct->ct_mcall);
403       break;
404     case CLSET_XID:
405       /* This will set the xid of the NEXT call */
406       *(u_long *)ct->ct_mcall =  htonl (*(u_long *)info - 1);
407       /* decrement by 1 as clnttcp_call() increments once */
408     case CLGET_VERS:
409       /*
410        * This RELIES on the information that, in the call body,
411        * the version number field is the fifth field from the
412        * begining of the RPC header. MUST be changed if the
413        * call_struct is changed
414        */
415       *(u_long *)info = ntohl (*(u_long *)(ct->ct_mcall +
416                                            4 * BYTES_PER_XDR_UNIT));
417       break;
418     case CLSET_VERS:
419       *(u_long *)(ct->ct_mcall + 4 * BYTES_PER_XDR_UNIT)
420         = htonl (*(u_long *)info);
421       break;
422     case CLGET_PROG:
423       /*
424        * This RELIES on the information that, in the call body,
425        * the program number field is the  field from the
426        * begining of the RPC header. MUST be changed if the
427        * call_struct is changed
428        */
429       *(u_long *)info = ntohl(*(u_long *)(ct->ct_mcall +
430                                           3 * BYTES_PER_XDR_UNIT));
431       break;
432     case CLSET_PROG:
433       *(u_long *)(ct->ct_mcall + 3 * BYTES_PER_XDR_UNIT)
434         = htonl(*(u_long *)info);
435       break;
436     /* The following are only possible with TI-RPC */
437     case CLGET_RETRY_TIMEOUT:
438     case CLSET_RETRY_TIMEOUT:
439     case CLGET_SVC_ADDR:
440     case CLSET_SVC_ADDR:
441     case CLSET_PUSH_TIMOD:
442     case CLSET_POP_TIMOD:
443     default:
444       return FALSE;
445     }
446   return TRUE;
447 }
448
449
450 static void
451 clnttcp_destroy (CLIENT *h)
452 {
453   struct ct_data *ct =
454   (struct ct_data *) h->cl_private;
455
456   if (ct->ct_closeit)
457     {
458       (void) __close (ct->ct_sock);
459     }
460   XDR_DESTROY (&(ct->ct_xdrs));
461   mem_free ((caddr_t) ct, sizeof (struct ct_data));
462   mem_free ((caddr_t) h, sizeof (CLIENT));
463 }
464
465 /*
466  * Interface between xdr serializer and tcp connection.
467  * Behaves like the system calls, read & write, but keeps some error state
468  * around for the rpc level.
469  */
470 static int
471 readtcp (char *ctptr, char *buf, int len)
472 {
473   struct ct_data *ct = (struct ct_data *)ctptr;
474   struct pollfd fd;
475   int milliseconds = (ct->ct_wait.tv_sec * 1000) +
476     (ct->ct_wait.tv_usec / 1000);
477
478   if (len == 0)
479     return 0;
480
481   fd.fd = ct->ct_sock;
482   fd.events = POLLIN;
483   while (TRUE)
484     {
485       switch (__poll(&fd, 1, milliseconds))
486         {
487         case 0:
488           ct->ct_error.re_status = RPC_TIMEDOUT;
489           return -1;
490
491         case -1:
492           if (errno == EINTR)
493             continue;
494           ct->ct_error.re_status = RPC_CANTRECV;
495           ct->ct_error.re_errno = errno;
496           return -1;
497         }
498       break;
499     }
500   switch (len = __read (ct->ct_sock, buf, len))
501     {
502
503     case 0:
504       /* premature eof */
505       ct->ct_error.re_errno = ECONNRESET;
506       ct->ct_error.re_status = RPC_CANTRECV;
507       len = -1;                 /* it's really an error */
508       break;
509
510     case -1:
511       ct->ct_error.re_errno = errno;
512       ct->ct_error.re_status = RPC_CANTRECV;
513       break;
514     }
515   return len;
516 }
517
518 static int
519 writetcp (char *ctptr, char *buf, int len)
520 {
521   int i, cnt;
522   struct ct_data *ct = (struct ct_data*)ctptr;
523
524   for (cnt = len; cnt > 0; cnt -= i, buf += i)
525     {
526       if ((i = __write (ct->ct_sock, buf, cnt)) == -1)
527         {
528           ct->ct_error.re_errno = errno;
529           ct->ct_error.re_status = RPC_CANTSEND;
530           return -1;
531         }
532     }
533   return len;
534 }