1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Copyright (c) 1984, 1986, 1987, 1988, 1989, 1996 AT&T
29 * All Rights Reserved
30 */
31
32 /*
33 * University Copyright- Copyright (c) 1982, 1986, 1988
34 * The Regents of the University of California
35 * All Rights Reserved
36 *
37 * University Acknowledgment- Portions of this document are derived from
38 * software developed by the University of California, Berkeley, and its
39 * contributors.
40 */
41
42 #pragma ident "%Z%%M% %I% %E% SMI"
43
44 /*
45 * clnt_udp.c, Implements a UDP/IP based, client side RPC.
46 */
47
48 #include <rpc/rpc.h>
49 #include <sys/socket.h>
50 #include <sys/time.h>
51 #include <sys/ioctl.h>
52 #include <netdb.h>
53 #include <errno.h>
54 #include <rpc/pmap_clnt.h>
55 #include <rpc/clnt_soc.h>
56 #include <syslog.h>
57 #include <sys/filio.h>
58 #include <malloc.h>
59 #include <unistd.h>
60 #include <stropts.h>
61 #include <stdio.h>
62
63
64 extern int errno;
65
66 extern int _socket(int, int, int);
67 extern pid_t getpid();
68 extern int bindresvport(int, struct sockaddr_in *);
69 extern bool_t xdr_opaque_auth(XDR *, struct opaque_auth *);
70 extern int _sendto(int, const char *, int, int,
71 const struct sockaddr *, int);
72 extern int _recvfrom(int, char *, int, int,
73 struct sockaddr *, int *);
74
75
76 static struct clnt_ops *clntudp_ops();
77
78 /*
79 * Private data kept per client handle
80 */
81 struct cu_data {
82 int cu_sock;
83 bool_t cu_closeit;
84 struct sockaddr_in cu_raddr;
85 int cu_rlen;
86 struct timeval cu_wait;
87 struct timeval cu_total;
88 struct rpc_err cu_error;
89 XDR cu_outxdrs;
90 u_int cu_xdrpos;
91 u_int cu_sendsz;
92 char *cu_outbuf;
93 u_int cu_recvsz;
94 char cu_inbuf[1];
95 };
96
97 /*
98 * Create a UDP based client handle.
99 * If *sockp<0, *sockp is set to a newly created UPD socket.
100 * If raddr->sin_port is 0 a binder on the remote machine
101 * is consulted for the correct port number.
102 * NB: It is the clients responsibility to close *sockp.
103 * NB: The rpch->cl_auth is initialized to null authentication.
104 * Caller may wish to set this something more useful.
105 *
106 * wait is the amount of time used between retransmitting a call if
107 * no response has been heard; retransmition occurs until the actual
108 * rpc call times out.
109 *
110 * sendsz and recvsz are the maximum allowable packet sizes that can be
111 * sent and received.
112 */
113 CLIENT *
clntudp_bufcreate(raddr,program,version,wait,sockp,sendsz,recvsz)114 clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz)
115 struct sockaddr_in *raddr;
116 rpcprog_t program;
117 rpcvers_t version;
118 struct timeval wait;
119 register int *sockp;
120 u_int sendsz;
121 u_int recvsz;
122 {
123 CLIENT *cl;
124 register struct cu_data *cu;
125 struct timeval now;
126 struct rpc_msg call_msg;
127
128 cl = (CLIENT *)mem_alloc(sizeof (CLIENT));
129 if (cl == NULL) {
130 (void) syslog(LOG_ERR, "clntudp_create: out of memory");
131 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
132 rpc_createerr.cf_error.re_errno = errno;
133 goto fooy;
134 }
135 sendsz = ((sendsz + 3) / 4) * 4;
136 recvsz = ((recvsz + 3) / 4) * 4;
137 cu = (struct cu_data *)mem_alloc(sizeof (*cu) + sendsz + recvsz);
138 if (cu == NULL) {
139 (void) syslog(LOG_ERR, "clntudp_create: out of memory");
140 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
141 rpc_createerr.cf_error.re_errno = errno;
142 goto fooy;
143 }
144 cu->cu_outbuf = &cu->cu_inbuf[recvsz];
145
146 (void) gettimeofday(&now, (struct timezone *)0);
147 if (raddr->sin_port == 0) {
148 u_short port;
149 if ((port =
150 pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) {
151 goto fooy;
152 }
153 raddr->sin_port = htons(port);
154 }
155 cl->cl_ops = clntudp_ops();
156 cl->cl_private = (caddr_t)cu;
157 cu->cu_raddr = *raddr;
158 cu->cu_rlen = sizeof (cu->cu_raddr);
159 cu->cu_wait = wait;
160 cu->cu_total.tv_sec = -1;
161 cu->cu_total.tv_usec = -1;
162 cu->cu_sendsz = sendsz;
163 cu->cu_recvsz = recvsz;
164 call_msg.rm_xid = getpid() ^ now.tv_sec ^ now.tv_usec;
165 call_msg.rm_direction = CALL;
166 call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
167 call_msg.rm_call.cb_prog = program;
168 call_msg.rm_call.cb_vers = version;
169 xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf,
170 sendsz, XDR_ENCODE);
171 if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) {
172 goto fooy;
173 }
174 cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
175 if (*sockp < 0) {
176 int dontblock = 1;
177
178 *sockp = _socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
179 if (*sockp < 0) {
180 rpc_createerr.cf_stat = RPC_SYSTEMERROR;
181 rpc_createerr.cf_error.re_errno = errno;
182 goto fooy;
183 }
184 /* attempt to bind to prov port */
185 (void) bindresvport(*sockp, (struct sockaddr_in *)0);
186 /* the sockets rpc controls are non-blocking */
187 (void) ioctl(*sockp, FIONBIO, (char *) &dontblock);
188 cu->cu_closeit = TRUE;
189 } else {
190 cu->cu_closeit = FALSE;
191 }
192 cu->cu_sock = *sockp;
193 cl->cl_auth = authnone_create();
194 return (cl);
195 fooy:
196 if (cu)
197 mem_free((caddr_t)cu, sizeof (*cu) + sendsz + recvsz);
198 if (cl)
199 mem_free((caddr_t)cl, sizeof (CLIENT));
200 return ((CLIENT *)NULL);
201 }
202
203 CLIENT *
clntudp_create(raddr,program,version,wait,sockp)204 clntudp_create(raddr, program, version, wait, sockp)
205 struct sockaddr_in *raddr;
206 rpcprog_t program;
207 rpcvers_t version;
208 struct timeval wait;
209 register int *sockp;
210 {
211
212 return (clntudp_bufcreate(raddr, program, version, wait, sockp,
213 UDPMSGSIZE, UDPMSGSIZE));
214 }
215
216 static enum clnt_stat
clntudp_call(cl,proc,xargs,argsp,xresults,resultsp,utimeout)217 clntudp_call(cl, proc, xargs, argsp, xresults, resultsp, utimeout)
218 register CLIENT *cl; /* client handle */
219 rpcproc_t proc; /* procedure number */
220 xdrproc_t xargs; /* xdr routine for args */
221 caddr_t argsp; /* pointer to args */
222 xdrproc_t xresults; /* xdr routine for results */
223 caddr_t resultsp; /* pointer to results */
224 struct timeval utimeout; /* seconds to wait before giving up */
225 {
226 register struct cu_data *cu = (struct cu_data *)cl->cl_private;
227 register XDR *xdrs;
228 register int outlen;
229 register int inlen;
230 int fromlen;
231 fd_set readfds;
232 fd_set mask;
233 struct sockaddr_in from;
234 struct rpc_msg reply_msg;
235 XDR reply_xdrs;
236 struct timeval startime, curtime;
237 int firsttimeout = 1;
238 struct timeval time_waited;
239 struct timeval retransmit_time;
240 bool_t ok;
241 int nrefreshes = 2; /* number of times to refresh cred */
242 struct timeval timeout;
243
244 if (cu->cu_total.tv_usec == -1) {
245 timeout = utimeout; /* use supplied timeout */
246 } else {
247 timeout = cu->cu_total; /* use default timeout */
248 }
249
250 time_waited.tv_sec = 0;
251 time_waited.tv_usec = 0;
252 retransmit_time = cu->cu_wait;
253
254 call_again:
255 xdrs = &(cu->cu_outxdrs);
256 xdrs->x_op = XDR_ENCODE;
257 XDR_SETPOS(xdrs, cu->cu_xdrpos);
258 /*
259 * the transaction is the first thing in the out buffer
260 */
261 (*(u_short *)(cu->cu_outbuf))++;
262 if ((! XDR_PUTINT32(xdrs, (int32_t *)&proc)) ||
263 (! AUTH_MARSHALL(cl->cl_auth, xdrs)) ||
264 (! (*xargs)(xdrs, argsp)))
265 return (cu->cu_error.re_status = RPC_CANTENCODEARGS);
266 outlen = (int)XDR_GETPOS(xdrs);
267
268 send_again:
269 if (_sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0,
270 (struct sockaddr *)&(cu->cu_raddr), cu->cu_rlen)
271 != outlen) {
272 cu->cu_error.re_errno = errno;
273 return (cu->cu_error.re_status = RPC_CANTSEND);
274 }
275
276 /*
277 * Hack to provide rpc-based message passing
278 */
279 if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
280 return (cu->cu_error.re_status = RPC_TIMEDOUT);
281 }
282 /*
283 * sub-optimal code appears here because we have
284 * some clock time to spare while the packets are in flight.
285 * (We assume that this is actually only executed once.)
286 */
287 reply_msg.acpted_rply.ar_verf = _null_auth;
288 reply_msg.acpted_rply.ar_results.where = resultsp;
289 reply_msg.acpted_rply.ar_results.proc = xresults;
290 FD_ZERO(&mask);
291 FD_SET(cu->cu_sock, &mask);
292 for (;;) {
293 readfds = mask;
294 switch (select(__rpc_dtbsize(), &readfds, NULL,
295 NULL, &(retransmit_time))) {
296
297 case 0:
298 time_waited.tv_sec += retransmit_time.tv_sec;
299 time_waited.tv_usec += retransmit_time.tv_usec;
300 while (time_waited.tv_usec >= 1000000) {
301 time_waited.tv_sec++;
302 time_waited.tv_usec -= 1000000;
303 }
304
305 /* update retransmit_time */
306
307 if (retransmit_time.tv_sec < RPC_MAX_BACKOFF) {
308 retransmit_time.tv_usec += retransmit_time.tv_usec;
309 retransmit_time.tv_sec += retransmit_time.tv_sec;
310 while (retransmit_time.tv_usec >= 1000000) {
311 retransmit_time.tv_sec++;
312 retransmit_time.tv_usec -= 1000000;
313 }
314 }
315
316 if ((time_waited.tv_sec < timeout.tv_sec) ||
317 ((time_waited.tv_sec == timeout.tv_sec) &&
318 (time_waited.tv_usec < timeout.tv_usec)))
319 goto send_again;
320 return (cu->cu_error.re_status = RPC_TIMEDOUT);
321
322 /*
323 * buggy in other cases because time_waited is not being
324 * updated.
325 */
326 case -1:
327 if (errno != EINTR) {
328 cu->cu_error.re_errno = errno;
329 return (cu->cu_error.re_status = RPC_CANTRECV);
330 }
331
332 /* interrupted by another signal, update time_waited */
333 if (firsttimeout) {
334 /*
335 * Could have done gettimeofday before clnt_call
336 * but that means 1 more system call per each
337 * clnt_call, so do it after first time out
338 */
339 if (gettimeofday(&startime,
340 (struct timezone *) NULL) == -1) {
341 errno = 0;
342 continue;
343 }
344 firsttimeout = 0;
345 errno = 0;
346 continue;
347 };
348
349 if (gettimeofday(&curtime,
350 (struct timezone *) NULL) == -1) {
351 errno = 0;
352 continue;
353 };
354
355 time_waited.tv_sec += curtime.tv_sec - startime.tv_sec;
356 time_waited.tv_usec += curtime.tv_usec -
357 startime.tv_usec;
358 while (time_waited.tv_usec < 0) {
359 time_waited.tv_sec--;
360 time_waited.tv_usec += 1000000;
361 };
362 while (time_waited.tv_usec >= 1000000) {
363 time_waited.tv_sec++;
364 time_waited.tv_usec -= 1000000;
365 }
366 startime.tv_sec = curtime.tv_sec;
367 startime.tv_usec = curtime.tv_usec;
368 if ((time_waited.tv_sec > timeout.tv_sec) ||
369 ((time_waited.tv_sec == timeout.tv_sec) &&
370 (time_waited.tv_usec > timeout.tv_usec))) {
371 return (cu->cu_error.re_status = RPC_TIMEDOUT);
372 }
373 errno = 0; /* reset it */
374 continue;
375
376 }
377 do {
378 fromlen = sizeof (struct sockaddr);
379 inlen = _recvfrom(cu->cu_sock, cu->cu_inbuf,
380 (int) cu->cu_recvsz, 0,
381 (struct sockaddr *)&from, &fromlen);
382 } while (inlen < 0 && errno == EINTR);
383 if (inlen < 0) {
384 if (errno == EWOULDBLOCK)
385 continue;
386 cu->cu_error.re_errno = errno;
387 return (cu->cu_error.re_status = RPC_CANTRECV);
388 }
389 if (inlen < sizeof (uint32_t))
390 continue;
391 /* see if reply transaction id matches sent id */
392 if (*((uint32_t *)(cu->cu_inbuf)) !=
393 *((uint32_t *)(cu->cu_outbuf)))
394 continue;
395 /* we now assume we have the proper reply */
396 break;
397 }
398
399 /*
400 * now decode and validate the response
401 */
402 xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)inlen, XDR_DECODE);
403 ok = xdr_replymsg(&reply_xdrs, &reply_msg);
404 /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */
405 if (ok) {
406 __seterr_reply(&reply_msg, &(cu->cu_error));
407 if (cu->cu_error.re_status == RPC_SUCCESS) {
408 if (! AUTH_VALIDATE(cl->cl_auth,
409 &reply_msg.acpted_rply.ar_verf)) {
410 cu->cu_error.re_status = RPC_AUTHERROR;
411 cu->cu_error.re_why = AUTH_INVALIDRESP;
412 }
413 if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
414 xdrs->x_op = XDR_FREE;
415 (void) xdr_opaque_auth(xdrs,
416 &(reply_msg.acpted_rply.ar_verf));
417 }
418 } /* end successful completion */
419 else {
420 /* maybe our credentials need to be refreshed ... */
421 if (nrefreshes > 0 &&
422 AUTH_REFRESH(cl->cl_auth, &reply_msg)) {
423 nrefreshes--;
424 goto call_again;
425 }
426 } /* end of unsuccessful completion */
427 } /* end of valid reply message */
428 else {
429 cu->cu_error.re_status = RPC_CANTDECODERES;
430 }
431 return (cu->cu_error.re_status);
432 }
433
434 static void
clntudp_geterr(cl,errp)435 clntudp_geterr(cl, errp)
436 CLIENT *cl;
437 struct rpc_err *errp;
438 {
439 register struct cu_data *cu = (struct cu_data *)cl->cl_private;
440
441 *errp = cu->cu_error;
442 }
443
444
445 static bool_t
clntudp_freeres(cl,xdr_res,res_ptr)446 clntudp_freeres(cl, xdr_res, res_ptr)
447 CLIENT *cl;
448 xdrproc_t xdr_res;
449 caddr_t res_ptr;
450 {
451 register struct cu_data *cu = (struct cu_data *)cl->cl_private;
452 register XDR *xdrs = &(cu->cu_outxdrs);
453
454 xdrs->x_op = XDR_FREE;
455 return ((*xdr_res)(xdrs, res_ptr));
456 }
457
458 static void
clntudp_abort()459 clntudp_abort()
460 /* CLIENT *h; */
461 {
462 }
463
464 static bool_t
clntudp_control(cl,request,info)465 clntudp_control(cl, request, info)
466 CLIENT *cl;
467 int request;
468 char *info;
469 {
470 register struct cu_data *cu = (struct cu_data *)cl->cl_private;
471
472 switch (request) {
473 case CLSET_TIMEOUT:
474 cu->cu_total = *(struct timeval *)info;
475 break;
476 case CLGET_TIMEOUT:
477 *(struct timeval *)info = cu->cu_total;
478 break;
479 case CLSET_RETRY_TIMEOUT:
480 cu->cu_wait = *(struct timeval *)info;
481 break;
482 case CLGET_RETRY_TIMEOUT:
483 *(struct timeval *)info = cu->cu_wait;
484 break;
485 case CLGET_SERVER_ADDR:
486 *(struct sockaddr_in *)info = cu->cu_raddr;
487 break;
488 case CLGET_FD:
489 *(int *)info = cu->cu_sock;
490 break;
491 case CLSET_FD_CLOSE:
492 cu->cu_closeit = TRUE;
493 break;
494 case CLSET_FD_NCLOSE:
495 cu->cu_closeit = FALSE;
496 break;
497 default:
498 return (FALSE);
499 }
500 return (TRUE);
501 }
502
503 static void
clntudp_destroy(cl)504 clntudp_destroy(cl)
505 CLIENT *cl;
506 {
507 register struct cu_data *cu = (struct cu_data *)cl->cl_private;
508
509 if (cu->cu_closeit) {
510 (void) close(cu->cu_sock);
511 }
512 XDR_DESTROY(&(cu->cu_outxdrs));
513 mem_free((caddr_t)cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz));
514 mem_free((caddr_t)cl, sizeof (CLIENT));
515 }
516
517 static struct clnt_ops *
clntudp_ops()518 clntudp_ops()
519 {
520 static struct clnt_ops ops;
521
522 if (ops.cl_call == NULL) {
523 ops.cl_call = clntudp_call;
524 ops.cl_abort = clntudp_abort;
525 ops.cl_geterr = clntudp_geterr;
526 ops.cl_freeres = clntudp_freeres;
527 ops.cl_destroy = clntudp_destroy;
528 ops.cl_control = clntudp_control;
529 }
530 return (&ops);
531 }
532