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