1 /* $NetBSD: clnt_dg.c,v 1.29 2013/05/07 21:08:44 christos Exp $ */ 2 3 /* 4 * Copyright (c) 2010, Oracle America, Inc. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are 8 * met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above 13 * copyright notice, this list of conditions and the following 14 * disclaimer in the documentation and/or other materials 15 * provided with the distribution. 16 * * Neither the name of the "Oracle America, Inc." nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 27 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 /* 34 * Copyright (c) 1986-1991 by Sun Microsystems Inc. 35 */ 36 37 /* #ident "@(#)clnt_dg.c 1.23 94/04/22 SMI" */ 38 39 #include <sys/cdefs.h> 40 #if defined(LIBC_SCCS) && !defined(lint) 41 #if 0 42 static char sccsid[] = "@(#)clnt_dg.c 1.19 89/03/16 Copyr 1988 Sun Micro"; 43 #else 44 __RCSID("$NetBSD: clnt_dg.c,v 1.29 2013/05/07 21:08:44 christos Exp $"); 45 #endif 46 #endif 47 48 /* 49 * Implements a connectionless client side RPC. 50 */ 51 52 #include "namespace.h" 53 #include "reentrant.h" 54 #include <sys/poll.h> 55 #include <sys/types.h> 56 #include <sys/time.h> 57 #include <sys/socket.h> 58 #include <sys/ioctl.h> 59 #include <rpc/rpc.h> 60 #include <assert.h> 61 #include <errno.h> 62 #include <stdlib.h> 63 #include <string.h> 64 #include <signal.h> 65 #include <unistd.h> 66 #include <err.h> 67 68 #include "svc_fdset.h" 69 #include "rpc_internal.h" 70 71 #ifdef __weak_alias 72 __weak_alias(clnt_dg_create,_clnt_dg_create) 73 #endif 74 75 #define RPC_MAX_BACKOFF 30 /* seconds */ 76 77 78 static struct clnt_ops *clnt_dg_ops(void); 79 static bool_t time_not_ok(struct timeval *); 80 static enum clnt_stat clnt_dg_call(CLIENT *, rpcproc_t, xdrproc_t, 81 const char *, xdrproc_t, caddr_t, struct timeval); 82 static void clnt_dg_geterr(CLIENT *, struct rpc_err *); 83 static bool_t clnt_dg_freeres(CLIENT *, xdrproc_t, caddr_t); 84 static void clnt_dg_abort(CLIENT *); 85 static bool_t clnt_dg_control(CLIENT *, u_int, char *); 86 static void clnt_dg_destroy(CLIENT *); 87 88 89 90 91 /* 92 * This machinery implements per-fd locks for MT-safety. It is not 93 * sufficient to do per-CLIENT handle locks for MT-safety because a 94 * user may create more than one CLIENT handle with the same fd behind 95 * it. Therfore, we allocate an array of flags (dg_fd_locks), protected 96 * by the clnt_fd_lock mutex, and an array (dg_cv) of condition variables 97 * similarly protected. Dg_fd_lock[fd] == 1 => a call is activte on some 98 * CLIENT handle created for that fd. 99 * The current implementation holds locks across the entire RPC and reply, 100 * including retransmissions. Yes, this is silly, and as soon as this 101 * code is proven to work, this should be the first thing fixed. One step 102 * at a time. 103 */ 104 static int *dg_fd_locks; 105 #ifdef _REENTRANT 106 #define __rpc_lock_value __isthreaded; 107 extern mutex_t clnt_fd_lock; 108 static cond_t *dg_cv; 109 #define release_fd_lock(fd, mask) { \ 110 mutex_lock(&clnt_fd_lock); \ 111 dg_fd_locks[fd] = 0; \ 112 mutex_unlock(&clnt_fd_lock); \ 113 thr_sigsetmask(SIG_SETMASK, &(mask), NULL); \ 114 cond_signal(&dg_cv[fd]); \ 115 } 116 #else 117 #define release_fd_lock(fd,mask) 118 #define __rpc_lock_value 0 119 #endif 120 121 static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory"; 122 123 /* VARIABLES PROTECTED BY clnt_fd_lock: dg_fd_locks, dg_cv */ 124 125 /* 126 * Private data kept per client handle 127 */ 128 struct cu_data { 129 int cu_fd; /* connections fd */ 130 bool_t cu_closeit; /* opened by library */ 131 struct sockaddr_storage cu_raddr; /* remote address */ 132 int cu_rlen; 133 struct timeval cu_wait; /* retransmit interval */ 134 struct timeval cu_total; /* total time for the call */ 135 struct rpc_err cu_error; 136 XDR cu_outxdrs; 137 u_int cu_xdrpos; 138 u_int cu_sendsz; /* send size */ 139 char *cu_outbuf; 140 u_int cu_recvsz; /* recv size */ 141 struct pollfd cu_pfdp; 142 char cu_inbuf[1]; 143 }; 144 145 /* 146 * Connection less client creation returns with client handle parameters. 147 * Default options are set, which the user can change using clnt_control(). 148 * fd should be open and bound. 149 * NB: The rpch->cl_auth is initialized to null authentication. 150 * Caller may wish to set this something more useful. 151 * 152 * sendsz and recvsz are the maximum allowable packet sizes that can be 153 * sent and received. Normally they are the same, but they can be 154 * changed to improve the program efficiency and buffer allocation. 155 * If they are 0, use the transport default. 156 * 157 * If svcaddr is NULL, returns NULL. 158 */ 159 CLIENT * 160 clnt_dg_create( 161 int fd, /* open file descriptor */ 162 const struct netbuf *svcaddr, /* servers address */ 163 rpcprog_t program, /* program number */ 164 rpcvers_t version, /* version number */ 165 u_int sendsz, /* buffer recv size */ 166 u_int recvsz) /* buffer send size */ 167 { 168 CLIENT *cl = NULL; /* client handle */ 169 struct cu_data *cu = NULL; /* private data */ 170 struct rpc_msg call_msg; 171 #ifdef _REENTRANT 172 sigset_t mask; 173 #endif 174 sigset_t newmask; 175 struct __rpc_sockinfo si; 176 int one = 1; 177 178 __clnt_sigfillset(&newmask); 179 thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 180 mutex_lock(&clnt_fd_lock); 181 if (dg_fd_locks == NULL) { 182 #ifdef _REENTRANT 183 size_t cv_allocsz; 184 #endif 185 size_t fd_allocsz; 186 int dtbsize = __rpc_dtbsize(); 187 188 fd_allocsz = dtbsize * sizeof (int); 189 dg_fd_locks = mem_alloc(fd_allocsz); 190 if (dg_fd_locks == NULL) { 191 goto err0; 192 } else 193 memset(dg_fd_locks, '\0', fd_allocsz); 194 195 #ifdef _REENTRANT 196 cv_allocsz = dtbsize * sizeof (cond_t); 197 dg_cv = mem_alloc(cv_allocsz); 198 if (dg_cv == NULL) { 199 mem_free(dg_fd_locks, fd_allocsz); 200 dg_fd_locks = NULL; 201 goto err0; 202 } else { 203 int i; 204 205 for (i = 0; i < dtbsize; i++) 206 cond_init(&dg_cv[i], 0, (void *) 0); 207 } 208 #endif 209 } 210 211 mutex_unlock(&clnt_fd_lock); 212 thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 213 214 if (svcaddr == NULL) { 215 rpc_createerr.cf_stat = RPC_UNKNOWNADDR; 216 return (NULL); 217 } 218 219 if (!__rpc_fd2sockinfo(fd, &si)) { 220 rpc_createerr.cf_stat = RPC_TLIERROR; 221 rpc_createerr.cf_error.re_errno = 0; 222 return (NULL); 223 } 224 /* 225 * Find the receive and the send size 226 */ 227 sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz); 228 recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz); 229 if ((sendsz == 0) || (recvsz == 0)) { 230 rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */ 231 rpc_createerr.cf_error.re_errno = 0; 232 return (NULL); 233 } 234 235 if ((cl = mem_alloc(sizeof (CLIENT))) == NULL) 236 goto err1; 237 /* 238 * Should be multiple of 4 for XDR. 239 */ 240 sendsz = ((sendsz + 3) / 4) * 4; 241 recvsz = ((recvsz + 3) / 4) * 4; 242 cu = malloc(sizeof (*cu) + sendsz + recvsz); 243 if (cu == NULL) 244 goto err1; 245 memset(cu, 0, sizeof(*cu)); 246 (void) memcpy(&cu->cu_raddr, svcaddr->buf, (size_t)svcaddr->len); 247 cu->cu_rlen = svcaddr->len; 248 cu->cu_outbuf = &cu->cu_inbuf[recvsz]; 249 /* Other values can also be set through clnt_control() */ 250 #ifdef RUMP_RPC 251 cu->cu_wait.tv_sec = 15; /* heuristically chosen */ 252 cu->cu_wait.tv_usec = 0; 253 #else 254 cu->cu_wait.tv_sec = 0; /* for testing, 10x / second */ 255 cu->cu_wait.tv_usec = 100000; 256 #endif 257 cu->cu_total.tv_sec = -1; 258 cu->cu_total.tv_usec = -1; 259 cu->cu_sendsz = sendsz; 260 cu->cu_recvsz = recvsz; 261 call_msg.rm_xid = __RPC_GETXID(); 262 call_msg.rm_call.cb_prog = program; 263 call_msg.rm_call.cb_vers = version; 264 xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE); 265 if (! xdr_callhdr(&(cu->cu_outxdrs), &call_msg)) { 266 rpc_createerr.cf_stat = RPC_CANTENCODEARGS; /* XXX */ 267 rpc_createerr.cf_error.re_errno = 0; 268 goto err2; 269 } 270 cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs)); 271 272 /* XXX fvdl - do we still want this? */ 273 #if 0 274 (void)bindresvport_sa(fd, (struct sockaddr *)svcaddr->buf); 275 #endif 276 ioctl(fd, FIONBIO, (char *)(void *)&one); 277 278 /* 279 * By default, closeit is always FALSE. It is users responsibility 280 * to do a close on it, else the user may use clnt_control 281 * to let clnt_destroy do it for him/her. 282 */ 283 cu->cu_closeit = FALSE; 284 cu->cu_fd = fd; 285 cu->cu_pfdp.fd = cu->cu_fd; 286 cu->cu_pfdp.events = POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND; 287 cl->cl_ops = clnt_dg_ops(); 288 cl->cl_private = (caddr_t)(void *)cu; 289 cl->cl_auth = authnone_create(); 290 cl->cl_tp = NULL; 291 cl->cl_netid = NULL; 292 return (cl); 293 err0: 294 mutex_unlock(&clnt_fd_lock); 295 thr_sigsetmask(SIG_SETMASK, &(mask), NULL); 296 err1: 297 warnx(mem_err_clnt_dg); 298 rpc_createerr.cf_stat = RPC_SYSTEMERROR; 299 rpc_createerr.cf_error.re_errno = errno; 300 err2: 301 if (cl) { 302 mem_free(cl, sizeof (CLIENT)); 303 if (cu) 304 mem_free(cu, sizeof (*cu) + sendsz + recvsz); 305 } 306 return (NULL); 307 } 308 309 static enum clnt_stat 310 clnt_dg_call( 311 CLIENT * cl, /* client handle */ 312 rpcproc_t proc, /* procedure number */ 313 xdrproc_t xargs, /* xdr routine for args */ 314 const char * argsp, /* pointer to args */ 315 xdrproc_t xresults, /* xdr routine for results */ 316 caddr_t resultsp, /* pointer to results */ 317 struct timeval utimeout) /* seconds to wait before giving up */ 318 { 319 struct cu_data *cu; 320 XDR *xdrs; 321 size_t outlen; 322 struct rpc_msg reply_msg; 323 XDR reply_xdrs; 324 bool_t ok; 325 int nrefreshes = 2; /* number of times to refresh cred */ 326 struct timeval timeout; 327 struct timeval retransmit_time; 328 struct timeval next_sendtime, starttime, time_waited, tv; 329 #ifdef _REENTRANT 330 sigset_t mask, *maskp = &mask; 331 #else 332 sigset_t *maskp = NULL; 333 #endif 334 sigset_t newmask; 335 ssize_t recvlen = 0; 336 struct timespec ts; 337 int n; 338 339 _DIAGASSERT(cl != NULL); 340 341 cu = (struct cu_data *)cl->cl_private; 342 343 __clnt_sigfillset(&newmask); 344 thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 345 mutex_lock(&clnt_fd_lock); 346 while (dg_fd_locks[cu->cu_fd]) 347 cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 348 dg_fd_locks[cu->cu_fd] = __rpc_lock_value; 349 mutex_unlock(&clnt_fd_lock); 350 if (cu->cu_total.tv_usec == -1) { 351 timeout = utimeout; /* use supplied timeout */ 352 } else { 353 timeout = cu->cu_total; /* use default timeout */ 354 } 355 356 time_waited.tv_sec = 0; 357 time_waited.tv_usec = 0; 358 retransmit_time = next_sendtime = cu->cu_wait; 359 gettimeofday(&starttime, NULL); 360 361 call_again: 362 xdrs = &(cu->cu_outxdrs); 363 xdrs->x_op = XDR_ENCODE; 364 XDR_SETPOS(xdrs, cu->cu_xdrpos); 365 /* 366 * the transaction is the first thing in the out buffer 367 */ 368 (*(u_int32_t *)(void *)(cu->cu_outbuf))++; 369 if ((! XDR_PUTINT32(xdrs, (int32_t *)&proc)) || 370 (! AUTH_MARSHALL(cl->cl_auth, xdrs)) || 371 (! (*xargs)(xdrs, __UNCONST(argsp)))) { 372 cu->cu_error.re_status = RPC_CANTENCODEARGS; 373 goto out; 374 } 375 outlen = (size_t)XDR_GETPOS(xdrs); 376 377 send_again: 378 if ((size_t)sendto(cu->cu_fd, cu->cu_outbuf, outlen, 0, 379 (struct sockaddr *)(void *)&cu->cu_raddr, (socklen_t)cu->cu_rlen) 380 != outlen) { 381 cu->cu_error.re_errno = errno; 382 cu->cu_error.re_status = RPC_CANTSEND; 383 goto out; 384 } 385 386 /* 387 * Hack to provide rpc-based message passing 388 */ 389 if (timeout.tv_sec == 0 && timeout.tv_usec == 0) { 390 cu->cu_error.re_status = RPC_TIMEDOUT; 391 goto out; 392 } 393 /* 394 * sub-optimal code appears here because we have 395 * some clock time to spare while the packets are in flight. 396 * (We assume that this is actually only executed once.) 397 */ 398 reply_msg.acpted_rply.ar_verf = _null_auth; 399 reply_msg.acpted_rply.ar_results.where = resultsp; 400 reply_msg.acpted_rply.ar_results.proc = xresults; 401 402 403 for (;;) { 404 /* Decide how long to wait. */ 405 if (timercmp(&next_sendtime, &timeout, <)) 406 timersub(&next_sendtime, &time_waited, &tv); 407 else 408 timersub(&timeout, &time_waited, &tv); 409 if (tv.tv_sec < 0 || tv.tv_usec < 0) 410 tv.tv_sec = tv.tv_usec = 0; 411 TIMEVAL_TO_TIMESPEC(&tv, &ts); 412 413 n = pollts(&cu->cu_pfdp, 1, &ts, maskp); 414 if (n == 1) { 415 /* We have some data now */ 416 do { 417 recvlen = recvfrom(cu->cu_fd, cu->cu_inbuf, 418 cu->cu_recvsz, 0, NULL, NULL); 419 } while (recvlen < 0 && errno == EINTR); 420 421 if (recvlen < 0 && errno != EWOULDBLOCK) { 422 cu->cu_error.re_errno = errno; 423 cu->cu_error.re_status = RPC_CANTRECV; 424 goto out; 425 } 426 if (recvlen >= (ssize_t)sizeof(uint32_t)) { 427 if (memcmp(cu->cu_inbuf, cu->cu_outbuf, 428 sizeof(uint32_t)) == 0) 429 /* Assume we have the proper reply. */ 430 break; 431 } 432 } 433 if (n == -1) { 434 cu->cu_error.re_errno = errno; 435 cu->cu_error.re_status = RPC_CANTRECV; 436 goto out; 437 } 438 439 gettimeofday(&tv, NULL); 440 timersub(&tv, &starttime, &time_waited); 441 442 /* Check for timeout. */ 443 if (timercmp(&time_waited, &timeout, >)) { 444 cu->cu_error.re_status = RPC_TIMEDOUT; 445 goto out; 446 } 447 448 /* Retransmit if necessary. */ 449 if (timercmp(&time_waited, &next_sendtime, >)) { 450 /* update retransmit_time */ 451 if (retransmit_time.tv_sec < RPC_MAX_BACKOFF) 452 timeradd(&retransmit_time, &retransmit_time, 453 &retransmit_time); 454 timeradd(&next_sendtime, &retransmit_time, 455 &next_sendtime); 456 goto send_again; 457 } 458 } 459 460 /* 461 * now decode and validate the response 462 */ 463 464 xdrmem_create(&reply_xdrs, cu->cu_inbuf, (u_int)recvlen, XDR_DECODE); 465 ok = xdr_replymsg(&reply_xdrs, &reply_msg); 466 /* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */ 467 if (ok) { 468 if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) && 469 (reply_msg.acpted_rply.ar_stat == SUCCESS)) 470 cu->cu_error.re_status = RPC_SUCCESS; 471 else 472 _seterr_reply(&reply_msg, &(cu->cu_error)); 473 474 if (cu->cu_error.re_status == RPC_SUCCESS) { 475 if (! AUTH_VALIDATE(cl->cl_auth, 476 &reply_msg.acpted_rply.ar_verf)) { 477 cu->cu_error.re_status = RPC_AUTHERROR; 478 cu->cu_error.re_why = AUTH_INVALIDRESP; 479 } 480 if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) { 481 xdrs->x_op = XDR_FREE; 482 (void) xdr_opaque_auth(xdrs, 483 &(reply_msg.acpted_rply.ar_verf)); 484 } 485 } /* end successful completion */ 486 /* 487 * If unsuccesful AND error is an authentication error 488 * then refresh credentials and try again, else break 489 */ 490 else if (cu->cu_error.re_status == RPC_AUTHERROR) 491 /* maybe our credentials need to be refreshed ... */ 492 if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth)) { 493 nrefreshes--; 494 goto call_again; 495 } 496 /* end of unsuccessful completion */ 497 } /* end of valid reply message */ 498 else { 499 cu->cu_error.re_status = RPC_CANTDECODERES; 500 501 } 502 out: 503 release_fd_lock(cu->cu_fd, mask); 504 return (cu->cu_error.re_status); 505 } 506 507 static void 508 clnt_dg_geterr(CLIENT *cl, struct rpc_err *errp) 509 { 510 struct cu_data *cu; 511 512 _DIAGASSERT(cl != NULL); 513 _DIAGASSERT(errp != NULL); 514 515 cu = (struct cu_data *)cl->cl_private; 516 *errp = cu->cu_error; 517 } 518 519 static bool_t 520 clnt_dg_freeres(CLIENT *cl, xdrproc_t xdr_res, caddr_t res_ptr) 521 { 522 struct cu_data *cu; 523 XDR *xdrs; 524 bool_t dummy; 525 #ifdef _REENTRANT 526 sigset_t mask; 527 #endif 528 sigset_t newmask; 529 530 _DIAGASSERT(cl != NULL); 531 cu = (struct cu_data *)cl->cl_private; 532 xdrs = &(cu->cu_outxdrs); 533 534 __clnt_sigfillset(&newmask); 535 thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 536 mutex_lock(&clnt_fd_lock); 537 while (dg_fd_locks[cu->cu_fd]) 538 cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 539 xdrs->x_op = XDR_FREE; 540 dummy = (*xdr_res)(xdrs, res_ptr); 541 mutex_unlock(&clnt_fd_lock); 542 thr_sigsetmask(SIG_SETMASK, &mask, NULL); 543 cond_signal(&dg_cv[cu->cu_fd]); 544 return (dummy); 545 } 546 547 /*ARGSUSED*/ 548 static void 549 clnt_dg_abort(CLIENT *h) 550 { 551 } 552 553 static bool_t 554 clnt_dg_control(CLIENT *cl, u_int request, char *info) 555 { 556 struct cu_data *cu; 557 struct netbuf *addr; 558 #ifdef _REENTRANT 559 sigset_t mask; 560 #endif 561 sigset_t newmask; 562 563 _DIAGASSERT(cl != NULL); 564 /* info is handled below */ 565 566 cu = (struct cu_data *)cl->cl_private; 567 568 __clnt_sigfillset(&newmask); 569 thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 570 mutex_lock(&clnt_fd_lock); 571 while (dg_fd_locks[cu->cu_fd]) 572 cond_wait(&dg_cv[cu->cu_fd], &clnt_fd_lock); 573 dg_fd_locks[cu->cu_fd] = __rpc_lock_value; 574 mutex_unlock(&clnt_fd_lock); 575 switch (request) { 576 case CLSET_FD_CLOSE: 577 cu->cu_closeit = TRUE; 578 release_fd_lock(cu->cu_fd, mask); 579 return (TRUE); 580 case CLSET_FD_NCLOSE: 581 cu->cu_closeit = FALSE; 582 release_fd_lock(cu->cu_fd, mask); 583 return (TRUE); 584 } 585 586 /* for other requests which use info */ 587 if (info == NULL) { 588 release_fd_lock(cu->cu_fd, mask); 589 return (FALSE); 590 } 591 switch (request) { 592 case CLSET_TIMEOUT: 593 if (time_not_ok((struct timeval *)(void *)info)) { 594 release_fd_lock(cu->cu_fd, mask); 595 return (FALSE); 596 } 597 cu->cu_total = *(struct timeval *)(void *)info; 598 break; 599 case CLGET_TIMEOUT: 600 *(struct timeval *)(void *)info = cu->cu_total; 601 break; 602 case CLGET_SERVER_ADDR: /* Give him the fd address */ 603 /* Now obsolete. Only for backward compatibility */ 604 (void) memcpy(info, &cu->cu_raddr, (size_t)cu->cu_rlen); 605 break; 606 case CLSET_RETRY_TIMEOUT: 607 if (time_not_ok((struct timeval *)(void *)info)) { 608 release_fd_lock(cu->cu_fd, mask); 609 return (FALSE); 610 } 611 cu->cu_wait = *(struct timeval *)(void *)info; 612 break; 613 case CLGET_RETRY_TIMEOUT: 614 *(struct timeval *)(void *)info = cu->cu_wait; 615 break; 616 case CLGET_FD: 617 *(int *)(void *)info = cu->cu_fd; 618 break; 619 case CLGET_SVC_ADDR: 620 addr = (struct netbuf *)(void *)info; 621 addr->buf = &cu->cu_raddr; 622 addr->len = cu->cu_rlen; 623 addr->maxlen = sizeof cu->cu_raddr; 624 break; 625 case CLSET_SVC_ADDR: /* set to new address */ 626 addr = (struct netbuf *)(void *)info; 627 if (addr->len < sizeof cu->cu_raddr) { 628 release_fd_lock(cu->cu_fd, mask); 629 return (FALSE); 630 } 631 (void) memcpy(&cu->cu_raddr, addr->buf, (size_t)addr->len); 632 cu->cu_rlen = addr->len; 633 break; 634 case CLGET_XID: 635 /* 636 * use the knowledge that xid is the 637 * first element in the call structure *. 638 * This will get the xid of the PREVIOUS call 639 */ 640 *(u_int32_t *)(void *)info = 641 ntohl(*(u_int32_t *)(void *)cu->cu_outbuf); 642 break; 643 644 case CLSET_XID: 645 /* This will set the xid of the NEXT call */ 646 *(u_int32_t *)(void *)cu->cu_outbuf = 647 htonl(*(u_int32_t *)(void *)info - 1); 648 /* decrement by 1 as clnt_dg_call() increments once */ 649 break; 650 651 case CLGET_VERS: 652 /* 653 * This RELIES on the information that, in the call body, 654 * the version number field is the fifth field from the 655 * begining of the RPC header. MUST be changed if the 656 * call_struct is changed 657 */ 658 *(u_int32_t *)(void *)info = 659 ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf + 660 4 * BYTES_PER_XDR_UNIT)); 661 break; 662 663 case CLSET_VERS: 664 *(u_int32_t *)(void *)(cu->cu_outbuf + 4 * BYTES_PER_XDR_UNIT) 665 = htonl(*(u_int32_t *)(void *)info); 666 break; 667 668 case CLGET_PROG: 669 /* 670 * This RELIES on the information that, in the call body, 671 * the program number field is the fourth field from the 672 * begining of the RPC header. MUST be changed if the 673 * call_struct is changed 674 */ 675 *(u_int32_t *)(void *)info = 676 ntohl(*(u_int32_t *)(void *)(cu->cu_outbuf + 677 3 * BYTES_PER_XDR_UNIT)); 678 break; 679 680 case CLSET_PROG: 681 *(u_int32_t *)(void *)(cu->cu_outbuf + 3 * BYTES_PER_XDR_UNIT) 682 = htonl(*(u_int32_t *)(void *)info); 683 break; 684 685 default: 686 release_fd_lock(cu->cu_fd, mask); 687 return (FALSE); 688 } 689 release_fd_lock(cu->cu_fd, mask); 690 return (TRUE); 691 } 692 693 static void 694 clnt_dg_destroy(CLIENT *cl) 695 { 696 struct cu_data *cu; 697 int cu_fd; 698 #ifdef _REENTRANT 699 sigset_t mask; 700 #endif 701 sigset_t newmask; 702 703 _DIAGASSERT(cl != NULL); 704 705 cu = (struct cu_data *)cl->cl_private; 706 cu_fd = cu->cu_fd; 707 708 __clnt_sigfillset(&newmask); 709 thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 710 mutex_lock(&clnt_fd_lock); 711 while (dg_fd_locks[cu_fd]) 712 cond_wait(&dg_cv[cu_fd], &clnt_fd_lock); 713 if (cu->cu_closeit) 714 (void) close(cu_fd); 715 XDR_DESTROY(&(cu->cu_outxdrs)); 716 mem_free(cu, (sizeof (*cu) + cu->cu_sendsz + cu->cu_recvsz)); 717 if (cl->cl_netid && cl->cl_netid[0]) 718 mem_free(cl->cl_netid, strlen(cl->cl_netid) +1); 719 if (cl->cl_tp && cl->cl_tp[0]) 720 mem_free(cl->cl_tp, strlen(cl->cl_tp) +1); 721 mem_free(cl, sizeof (CLIENT)); 722 mutex_unlock(&clnt_fd_lock); 723 thr_sigsetmask(SIG_SETMASK, &mask, NULL); 724 cond_signal(&dg_cv[cu_fd]); 725 } 726 727 static struct clnt_ops * 728 clnt_dg_ops(void) 729 { 730 static struct clnt_ops ops; 731 #ifdef _REENTRANT 732 extern mutex_t ops_lock; 733 sigset_t mask; 734 #endif 735 sigset_t newmask; 736 737 /* VARIABLES PROTECTED BY ops_lock: ops */ 738 739 __clnt_sigfillset(&newmask); 740 thr_sigsetmask(SIG_SETMASK, &newmask, &mask); 741 mutex_lock(&ops_lock); 742 if (ops.cl_call == NULL) { 743 ops.cl_call = clnt_dg_call; 744 ops.cl_abort = clnt_dg_abort; 745 ops.cl_geterr = clnt_dg_geterr; 746 ops.cl_freeres = clnt_dg_freeres; 747 ops.cl_destroy = clnt_dg_destroy; 748 ops.cl_control = clnt_dg_control; 749 } 750 mutex_unlock(&ops_lock); 751 thr_sigsetmask(SIG_SETMASK, &mask, NULL); 752 return (&ops); 753 } 754 755 /* 756 * Make sure that the time is not garbage. -1 value is allowed. 757 */ 758 static bool_t 759 time_not_ok(struct timeval *t) 760 { 761 762 _DIAGASSERT(t != NULL); 763 764 return (t->tv_sec < -1 || t->tv_sec > 100000000 || 765 t->tv_usec < -1 || t->tv_usec > 1000000); 766 } 767