Add more control flags.
[kopensolaris-gnu/glibc.git] / sunrpc / clnt_udp.c
1 /* @(#)clnt_udp.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_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
32 #endif
33
34 /*
35  * clnt_udp.c, Implements a UDP/IP based, client side RPC.
36  *
37  * Copyright (C) 1984, Sun Microsystems, Inc.
38  */
39
40 #include <stdio.h>
41 #include <unistd.h>
42 #include <rpc/rpc.h>
43 #include <rpc/xdr.h>
44 #include <rpc/clnt.h>
45 #include <sys/socket.h>
46 #include <sys/ioctl.h>
47 #include <netdb.h>
48 #include <errno.h>
49 #include <rpc/pmap_clnt.h>
50
51 extern bool_t xdr_opaque_auth (XDR *, struct opaque_auth *);
52
53 /*
54  * UDP bases client side rpc operations
55  */
56 static enum clnt_stat clntudp_call (CLIENT *, u_long, xdrproc_t, caddr_t,
57                                     xdrproc_t, caddr_t, struct timeval);
58 static void clntudp_abort (void);
59 static void clntudp_geterr (CLIENT *, struct rpc_err *);
60 static bool_t clntudp_freeres (CLIENT *, xdrproc_t, caddr_t);
61 static bool_t clntudp_control (CLIENT *, int, char *);
62 static void clntudp_destroy (CLIENT *);
63
64 static struct clnt_ops udp_ops =
65 {
66   clntudp_call,
67   clntudp_abort,
68   clntudp_geterr,
69   clntudp_freeres,
70   clntudp_destroy,
71   clntudp_control
72 };
73
74 /*
75  * Private data kept per client handle
76  */
77 struct cu_data
78   {
79     int cu_sock;
80     bool_t cu_closeit;
81     struct sockaddr_in cu_raddr;
82     int cu_rlen;
83     struct timeval cu_wait;
84     struct timeval cu_total;
85     struct rpc_err cu_error;
86     XDR cu_outxdrs;
87     u_int cu_xdrpos;
88     u_int cu_sendsz;
89     char *cu_outbuf;
90     u_int cu_recvsz;
91     char cu_inbuf[1];
92   };
93
94 /*
95  * Create a UDP based client handle.
96  * If *sockp<0, *sockp is set to a newly created UPD socket.
97  * If raddr->sin_port is 0 a binder on the remote machine
98  * is consulted for the correct port number.
99  * NB: It is the clients responsibility to close *sockp.
100  * NB: The rpch->cl_auth is initialized to null authentication.
101  *     Caller may wish to set this something more useful.
102  *
103  * wait is the amount of time used between retransmitting a call if
104  * no response has been heard; retransmission occurs until the actual
105  * rpc call times out.
106  *
107  * sendsz and recvsz are the maximum allowable packet sizes that can be
108  * sent and received.
109  */
110 CLIENT *
111 clntudp_bufcreate (raddr, program, version, wait, sockp, sendsz, recvsz)
112      struct sockaddr_in *raddr;
113      u_long program;
114      u_long version;
115      struct timeval wait;
116      int *sockp;
117      u_int sendsz;
118      u_int recvsz;
119 {
120   CLIENT *cl;
121   struct cu_data *cu = NULL;
122   struct timeval now;
123   struct rpc_msg call_msg;
124
125   cl = (CLIENT *) mem_alloc (sizeof (CLIENT));
126   if (cl == NULL)
127     {
128       (void) fprintf (stderr, _("clntudp_create: out of memory\n"));
129       rpc_createerr.cf_stat = RPC_SYSTEMERROR;
130       rpc_createerr.cf_error.re_errno = errno;
131       goto fooy;
132     }
133   sendsz = ((sendsz + 3) / 4) * 4;
134   recvsz = ((recvsz + 3) / 4) * 4;
135   cu = (struct cu_data *) mem_alloc (sizeof (*cu) + sendsz + recvsz);
136   if (cu == NULL)
137     {
138       (void) fprintf (stderr, _("clntudp_create: out of memory\n"));
139       rpc_createerr.cf_stat = RPC_SYSTEMERROR;
140       rpc_createerr.cf_error.re_errno = errno;
141       goto fooy;
142     }
143   cu->cu_outbuf = &cu->cu_inbuf[recvsz];
144
145   (void) gettimeofday (&now, (struct timezone *) 0);
146   if (raddr->sin_port == 0)
147     {
148       u_short port;
149       if ((port =
150            pmap_getport (raddr, program, version, IPPROTO_UDP)) == 0)
151         {
152           goto fooy;
153         }
154       raddr->sin_port = htons (port);
155     }
156   cl->cl_ops = &udp_ops;
157   cl->cl_private = (caddr_t) cu;
158   cu->cu_raddr = *raddr;
159   cu->cu_rlen = sizeof (cu->cu_raddr);
160   cu->cu_wait = wait;
161   cu->cu_total.tv_sec = -1;
162   cu->cu_total.tv_usec = -1;
163   cu->cu_sendsz = sendsz;
164   cu->cu_recvsz = recvsz;
165   call_msg.rm_xid = getpid () ^ now.tv_sec ^ now.tv_usec;
166   call_msg.rm_direction = CALL;
167   call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
168   call_msg.rm_call.cb_prog = program;
169   call_msg.rm_call.cb_vers = version;
170   xdrmem_create (&(cu->cu_outxdrs), cu->cu_outbuf,
171                  sendsz, XDR_ENCODE);
172   if (!xdr_callhdr (&(cu->cu_outxdrs), &call_msg))
173     {
174       goto fooy;
175     }
176   cu->cu_xdrpos = XDR_GETPOS (&(cu->cu_outxdrs));
177   if (*sockp < 0)
178     {
179       int dontblock = 1;
180
181       *sockp = socket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
182       if (*sockp < 0)
183         {
184           rpc_createerr.cf_stat = RPC_SYSTEMERROR;
185           rpc_createerr.cf_error.re_errno = errno;
186           goto fooy;
187         }
188       /* attempt to bind to prov port */
189       (void) bindresvport (*sockp, (struct sockaddr_in *) 0);
190       /* the sockets rpc controls are non-blocking */
191       (void) ioctl (*sockp, FIONBIO, (char *) &dontblock);
192       cu->cu_closeit = TRUE;
193     }
194   else
195     {
196       cu->cu_closeit = FALSE;
197     }
198   cu->cu_sock = *sockp;
199   cl->cl_auth = authnone_create ();
200   return cl;
201 fooy:
202   if (cu)
203     mem_free ((caddr_t) cu, sizeof (*cu) + sendsz + recvsz);
204   if (cl)
205     mem_free ((caddr_t) cl, sizeof (CLIENT));
206   return (CLIENT *) NULL;
207 }
208
209 CLIENT *
210 clntudp_create (raddr, program, version, wait, sockp)
211      struct sockaddr_in *raddr;
212      u_long program;
213      u_long version;
214      struct timeval wait;
215      int *sockp;
216 {
217
218   return clntudp_bufcreate (raddr, program, version, wait, sockp,
219                             UDPMSGSIZE, UDPMSGSIZE);
220 }
221
222 static enum clnt_stat
223 clntudp_call (cl, proc, xargs, argsp, xresults, resultsp, utimeout)
224      CLIENT *cl;        /* client handle */
225      u_long proc;               /* procedure number */
226      xdrproc_t xargs;           /* xdr routine for args */
227      caddr_t argsp;             /* pointer to args */
228      xdrproc_t xresults;        /* xdr routine for results */
229      caddr_t resultsp;          /* pointer to results */
230      struct timeval utimeout;   /* seconds to wait before giving up */
231 {
232   struct cu_data *cu = (struct cu_data *) cl->cl_private;
233   XDR *xdrs;
234   int outlen = 0;
235   int inlen;
236   socklen_t fromlen;
237 #ifdef FD_SETSIZE
238   fd_set readfds;
239   fd_set mask;
240 #else
241   int readfds;
242   int mask;
243 #endif /* def FD_SETSIZE */
244   struct sockaddr_in from;
245   struct rpc_msg reply_msg;
246   XDR reply_xdrs;
247   struct timeval time_waited;
248   bool_t ok;
249   int nrefreshes = 2;           /* number of times to refresh cred */
250   struct timeval timeout;
251
252   if (cu->cu_total.tv_usec == -1)
253     {
254       timeout = utimeout;       /* use supplied timeout */
255     }
256   else
257     {
258       timeout = cu->cu_total;   /* use default timeout */
259     }
260
261   time_waited.tv_sec = 0;
262   time_waited.tv_usec = 0;
263 call_again:
264   xdrs = &(cu->cu_outxdrs);
265   if (xargs == NULL)
266     goto get_reply;
267   xdrs->x_op = XDR_ENCODE;
268   XDR_SETPOS (xdrs, cu->cu_xdrpos);
269   /*
270    * the transaction is the first thing in the out buffer
271    */
272   (*(u_short *) (cu->cu_outbuf))++;
273   if ((!XDR_PUTLONG (xdrs, (long *) &proc)) ||
274       (!AUTH_MARSHALL (cl->cl_auth, xdrs)) ||
275       (!(*xargs) (xdrs, argsp)))
276     return (cu->cu_error.re_status = RPC_CANTENCODEARGS);
277   outlen = (int) XDR_GETPOS (xdrs);
278
279 send_again:
280   if (sendto (cu->cu_sock, cu->cu_outbuf, outlen, 0,
281               (struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen)
282       != outlen)
283     {
284       cu->cu_error.re_errno = errno;
285       return (cu->cu_error.re_status = RPC_CANTSEND);
286     }
287
288   /*
289    * Hack to provide rpc-based message passing
290    */
291   if (timeout.tv_sec == 0 && timeout.tv_usec == 0)
292     {
293       return (cu->cu_error.re_status = RPC_TIMEDOUT);
294     }
295  get_reply:
296   /*
297    * sub-optimal code appears here because we have
298    * some clock time to spare while the packets are in flight.
299    * (We assume that this is actually only executed once.)
300    */
301   reply_msg.acpted_rply.ar_verf = _null_auth;
302   reply_msg.acpted_rply.ar_results.where = resultsp;
303   reply_msg.acpted_rply.ar_results.proc = xresults;
304 #ifdef FD_SETSIZE
305   FD_ZERO (&mask);
306   FD_SET (cu->cu_sock, &mask);
307 #else
308   mask = 1 << cu->cu_sock;
309 #endif /* def FD_SETSIZE */
310   for (;;)
311     {
312       struct timeval cu_wait = cu->cu_wait;
313       readfds = mask;
314       switch (select (_rpc_dtablesize (), &readfds, (fd_set*) NULL,
315                       (fd_set*) NULL, &cu_wait))
316         {
317
318         case 0:
319           time_waited.tv_sec += cu->cu_wait.tv_sec;
320           time_waited.tv_usec += cu->cu_wait.tv_usec;
321           while (time_waited.tv_usec >= 1000000)
322             {
323               time_waited.tv_sec++;
324               time_waited.tv_usec -= 1000000;
325             }
326           if ((time_waited.tv_sec < timeout.tv_sec) ||
327               ((time_waited.tv_sec == timeout.tv_sec) &&
328                (time_waited.tv_usec < timeout.tv_usec)))
329             goto send_again;
330           return (cu->cu_error.re_status = RPC_TIMEDOUT);
331
332           /*
333            * buggy in other cases because time_waited is not being
334            * updated.
335            */
336         case -1:
337           if (errno == EINTR)
338             continue;
339           cu->cu_error.re_errno = errno;
340           return (cu->cu_error.re_status = RPC_CANTRECV);
341         }
342       do
343         {
344           fromlen = sizeof (struct sockaddr);
345           inlen = recvfrom (cu->cu_sock, cu->cu_inbuf,
346                             (int) cu->cu_recvsz, 0,
347                             (struct sockaddr *) &from, &fromlen);
348         }
349       while (inlen < 0 && errno == EINTR);
350       if (inlen < 0)
351         {
352           if (errno == EWOULDBLOCK)
353             continue;
354           cu->cu_error.re_errno = errno;
355           return (cu->cu_error.re_status = RPC_CANTRECV);
356         }
357       if (inlen < 4)
358         continue;
359
360       /* see if reply transaction id matches sent id.
361         Don't do this if we only wait for a replay */
362       if (xargs != NULL
363           && (*((u_int32_t *) (cu->cu_inbuf))
364               != *((u_int32_t *) (cu->cu_outbuf))))
365         continue;
366       /* we now assume we have the proper reply */
367       break;
368     }
369
370   /*
371    * now decode and validate the response
372    */
373   xdrmem_create (&reply_xdrs, cu->cu_inbuf, (u_int) inlen, XDR_DECODE);
374   ok = xdr_replymsg (&reply_xdrs, &reply_msg);
375   /* XDR_DESTROY(&reply_xdrs);  save a few cycles on noop destroy */
376   if (ok)
377     {
378       _seterr_reply (&reply_msg, &(cu->cu_error));
379       if (cu->cu_error.re_status == RPC_SUCCESS)
380         {
381           if (!AUTH_VALIDATE (cl->cl_auth,
382                               &reply_msg.acpted_rply.ar_verf))
383             {
384               cu->cu_error.re_status = RPC_AUTHERROR;
385               cu->cu_error.re_why = AUTH_INVALIDRESP;
386             }
387           if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
388             {
389               xdrs->x_op = XDR_FREE;
390               (void) xdr_opaque_auth (xdrs,
391                                       &(reply_msg.acpted_rply.ar_verf));
392             }
393         }                       /* end successful completion */
394       else
395         {
396           /* maybe our credentials need to be refreshed ... */
397           if (nrefreshes > 0 && AUTH_REFRESH (cl->cl_auth))
398             {
399               nrefreshes--;
400               goto call_again;
401             }
402         }                       /* end of unsuccessful completion */
403     }                           /* end of valid reply message */
404   else
405     {
406       cu->cu_error.re_status = RPC_CANTDECODERES;
407     }
408   return cu->cu_error.re_status;
409 }
410
411 static void
412 clntudp_geterr (CLIENT *cl, struct rpc_err *errp)
413 {
414   struct cu_data *cu = (struct cu_data *) cl->cl_private;
415
416   *errp = cu->cu_error;
417 }
418
419
420 static bool_t
421 clntudp_freeres (CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr)
422 {
423   struct cu_data *cu = (struct cu_data *) cl->cl_private;
424   XDR *xdrs = &(cu->cu_outxdrs);
425
426   xdrs->x_op = XDR_FREE;
427   return (*xdr_res) (xdrs, res_ptr);
428 }
429
430 static void
431 clntudp_abort (void)
432 {
433 }
434
435 static bool_t
436 clntudp_control (CLIENT *cl, int request, char *info)
437 {
438   struct cu_data *cu = (struct cu_data *) cl->cl_private;
439
440   switch (request)
441     {
442     case CLSET_FD_CLOSE:
443       cu->cu_closeit = TRUE;
444       break;
445     case CLSET_FD_NCLOSE:
446       cu->cu_closeit = FALSE;
447       break;
448     case CLSET_TIMEOUT:
449       cu->cu_total = *(struct timeval *) info;
450       break;
451     case CLGET_TIMEOUT:
452       *(struct timeval *) info = cu->cu_total;
453       break;
454     case CLSET_RETRY_TIMEOUT:
455       cu->cu_wait = *(struct timeval *) info;
456       break;
457     case CLGET_RETRY_TIMEOUT:
458       *(struct timeval *) info = cu->cu_wait;
459       break;
460     case CLGET_SERVER_ADDR:
461       *(struct sockaddr_in *) info = cu->cu_raddr;
462       break;
463     case CLGET_FD:
464       *(int *)info = cu->cu_sock;
465       break;
466     case CLGET_XID:
467       /*
468        * use the knowledge that xid is the
469        * first element in the call structure *.
470        * This will get the xid of the PREVIOUS call
471        */
472       *(u_long *)info = ntohl(*(u_long *)cu->cu_outbuf);
473       break;
474     case CLSET_XID:
475       /* This will set the xid of the NEXT call */
476       *(u_long *)cu->cu_outbuf =  htonl(*(u_long *)info - 1);
477       /* decrement by 1 as clntudp_call() increments once */
478     case CLGET_VERS:
479       /*
480        * This RELIES on the information that, in the call body,
481        * the version number field is the fifth field from the
482        * begining of the RPC header. MUST be changed if the
483        * call_struct is changed
484        */
485       *(u_long *)info = ntohl(*(u_long *)(cu->cu_outbuf +
486                                           4 * BYTES_PER_XDR_UNIT));
487       break;
488     case CLSET_VERS:
489       *(u_long *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT)
490         = htonl(*(u_long *)info);
491       break;
492     case CLGET_PROG:
493       /*
494        * This RELIES on the information that, in the call body,
495        * the program number field is the  field from the
496        * begining of the RPC header. MUST be changed if the
497        * call_struct is changed
498        */
499       *(u_long *)info = ntohl(*(u_long *)(cu->cu_outbuf +
500                                           3 * BYTES_PER_XDR_UNIT));
501       break;
502     case CLSET_PROG:
503       *(u_long *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT)
504         = htonl(*(u_long *)info);
505       break;
506     /* The following are only possible with TI-RPC */
507     case CLGET_SVC_ADDR:
508     case CLSET_SVC_ADDR:
509     case CLSET_PUSH_TIMOD:
510     case CLSET_POP_TIMOD:
511     default:
512       return FALSE;
513     }
514   return TRUE;
515 }
516
517 static void
518 clntudp_destroy (CLIENT *cl)
519 {
520   struct cu_data *cu = (struct cu_data *) cl->cl_private;
521
522   if (cu->cu_closeit)
523     {
524       (void) close (cu->cu_sock);
525     }
526   XDR_DESTROY (&(cu->cu_outxdrs));
527   mem_free ((caddr_t) cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
528   mem_free ((caddr_t) cl, sizeof (CLIENT));
529 }