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