The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/rpc/clnt_dg.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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 

Cache object: 9fc436e6c696e7bcd3ae45be8a8a3c61


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.