6/sys/rpc/clnt_dg.c

   1 /*      $NetBSD: clnt_dg.c,v 1.4 2000/07/14 08:40:41 fvdl Exp $ */
   2
   3 /*
   4  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
   5  * unrestricted use provided that this legend is included on all tape
   6  * media and as a part of the software program in whole or part.  Users
   7  * may copy or modify Sun RPC without charge, but are not authorized
   8  * to license or distribute it to anyone else except as part of a product or
   9  * program developed by the user.
  10  *
  11  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  12  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  13  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  14  *
  15  * Sun RPC is provided with no support and without any obligation on the
  16  * part of Sun Microsystems, Inc. to assist in its use, correction,
  17  * modification or enhancement.
  18  *
  19  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  20  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  21  * OR ANY PART THEREOF.
  22  *
  23  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  24  * or profits or other special, indirect and consequential damages, even if
  25  * Sun has been advised of the possibility of such damages.
  26  *
  27  * Sun Microsystems, Inc.
  28  * 2550 Garcia Avenue
  29  * Mountain View, California  94043
  30  */
  31 /*
  32  * Copyright (c) 1986-1991 by Sun Microsystems Inc.
  33  */
  34
  35 #if defined(LIBC_SCCS) && !defined(lint)
  36 #ident  "@(#)clnt_dg.c  1.23    94/04/22 SMI"
  37 static char sccsid[] = "@(#)clnt_dg.c 1.19 89/03/16 Copyr 1988 Sun Micro";
  38 #endif
  39 #include <sys/cdefs.h>
  40 __FBSDID("$FreeBSD$");
  41
  42 /*
  43  * Implements a connectionless client side RPC.
  44  */
  45
  46 #include <sys/param.h>
  47 #include <sys/systm.h>
  48 #include <sys/lock.h>
  49 #include <sys/malloc.h>
  50 #include <sys/mbuf.h>
  51 #include <sys/mutex.h>
  52 #include <sys/pcpu.h>
  53 #include <sys/proc.h>
  54 #include <sys/socket.h>
  55 #include <sys/socketvar.h>
  56 #include <sys/time.h>
  57 #include <sys/uio.h>
  58
  59 #include <rpc/rpc.h>
  60 #include <rpc/rpc_com.h>
  61
  62
  63 #ifdef _FREEFALL_CONFIG
  64 /*
  65  * Disable RPC exponential back-off for FreeBSD.org systems.
  66  */
  67 #define RPC_MAX_BACKOFF         1 /* second */
  68 #else
  69 #define RPC_MAX_BACKOFF         30 /* seconds */
  70 #endif
  71
  72 static bool_t time_not_ok(struct timeval *);
  73 static enum clnt_stat clnt_dg_call(CLIENT *, rpcproc_t, xdrproc_t, void *,
  74             xdrproc_t, void *, struct timeval);
  75 static void clnt_dg_geterr(CLIENT *, struct rpc_err *);
  76 static bool_t clnt_dg_freeres(CLIENT *, xdrproc_t, void *);
  77 static void clnt_dg_abort(CLIENT *);
  78 static bool_t clnt_dg_control(CLIENT *, u_int, void *);
  79 static void clnt_dg_destroy(CLIENT *);
  80 static void clnt_dg_soupcall(struct socket *so, void *arg, int waitflag);
  81
  82 static struct clnt_ops clnt_dg_ops = {
  83         .cl_call =      clnt_dg_call,
  84         .cl_abort =     clnt_dg_abort,
  85         .cl_geterr =    clnt_dg_geterr,
  86         .cl_freeres =   clnt_dg_freeres,
  87         .cl_destroy =   clnt_dg_destroy,
  88         .cl_control =   clnt_dg_control
  89 };
  90
  91 static const char mem_err_clnt_dg[] = "clnt_dg_create: out of memory";
  92
  93 /*
  94  * A pending RPC request which awaits a reply.
  95  */
  96 struct cu_request {
  97         TAILQ_ENTRY(cu_request) cr_link;
  98         uint32_t                cr_xid;         /* XID of request */
  99         struct mbuf             *cr_mrep;       /* reply received by upcall */
 100         int                     cr_error;       /* any error from upcall */
 101 };
 102
 103 TAILQ_HEAD(cu_request_list, cu_request);
 104
 105 #define MCALL_MSG_SIZE 24
 106
 107 /*
 108  * This structure is pointed to by the socket's so_upcallarg
 109  * member. It is separate from the client private data to facilitate
 110  * multiple clients sharing the same socket. The cs_lock mutex is used
 111  * to protect all fields of this structure, the socket's receive
 112  * buffer SOCKBUF_LOCK is used to ensure that exactly one of these
 113  * structures is installed on the socket.
 114  */
 115 struct cu_socket {
 116         struct mtx              cs_lock;
 117         int                     cs_refs;        /* Count of clients */
 118         struct cu_request_list  cs_pending;     /* Requests awaiting replies */
 119
 120 };
 121
 122 /*
 123  * Private data kept per client handle
 124  */
 125 struct cu_data {
 126         struct socket           *cu_socket;     /* connection socket */
 127         bool_t                  cu_closeit;     /* opened by library */
 128         struct sockaddr_storage cu_raddr;       /* remote address */
 129         int                     cu_rlen;
 130         struct timeval          cu_wait;        /* retransmit interval */
 131         struct timeval          cu_total;       /* total time for the call */
 132         struct rpc_err          cu_error;
 133         uint32_t                cu_xid;
 134         char                    cu_mcallc[MCALL_MSG_SIZE]; /* marshalled callmsg */
 135         size_t                  cu_mcalllen;
 136         size_t                  cu_sendsz;      /* send size */
 137         size_t                  cu_recvsz;      /* recv size */
 138         int                     cu_async;
 139         int                     cu_connect;     /* Use connect(). */
 140         int                     cu_connected;   /* Have done connect(). */
 141         const char              *cu_waitchan;
 142         int                     cu_waitflag;
 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         struct socket *so,
 162         struct sockaddr *svcaddr,       /* servers address */
 163         rpcprog_t program,              /* program number */
 164         rpcvers_t version,              /* version number */
 165         size_t sendsz,                  /* buffer recv size */
 166         size_t recvsz)                  /* buffer send size */
 167 {
 168         CLIENT *cl = NULL;              /* client handle */
 169         struct cu_data *cu = NULL;      /* private data */
 170         struct cu_socket *cs = NULL;
 171         struct timeval now;
 172         struct rpc_msg call_msg;
 173         struct __rpc_sockinfo si;
 174         XDR xdrs;
 175
 176         if (svcaddr == NULL) {
 177                 rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
 178                 return (NULL);
 179         }
 180
 181         if (!__rpc_socket2sockinfo(so, &si)) {
 182                 rpc_createerr.cf_stat = RPC_TLIERROR;
 183                 rpc_createerr.cf_error.re_errno = 0;
 184                 return (NULL);
 185         }
 186
 187         /*
 188          * Find the receive and the send size
 189          */
 190         sendsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)sendsz);
 191         recvsz = __rpc_get_t_size(si.si_af, si.si_proto, (int)recvsz);
 192         if ((sendsz == 0) || (recvsz == 0)) {
 193                 rpc_createerr.cf_stat = RPC_TLIERROR; /* XXX */
 194                 rpc_createerr.cf_error.re_errno = 0;
 195                 return (NULL);
 196         }
 197
 198         cl = mem_alloc(sizeof (CLIENT));
 199
 200         /*
 201          * Should be multiple of 4 for XDR.
 202          */
 203         sendsz = ((sendsz + 3) / 4) * 4;
 204         recvsz = ((recvsz + 3) / 4) * 4;
 205         cu = mem_alloc(sizeof (*cu));
 206         (void) memcpy(&cu->cu_raddr, svcaddr, (size_t)svcaddr->sa_len);
 207         cu->cu_rlen = svcaddr->sa_len;
 208         /* Other values can also be set through clnt_control() */
 209         cu->cu_wait.tv_sec = 15;        /* heuristically chosen */
 210         cu->cu_wait.tv_usec = 0;
 211         cu->cu_total.tv_sec = -1;
 212         cu->cu_total.tv_usec = -1;
 213         cu->cu_sendsz = sendsz;
 214         cu->cu_recvsz = recvsz;
 215         cu->cu_async = FALSE;
 216         cu->cu_connect = FALSE;
 217         cu->cu_connected = FALSE;
 218         cu->cu_waitchan = "rpcrecv";
 219         cu->cu_waitflag = 0;
 220         (void) getmicrotime(&now);
 221         cu->cu_xid = __RPC_GETXID(&now);
 222         call_msg.rm_xid = cu->cu_xid;
 223         call_msg.rm_call.cb_prog = program;
 224         call_msg.rm_call.cb_vers = version;
 225         xdrmem_create(&xdrs, cu->cu_mcallc, MCALL_MSG_SIZE, XDR_ENCODE);
 226         if (! xdr_callhdr(&xdrs, &call_msg)) {
 227                 rpc_createerr.cf_stat = RPC_CANTENCODEARGS;  /* XXX */
 228                 rpc_createerr.cf_error.re_errno = 0;
 229                 goto err2;
 230         }
 231         cu->cu_mcalllen = XDR_GETPOS(&xdrs);;
 232
 233         /*
 234          * By default, closeit is always FALSE. It is users responsibility
 235          * to do a close on it, else the user may use clnt_control
 236          * to let clnt_destroy do it for him/her.
 237          */
 238         cu->cu_closeit = FALSE;
 239         cu->cu_socket = so;
 240
 241         SOCKBUF_LOCK(&so->so_rcv);
 242 recheck_socket:
 243         if (so->so_upcall) {
 244                 if (so->so_upcall != clnt_dg_soupcall) {
 245                         SOCKBUF_UNLOCK(&so->so_rcv);
 246                         printf("clnt_dg_create(): socket already has an incompatible upcall\n");
 247                         goto err2;
 248                 }
 249                 cs = (struct cu_socket *) so->so_upcallarg;
 250                 mtx_lock(&cs->cs_lock);
 251                 cs->cs_refs++;
 252                 mtx_unlock(&cs->cs_lock);
 253         } else {
 254                 /*
 255                  * We are the first on this socket - allocate the
 256                  * structure and install it in the socket.
 257                  */
 258                 SOCKBUF_UNLOCK(&cu->cu_socket->so_rcv);
 259                 cs = mem_alloc(sizeof(*cs));
 260                 SOCKBUF_LOCK(&cu->cu_socket->so_rcv);
 261                 if (so->so_upcall) {
 262                         /*
 263                          * We have lost a race with some other client.
 264                          */
 265                         mem_free(cs, sizeof(*cs));
 266                         goto recheck_socket;
 267                 }
 268                 mtx_init(&cs->cs_lock, "cs->cs_lock", NULL, MTX_DEF);
 269                 cs->cs_refs = 1;
 270                 TAILQ_INIT(&cs->cs_pending);
 271                 so->so_upcallarg = cs;
 272                 so->so_upcall = clnt_dg_soupcall;
 273                 so->so_rcv.sb_flags |= SB_UPCALL;
 274         }
 275         SOCKBUF_UNLOCK(&so->so_rcv);
 276
 277         cl->cl_ops = &clnt_dg_ops;
 278         cl->cl_private = (caddr_t)(void *)cu;
 279         cl->cl_auth = authnone_create();
 280         cl->cl_tp = NULL;
 281         cl->cl_netid = NULL;
 282         return (cl);
 283 err2:
 284         if (cl) {
 285                 mem_free(cl, sizeof (CLIENT));
 286                 if (cu)
 287                         mem_free(cu, sizeof (*cu));
 288         }
 289         return (NULL);
 290 }
 291
 292 static enum clnt_stat
 293 clnt_dg_call(
 294         CLIENT  *cl,                    /* client handle */
 295         rpcproc_t       proc,           /* procedure number */
 296         xdrproc_t       xargs,          /* xdr routine for args */
 297         void            *argsp,         /* pointer to args */
 298         xdrproc_t       xresults,       /* xdr routine for results */
 299         void            *resultsp,      /* pointer to results */
 300         struct timeval  utimeout)       /* seconds to wait before giving up */
 301 {
 302         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 303         struct cu_socket *cs = (struct cu_socket *) cu->cu_socket->so_upcallarg;
 304         XDR xdrs;
 305         struct rpc_msg reply_msg;
 306         bool_t ok;
 307         int nrefreshes = 2;             /* number of times to refresh cred */
 308         struct timeval timeout;
 309         struct timeval retransmit_time;
 310         struct timeval next_sendtime, starttime, time_waited, tv;
 311         struct sockaddr *sa;
 312         socklen_t salen;
 313         uint32_t xid;
 314         struct mbuf *mreq = NULL;
 315         struct cu_request cr;
 316         int error;
 317
 318         mtx_lock(&cs->cs_lock);
 319
 320         cr.cr_mrep = NULL;
 321         cr.cr_error = 0;
 322
 323         if (cu->cu_total.tv_usec == -1) {
 324                 timeout = utimeout;     /* use supplied timeout */
 325         } else {
 326                 timeout = cu->cu_total; /* use default timeout */
 327         }
 328
 329         if (cu->cu_connect && !cu->cu_connected) {
 330                 mtx_unlock(&cs->cs_lock);
 331                 error = soconnect(cu->cu_socket,
 332                     (struct sockaddr *)&cu->cu_raddr, curthread);
 333                 mtx_lock(&cs->cs_lock);
 334                 if (error) {
 335                         cu->cu_error.re_errno = error;
 336                         cu->cu_error.re_status = RPC_CANTSEND;
 337                         goto out;
 338                 }
 339                 cu->cu_connected = 1;
 340         }
 341         if (cu->cu_connected) {
 342                 sa = NULL;
 343                 salen = 0;
 344         } else {
 345                 sa = (struct sockaddr *)&cu->cu_raddr;
 346                 salen = cu->cu_rlen;
 347         }
 348         time_waited.tv_sec = 0;
 349         time_waited.tv_usec = 0;
 350         retransmit_time = next_sendtime = cu->cu_wait;
 351
 352         getmicrotime(&starttime);
 353
 354 call_again:
 355         mtx_assert(&cs->cs_lock, MA_OWNED);
 356
 357         cu->cu_xid++;
 358         xid = cu->cu_xid;
 359
 360 send_again:
 361         mtx_unlock(&cs->cs_lock);
 362
 363         MGETHDR(mreq, M_WAIT, MT_DATA);
 364         MCLGET(mreq, M_WAIT);
 365         mreq->m_len = 0;
 366         m_append(mreq, cu->cu_mcalllen, cu->cu_mcallc);
 367
 368         /*
 369          * The XID is the first thing in the request.
 370          */
 371         *mtod(mreq, uint32_t *) = htonl(xid);
 372
 373         xdrmbuf_create(&xdrs, mreq, XDR_ENCODE);
 374
 375         if (cu->cu_async == TRUE && xargs == NULL)
 376                 goto get_reply;
 377
 378         if ((! XDR_PUTINT32(&xdrs, &proc)) ||
 379             (! AUTH_MARSHALL(cl->cl_auth, &xdrs)) ||
 380             (! (*xargs)(&xdrs, argsp))) {
 381                 cu->cu_error.re_status = RPC_CANTENCODEARGS;
 382                 mtx_lock(&cs->cs_lock);
 383                 goto out;
 384         }
 385         m_fixhdr(mreq);
 386
 387         cr.cr_xid = xid;
 388         mtx_lock(&cs->cs_lock);
 389         TAILQ_INSERT_TAIL(&cs->cs_pending, &cr, cr_link);
 390         mtx_unlock(&cs->cs_lock);
 391
 392         /*
 393          * sosend consumes mreq.
 394          */
 395         error = sosend(cu->cu_socket, sa, NULL, mreq, NULL, 0, curthread);
 396         mreq = NULL;
 397
 398         /*
 399          * sub-optimal code appears here because we have
 400          * some clock time to spare while the packets are in flight.
 401          * (We assume that this is actually only executed once.)
 402          */
 403         reply_msg.acpted_rply.ar_verf = _null_auth;
 404         reply_msg.acpted_rply.ar_results.where = resultsp;
 405         reply_msg.acpted_rply.ar_results.proc = xresults;
 406
 407         mtx_lock(&cs->cs_lock);
 408         if (error) {
 409                 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
 410
 411                 cu->cu_error.re_errno = error;
 412                 cu->cu_error.re_status = RPC_CANTSEND;
 413                 goto out;
 414         }
 415
 416         /*
 417          * Check to see if we got an upcall while waiting for the
 418          * lock. In both these cases, the request has been removed
 419          * from cs->cs_pending.
 420          */
 421         if (cr.cr_error) {
 422                 cu->cu_error.re_errno = cr.cr_error;
 423                 cu->cu_error.re_status = RPC_CANTRECV;
 424                 goto out;
 425         }
 426         if (cr.cr_mrep) {
 427                 goto got_reply;
 428         }
 429
 430         /*
 431          * Hack to provide rpc-based message passing
 432          */
 433         if (timeout.tv_sec == 0 && timeout.tv_usec == 0) {
 434                 if (cr.cr_xid)
 435                         TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
 436                 cu->cu_error.re_status = RPC_TIMEDOUT;
 437                 goto out;
 438         }
 439
 440 get_reply:
 441         for (;;) {
 442                 /* Decide how long to wait. */
 443                 if (timevalcmp(&next_sendtime, &timeout, <)) {
 444                         tv = next_sendtime;
 445                 } else {
 446                         tv = timeout;
 447                 }
 448                 timevalsub(&tv, &time_waited);
 449                 if (tv.tv_sec < 0 || tv.tv_usec < 0)
 450                         tv.tv_sec = tv.tv_usec = 0;
 451
 452                 error = msleep(&cr, &cs->cs_lock, cu->cu_waitflag,
 453                     cu->cu_waitchan, tvtohz(&tv));
 454
 455                 if (!error) {
 456                         /*
 457                          * We were woken up by the upcall.  If the
 458                          * upcall had a receive error, report that,
 459                          * otherwise we have a reply.
 460                          */
 461                         if (cr.cr_error) {
 462                                 cu->cu_error.re_errno = cr.cr_error;
 463                                 cu->cu_error.re_status = RPC_CANTRECV;
 464                                 goto out;
 465                         }
 466                         break;
 467                 }
 468
 469                 /*
 470                  * The sleep returned an error so our request is still
 471                  * on the list. If we got EWOULDBLOCK, we may want to
 472                  * re-send the request.
 473                  */
 474                 if (error != EWOULDBLOCK) {
 475                         if (cr.cr_xid)
 476                                 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
 477                         cu->cu_error.re_errno = error;
 478                         if (error == EINTR)
 479                                 cu->cu_error.re_status = RPC_INTR;
 480                         else
 481                                 cu->cu_error.re_status = RPC_CANTRECV;
 482                         goto out;
 483                 }
 484
 485                 getmicrotime(&tv);
 486                 time_waited = tv;
 487                 timevalsub(&time_waited, &starttime);
 488
 489                 /* Check for timeout. */
 490                 if (timevalcmp(&time_waited, &timeout, >)) {
 491                         if (cr.cr_xid)
 492                                 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
 493                         cu->cu_error.re_errno = EWOULDBLOCK;
 494                         cu->cu_error.re_status = RPC_TIMEDOUT;
 495                         goto out;
 496                 }
 497
 498                 /* Retransmit if necessary. */
 499                 if (timevalcmp(&time_waited, &next_sendtime, >)) {
 500                         if (cr.cr_xid)
 501                                 TAILQ_REMOVE(&cs->cs_pending, &cr, cr_link);
 502                         /* update retransmit_time */
 503                         if (retransmit_time.tv_sec < RPC_MAX_BACKOFF)
 504                                 timevaladd(&retransmit_time, &retransmit_time);
 505                         timevaladd(&next_sendtime, &retransmit_time);
 506                         goto send_again;
 507                 }
 508         }
 509
 510 got_reply:
 511         /*
 512          * Now decode and validate the response. We need to drop the
 513          * lock since xdr_replymsg may end up sleeping in malloc.
 514          */
 515         mtx_unlock(&cs->cs_lock);
 516
 517         xdrmbuf_create(&xdrs, cr.cr_mrep, XDR_DECODE);
 518         ok = xdr_replymsg(&xdrs, &reply_msg);
 519         XDR_DESTROY(&xdrs);
 520         cr.cr_mrep = NULL;
 521
 522         mtx_lock(&cs->cs_lock);
 523
 524         if (ok) {
 525                 if ((reply_msg.rm_reply.rp_stat == MSG_ACCEPTED) &&
 526                         (reply_msg.acpted_rply.ar_stat == SUCCESS))
 527                         cu->cu_error.re_status = RPC_SUCCESS;
 528                 else
 529                         _seterr_reply(&reply_msg, &(cu->cu_error));
 530
 531                 if (cu->cu_error.re_status == RPC_SUCCESS) {
 532                         if (! AUTH_VALIDATE(cl->cl_auth,
 533                                             &reply_msg.acpted_rply.ar_verf)) {
 534                                 cu->cu_error.re_status = RPC_AUTHERROR;
 535                                 cu->cu_error.re_why = AUTH_INVALIDRESP;
 536                         }
 537                         if (reply_msg.acpted_rply.ar_verf.oa_base != NULL) {
 538                                 xdrs.x_op = XDR_FREE;
 539                                 (void) xdr_opaque_auth(&xdrs,
 540                                         &(reply_msg.acpted_rply.ar_verf));
 541                         }
 542                 }               /* end successful completion */
 543                 /*
 544                  * If unsuccesful AND error is an authentication error
 545                  * then refresh credentials and try again, else break
 546                  */
 547                 else if (cu->cu_error.re_status == RPC_AUTHERROR)
 548                         /* maybe our credentials need to be refreshed ... */
 549                         if (nrefreshes > 0 &&
 550                             AUTH_REFRESH(cl->cl_auth, &reply_msg)) {
 551                                 nrefreshes--;
 552                                 goto call_again;
 553                         }
 554                 /* end of unsuccessful completion */
 555         }       /* end of valid reply message */
 556         else {
 557                 cu->cu_error.re_status = RPC_CANTDECODERES;
 558
 559         }
 560 out:
 561         mtx_assert(&cs->cs_lock, MA_OWNED);
 562
 563         if (mreq)
 564                 m_freem(mreq);
 565         if (cr.cr_mrep)
 566                 m_freem(cr.cr_mrep);
 567
 568         mtx_unlock(&cs->cs_lock);
 569         return (cu->cu_error.re_status);
 570 }
 571
 572 static void
 573 clnt_dg_geterr(CLIENT *cl, struct rpc_err *errp)
 574 {
 575         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 576
 577         *errp = cu->cu_error;
 578 }
 579
 580 static bool_t
 581 clnt_dg_freeres(CLIENT *cl, xdrproc_t xdr_res, void *res_ptr)
 582 {
 583         XDR xdrs;
 584         bool_t dummy;
 585
 586         xdrs.x_op = XDR_FREE;
 587         dummy = (*xdr_res)(&xdrs, res_ptr);
 588
 589         return (dummy);
 590 }
 591
 592 /*ARGSUSED*/
 593 static void
 594 clnt_dg_abort(CLIENT *h)
 595 {
 596 }
 597
 598 static bool_t
 599 clnt_dg_control(CLIENT *cl, u_int request, void *info)
 600 {
 601         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 602         struct cu_socket *cs = (struct cu_socket *) cu->cu_socket->so_upcallarg;
 603         struct sockaddr *addr;
 604
 605         mtx_lock(&cs->cs_lock);
 606
 607         switch (request) {
 608         case CLSET_FD_CLOSE:
 609                 cu->cu_closeit = TRUE;
 610                 mtx_unlock(&cs->cs_lock);
 611                 return (TRUE);
 612         case CLSET_FD_NCLOSE:
 613                 cu->cu_closeit = FALSE;
 614                 mtx_unlock(&cs->cs_lock);
 615                 return (TRUE);
 616         }
 617
 618         /* for other requests which use info */
 619         if (info == NULL) {
 620                 mtx_unlock(&cs->cs_lock);
 621                 return (FALSE);
 622         }
 623         switch (request) {
 624         case CLSET_TIMEOUT:
 625                 if (time_not_ok((struct timeval *)info)) {
 626                         mtx_unlock(&cs->cs_lock);
 627                         return (FALSE);
 628                 }
 629                 cu->cu_total = *(struct timeval *)info;
 630                 break;
 631         case CLGET_TIMEOUT:
 632                 *(struct timeval *)info = cu->cu_total;
 633                 break;
 634         case CLSET_RETRY_TIMEOUT:
 635                 if (time_not_ok((struct timeval *)info)) {
 636                         mtx_unlock(&cs->cs_lock);
 637                         return (FALSE);
 638                 }
 639                 cu->cu_wait = *(struct timeval *)info;
 640                 break;
 641         case CLGET_RETRY_TIMEOUT:
 642                 *(struct timeval *)info = cu->cu_wait;
 643                 break;
 644         case CLGET_SVC_ADDR:
 645                 /*
 646                  * Slightly different semantics to userland - we use
 647                  * sockaddr instead of netbuf.
 648                  */
 649                 memcpy(info, &cu->cu_raddr, cu->cu_raddr.ss_len);
 650                 break;
 651         case CLSET_SVC_ADDR:            /* set to new address */
 652                 addr = (struct sockaddr *)info;
 653                 (void) memcpy(&cu->cu_raddr, addr, addr->sa_len);
 654                 break;
 655         case CLGET_XID:
 656                 *(uint32_t *)info = cu->cu_xid;
 657                 break;
 658
 659         case CLSET_XID:
 660                 /* This will set the xid of the NEXT call */
 661                 /* decrement by 1 as clnt_dg_call() increments once */
 662                 cu->cu_xid = *(uint32_t *)info - 1;
 663                 break;
 664
 665         case CLGET_VERS:
 666                 /*
 667                  * This RELIES on the information that, in the call body,
 668                  * the version number field is the fifth field from the
 669                  * begining of the RPC header. MUST be changed if the
 670                  * call_struct is changed
 671                  */
 672                 *(uint32_t *)info =
 673                     ntohl(*(uint32_t *)(void *)(cu->cu_mcallc +
 674                     4 * BYTES_PER_XDR_UNIT));
 675                 break;
 676
 677         case CLSET_VERS:
 678                 *(uint32_t *)(void *)(cu->cu_mcallc + 4 * BYTES_PER_XDR_UNIT)
 679                         = htonl(*(uint32_t *)info);
 680                 break;
 681
 682         case CLGET_PROG:
 683                 /*
 684                  * This RELIES on the information that, in the call body,
 685                  * the program number field is the fourth field from the
 686                  * begining of the RPC header. MUST be changed if the
 687                  * call_struct is changed
 688                  */
 689                 *(uint32_t *)info =
 690                     ntohl(*(uint32_t *)(void *)(cu->cu_mcallc +
 691                     3 * BYTES_PER_XDR_UNIT));
 692                 break;
 693
 694         case CLSET_PROG:
 695                 *(uint32_t *)(void *)(cu->cu_mcallc + 3 * BYTES_PER_XDR_UNIT)
 696                         = htonl(*(uint32_t *)info);
 697                 break;
 698         case CLSET_ASYNC:
 699                 cu->cu_async = *(int *)info;
 700                 break;
 701         case CLSET_CONNECT:
 702                 cu->cu_connect = *(int *)info;
 703                 break;
 704         case CLSET_WAITCHAN:
 705                 cu->cu_waitchan = *(const char **)info;
 706                 break;
 707         case CLGET_WAITCHAN:
 708                 *(const char **) info = cu->cu_waitchan;
 709                 break;
 710         case CLSET_INTERRUPTIBLE:
 711                 if (*(int *) info)
 712                         cu->cu_waitflag = PCATCH;
 713                 else
 714                         cu->cu_waitflag = 0;
 715                 break;
 716         case CLGET_INTERRUPTIBLE:
 717                 if (cu->cu_waitflag)
 718                         *(int *) info = TRUE;
 719                 else
 720                         *(int *) info = FALSE;
 721                 break;
 722         default:
 723                 mtx_unlock(&cs->cs_lock);
 724                 return (FALSE);
 725         }
 726         mtx_unlock(&cs->cs_lock);
 727         return (TRUE);
 728 }
 729
 730 static void
 731 clnt_dg_destroy(CLIENT *cl)
 732 {
 733         struct cu_data *cu = (struct cu_data *)cl->cl_private;
 734         struct cu_socket *cs = (struct cu_socket *) cu->cu_socket->so_upcallarg;
 735         struct socket *so = NULL;
 736         bool_t lastsocketref;
 737
 738         SOCKBUF_LOCK(&cu->cu_socket->so_rcv);
 739
 740         mtx_lock(&cs->cs_lock);
 741         cs->cs_refs--;
 742         if (cs->cs_refs == 0) {
 743                 cu->cu_socket->so_upcallarg = NULL;
 744                 cu->cu_socket->so_upcall = NULL;
 745                 cu->cu_socket->so_rcv.sb_flags &= ~SB_UPCALL;
 746                 mtx_destroy(&cs->cs_lock);
 747                 SOCKBUF_UNLOCK(&cu->cu_socket->so_rcv);
 748                 mem_free(cs, sizeof(*cs));
 749                 lastsocketref = TRUE;
 750         } else {
 751                 mtx_unlock(&cs->cs_lock);
 752                 SOCKBUF_UNLOCK(&cu->cu_socket->so_rcv);
 753                 lastsocketref = FALSE;
 754         }
 755
 756         if (cu->cu_closeit) {
 757                 KASSERT(lastsocketref, ("clnt_dg_destroy(): closing a socket "
 758                         "shared with other clients"));
 759                 so = cu->cu_socket;
 760                 cu->cu_socket = NULL;
 761         }
 762
 763         if (so)
 764                 soclose(so);
 765
 766         if (cl->cl_netid && cl->cl_netid[0])
 767                 mem_free(cl->cl_netid, strlen(cl->cl_netid) +1);
 768         if (cl->cl_tp && cl->cl_tp[0])
 769                 mem_free(cl->cl_tp, strlen(cl->cl_tp) +1);
 770         mem_free(cu, sizeof (*cu));
 771         mem_free(cl, sizeof (CLIENT));
 772 }
 773
 774 /*
 775  * Make sure that the time is not garbage.  -1 value is allowed.
 776  */
 777 static bool_t
 778 time_not_ok(struct timeval *t)
 779 {
 780         return (t->tv_sec < -1 || t->tv_sec > 100000000 ||
 781                 t->tv_usec < -1 || t->tv_usec > 1000000);
 782 }
 783
 784 void
 785 clnt_dg_soupcall(struct socket *so, void *arg, int waitflag)
 786 {
 787         struct cu_socket *cs = (struct cu_socket *) arg;
 788         struct uio uio;
 789         struct mbuf *m;
 790         struct mbuf *control;
 791         struct cu_request *cr;
 792         int error, rcvflag, foundreq;
 793         uint32_t xid;
 794
 795         uio.uio_resid = 1000000000;
 796         uio.uio_td = curthread;
 797         do {
 798                 m = NULL;
 799                 control = NULL;
 800                 rcvflag = MSG_DONTWAIT;
 801                 error = soreceive(so, NULL, &uio, &m, &control, &rcvflag);
 802                 if (control)
 803                         m_freem(control);
 804
 805                 if (error == EWOULDBLOCK)
 806                         break;
 807
 808                 /*
 809                  * If there was an error, wake up all pending
 810                  * requests.
 811                  */
 812                 if (error) {
 813                         mtx_lock(&cs->cs_lock);
 814                         TAILQ_FOREACH(cr, &cs->cs_pending, cr_link) {
 815                                 cr->cr_error = error;
 816                                 wakeup(cr);
 817                         }
 818                         TAILQ_INIT(&cs->cs_pending);
 819                         mtx_unlock(&cs->cs_lock);
 820                         break;
 821                 }
 822
 823                 /*
 824                  * The XID is in the first uint32_t of the reply.
 825                  */
 826                 m = m_pullup(m, sizeof(xid));
 827                 if (!m)
 828                         break;
 829                 xid = ntohl(*mtod(m, uint32_t *));
 830
 831                 /*
 832                  * Attempt to match this reply with a pending request.
 833                  */
 834                 mtx_lock(&cs->cs_lock);
 835                 foundreq = 0;
 836                 TAILQ_FOREACH(cr, &cs->cs_pending, cr_link) {
 837                         if (cr->cr_xid == xid) {
 838                                 /*
 839                                  * This one matches. We snip it out of
 840                                  * the pending list and leave the
 841                                  * reply mbuf in cr->cr_mrep. Set the
 842                                  * XID to zero so that clnt_dg_call
 843                                  * can know not to repeat the
 844                                  * TAILQ_REMOVE.
 845                                  */
 846                                 TAILQ_REMOVE(&cs->cs_pending, cr, cr_link);
 847                                 cr->cr_xid = 0;
 848                                 cr->cr_mrep = m;
 849                                 cr->cr_error = 0;
 850                                 foundreq = 1;
 851                                 wakeup(cr);
 852                                 break;
 853                         }
 854                 }
 855                 mtx_unlock(&cs->cs_lock);
 856
 857                 /*
 858                  * If we didn't find the matching request, just drop
 859                  * it - its probably a repeated reply.
 860                  */
 861                 if (!foundreq)
 862                         m_freem(m);
 863         } while (m);
 864 }
 865