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/svc.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  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: svc.c,v 1.21 2000/07/06 03:10:35 christos 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 #if defined(LIBC_SCCS) && !defined(lint)
   33 static char *sccsid2 = "@(#)svc.c 1.44 88/02/08 Copyr 1984 Sun Micro";
   34 static char *sccsid = "@(#)svc.c        2.4 88/08/11 4.0 RPCSRC";
   35 #endif
   36 #include <sys/cdefs.h>
   37 __FBSDID("$FreeBSD$");
   38 
   39 /*
   40  * svc.c, Server-side remote procedure call interface.
   41  *
   42  * There are two sets of procedures here.  The xprt routines are
   43  * for handling transport handles.  The svc routines handle the
   44  * list of service routines.
   45  *
   46  * Copyright (C) 1984, Sun Microsystems, Inc.
   47  */
   48 
   49 #include <sys/param.h>
   50 #include <sys/lock.h>
   51 #include <sys/kernel.h>
   52 #include <sys/malloc.h>
   53 #include <sys/mutex.h>
   54 #include <sys/queue.h>
   55 #include <sys/systm.h>
   56 #include <sys/ucred.h>
   57 
   58 #include <rpc/rpc.h>
   59 #include <rpc/rpcb_clnt.h>
   60 
   61 #include <rpc/rpc_com.h>
   62 
   63 #define SVC_VERSQUIET 0x0001            /* keep quiet about vers mismatch */
   64 #define version_keepquiet(xp) ((u_long)(xp)->xp_p3 & SVC_VERSQUIET)
   65 
   66 static struct svc_callout *svc_find(SVCPOOL *pool, rpcprog_t, rpcvers_t,
   67     char *);
   68 static void __xprt_do_unregister (SVCXPRT *xprt, bool_t dolock);
   69 
   70 /* ***************  SVCXPRT related stuff **************** */
   71 
   72 SVCPOOL*
   73 svcpool_create(void)
   74 {
   75         SVCPOOL *pool;
   76 
   77         pool = malloc(sizeof(SVCPOOL), M_RPC, M_WAITOK|M_ZERO);
   78         
   79         mtx_init(&pool->sp_lock, "sp_lock", NULL, MTX_DEF);
   80         TAILQ_INIT(&pool->sp_xlist);
   81         TAILQ_INIT(&pool->sp_active);
   82         TAILQ_INIT(&pool->sp_callouts);
   83 
   84         return pool;
   85 }
   86 
   87 void
   88 svcpool_destroy(SVCPOOL *pool)
   89 {
   90         SVCXPRT *xprt;
   91         struct svc_callout *s;
   92 
   93         mtx_lock(&pool->sp_lock);
   94 
   95         while (TAILQ_FIRST(&pool->sp_xlist)) {
   96                 xprt = TAILQ_FIRST(&pool->sp_xlist);
   97                 mtx_unlock(&pool->sp_lock);
   98                 SVC_DESTROY(xprt);
   99                 mtx_lock(&pool->sp_lock);
  100         }
  101 
  102         while (TAILQ_FIRST(&pool->sp_callouts)) {
  103                 s = TAILQ_FIRST(&pool->sp_callouts);
  104                 mtx_unlock(&pool->sp_lock);
  105                 svc_unreg(pool, s->sc_prog, s->sc_vers);
  106                 mtx_lock(&pool->sp_lock);
  107         }
  108 
  109         mtx_destroy(&pool->sp_lock);
  110         free(pool, M_RPC);
  111 }
  112 
  113 /*
  114  * Activate a transport handle.
  115  */
  116 void
  117 xprt_register(SVCXPRT *xprt)
  118 {
  119         SVCPOOL *pool = xprt->xp_pool;
  120 
  121         mtx_lock(&pool->sp_lock);
  122         xprt->xp_registered = TRUE;
  123         xprt->xp_active = FALSE;
  124         TAILQ_INSERT_TAIL(&pool->sp_xlist, xprt, xp_link);
  125         mtx_unlock(&pool->sp_lock);
  126 }
  127 
  128 void
  129 xprt_unregister(SVCXPRT *xprt)
  130 {
  131         __xprt_do_unregister(xprt, TRUE);
  132 }
  133 
  134 void
  135 __xprt_unregister_unlocked(SVCXPRT *xprt)
  136 {
  137         __xprt_do_unregister(xprt, FALSE);
  138 }
  139 
  140 /*
  141  * De-activate a transport handle.
  142  */
  143 static void
  144 __xprt_do_unregister(SVCXPRT *xprt, bool_t dolock)
  145 {
  146         SVCPOOL *pool = xprt->xp_pool;
  147 
  148         //__svc_generic_cleanup(xprt);
  149 
  150         if (dolock)
  151                 mtx_lock(&pool->sp_lock);
  152 
  153         if (xprt->xp_active) {
  154                 TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink);
  155                 xprt->xp_active = FALSE;
  156         }
  157         TAILQ_REMOVE(&pool->sp_xlist, xprt, xp_link);
  158         xprt->xp_registered = FALSE;
  159 
  160         if (dolock)
  161                 mtx_unlock(&pool->sp_lock);
  162 }
  163 
  164 void
  165 xprt_active(SVCXPRT *xprt)
  166 {
  167         SVCPOOL *pool = xprt->xp_pool;
  168 
  169         mtx_lock(&pool->sp_lock);
  170 
  171         if (!xprt->xp_active) {
  172                 TAILQ_INSERT_TAIL(&pool->sp_active, xprt, xp_alink);
  173                 xprt->xp_active = TRUE;
  174         }
  175         wakeup(&pool->sp_active);
  176 
  177         mtx_unlock(&pool->sp_lock);
  178 }
  179 
  180 void
  181 xprt_inactive(SVCXPRT *xprt)
  182 {
  183         SVCPOOL *pool = xprt->xp_pool;
  184 
  185         mtx_lock(&pool->sp_lock);
  186 
  187         if (xprt->xp_active) {
  188                 TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink);
  189                 xprt->xp_active = FALSE;
  190         }
  191         wakeup(&pool->sp_active);
  192 
  193         mtx_unlock(&pool->sp_lock);
  194 }
  195 
  196 /*
  197  * Add a service program to the callout list.
  198  * The dispatch routine will be called when a rpc request for this
  199  * program number comes in.
  200  */
  201 bool_t
  202 svc_reg(SVCXPRT *xprt, const rpcprog_t prog, const rpcvers_t vers,
  203     void (*dispatch)(struct svc_req *, SVCXPRT *),
  204     const struct netconfig *nconf)
  205 {
  206         SVCPOOL *pool = xprt->xp_pool;
  207         struct svc_callout *s;
  208         char *netid = NULL;
  209         int flag = 0;
  210 
  211 /* VARIABLES PROTECTED BY svc_lock: s, svc_head */
  212 
  213         if (xprt->xp_netid) {
  214                 netid = strdup(xprt->xp_netid, M_RPC);
  215                 flag = 1;
  216         } else if (nconf && nconf->nc_netid) {
  217                 netid = strdup(nconf->nc_netid, M_RPC);
  218                 flag = 1;
  219         } /* must have been created with svc_raw_create */
  220         if ((netid == NULL) && (flag == 1)) {
  221                 return (FALSE);
  222         }
  223 
  224         mtx_lock(&pool->sp_lock);
  225         if ((s = svc_find(pool, prog, vers, netid)) != NULL) {
  226                 if (netid)
  227                         free(netid, M_RPC);
  228                 if (s->sc_dispatch == dispatch)
  229                         goto rpcb_it; /* he is registering another xptr */
  230                 mtx_unlock(&pool->sp_lock);
  231                 return (FALSE);
  232         }
  233         s = malloc(sizeof (struct svc_callout), M_RPC, M_NOWAIT);
  234         if (s == NULL) {
  235                 if (netid)
  236                         free(netid, M_RPC);
  237                 mtx_unlock(&pool->sp_lock);
  238                 return (FALSE);
  239         }
  240 
  241         s->sc_prog = prog;
  242         s->sc_vers = vers;
  243         s->sc_dispatch = dispatch;
  244         s->sc_netid = netid;
  245         TAILQ_INSERT_TAIL(&pool->sp_callouts, s, sc_link);
  246 
  247         if ((xprt->xp_netid == NULL) && (flag == 1) && netid)
  248                 ((SVCXPRT *) xprt)->xp_netid = strdup(netid, M_RPC);
  249 
  250 rpcb_it:
  251         mtx_unlock(&pool->sp_lock);
  252         /* now register the information with the local binder service */
  253         if (nconf) {
  254                 bool_t dummy;
  255                 struct netconfig tnc;
  256                 tnc = *nconf;
  257                 dummy = rpcb_set(prog, vers, &tnc,
  258                     &((SVCXPRT *) xprt)->xp_ltaddr);
  259                 return (dummy);
  260         }
  261         return (TRUE);
  262 }
  263 
  264 /*
  265  * Remove a service program from the callout list.
  266  */
  267 void
  268 svc_unreg(SVCPOOL *pool, const rpcprog_t prog, const rpcvers_t vers)
  269 {
  270         struct svc_callout *s;
  271 
  272         /* unregister the information anyway */
  273         (void) rpcb_unset(prog, vers, NULL);
  274         mtx_lock(&pool->sp_lock);
  275         while ((s = svc_find(pool, prog, vers, NULL)) != NULL) {
  276                 TAILQ_REMOVE(&pool->sp_callouts, s, sc_link);
  277                 if (s->sc_netid)
  278                         mem_free(s->sc_netid, sizeof (s->sc_netid) + 1);
  279                 mem_free(s, sizeof (struct svc_callout));
  280         }
  281         mtx_unlock(&pool->sp_lock);
  282 }
  283 
  284 /* ********************** CALLOUT list related stuff ************* */
  285 
  286 /*
  287  * Search the callout list for a program number, return the callout
  288  * struct.
  289  */
  290 static struct svc_callout *
  291 svc_find(SVCPOOL *pool, rpcprog_t prog, rpcvers_t vers, char *netid)
  292 {
  293         struct svc_callout *s;
  294 
  295         mtx_assert(&pool->sp_lock, MA_OWNED);
  296         TAILQ_FOREACH(s, &pool->sp_callouts, sc_link) {
  297                 if (s->sc_prog == prog && s->sc_vers == vers
  298                     && (netid == NULL || s->sc_netid == NULL ||
  299                         strcmp(netid, s->sc_netid) == 0))
  300                         break;
  301         }
  302 
  303         return (s);
  304 }
  305 
  306 /* ******************* REPLY GENERATION ROUTINES  ************ */
  307 
  308 /*
  309  * Send a reply to an rpc request
  310  */
  311 bool_t
  312 svc_sendreply(SVCXPRT *xprt, xdrproc_t xdr_results, void * xdr_location)
  313 {
  314         struct rpc_msg rply; 
  315 
  316         rply.rm_direction = REPLY;  
  317         rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  318         rply.acpted_rply.ar_verf = xprt->xp_verf; 
  319         rply.acpted_rply.ar_stat = SUCCESS;
  320         rply.acpted_rply.ar_results.where = xdr_location;
  321         rply.acpted_rply.ar_results.proc = xdr_results;
  322 
  323         return (SVC_REPLY(xprt, &rply)); 
  324 }
  325 
  326 /*
  327  * No procedure error reply
  328  */
  329 void
  330 svcerr_noproc(SVCXPRT *xprt)
  331 {
  332         struct rpc_msg rply;
  333 
  334         rply.rm_direction = REPLY;
  335         rply.rm_reply.rp_stat = MSG_ACCEPTED;
  336         rply.acpted_rply.ar_verf = xprt->xp_verf;
  337         rply.acpted_rply.ar_stat = PROC_UNAVAIL;
  338 
  339         SVC_REPLY(xprt, &rply);
  340 }
  341 
  342 /*
  343  * Can't decode args error reply
  344  */
  345 void
  346 svcerr_decode(SVCXPRT *xprt)
  347 {
  348         struct rpc_msg rply; 
  349 
  350         rply.rm_direction = REPLY; 
  351         rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  352         rply.acpted_rply.ar_verf = xprt->xp_verf;
  353         rply.acpted_rply.ar_stat = GARBAGE_ARGS;
  354 
  355         SVC_REPLY(xprt, &rply); 
  356 }
  357 
  358 /*
  359  * Some system error
  360  */
  361 void
  362 svcerr_systemerr(SVCXPRT *xprt)
  363 {
  364         struct rpc_msg rply; 
  365 
  366         rply.rm_direction = REPLY; 
  367         rply.rm_reply.rp_stat = MSG_ACCEPTED; 
  368         rply.acpted_rply.ar_verf = xprt->xp_verf;
  369         rply.acpted_rply.ar_stat = SYSTEM_ERR;
  370 
  371         SVC_REPLY(xprt, &rply); 
  372 }
  373 
  374 /*
  375  * Authentication error reply
  376  */
  377 void
  378 svcerr_auth(SVCXPRT *xprt, enum auth_stat why)
  379 {
  380         struct rpc_msg rply;
  381 
  382         rply.rm_direction = REPLY;
  383         rply.rm_reply.rp_stat = MSG_DENIED;
  384         rply.rjcted_rply.rj_stat = AUTH_ERROR;
  385         rply.rjcted_rply.rj_why = why;
  386 
  387         SVC_REPLY(xprt, &rply);
  388 }
  389 
  390 /*
  391  * Auth too weak error reply
  392  */
  393 void
  394 svcerr_weakauth(SVCXPRT *xprt)
  395 {
  396 
  397         svcerr_auth(xprt, AUTH_TOOWEAK);
  398 }
  399 
  400 /*
  401  * Program unavailable error reply
  402  */
  403 void 
  404 svcerr_noprog(SVCXPRT *xprt)
  405 {
  406         struct rpc_msg rply;  
  407 
  408         rply.rm_direction = REPLY;   
  409         rply.rm_reply.rp_stat = MSG_ACCEPTED;  
  410         rply.acpted_rply.ar_verf = xprt->xp_verf;  
  411         rply.acpted_rply.ar_stat = PROG_UNAVAIL;
  412 
  413         SVC_REPLY(xprt, &rply);
  414 }
  415 
  416 /*
  417  * Program version mismatch error reply
  418  */
  419 void  
  420 svcerr_progvers(SVCXPRT *xprt, rpcvers_t low_vers, rpcvers_t high_vers)
  421 {
  422         struct rpc_msg rply;
  423 
  424         rply.rm_direction = REPLY;
  425         rply.rm_reply.rp_stat = MSG_ACCEPTED;
  426         rply.acpted_rply.ar_verf = xprt->xp_verf;
  427         rply.acpted_rply.ar_stat = PROG_MISMATCH;
  428         rply.acpted_rply.ar_vers.low = (uint32_t)low_vers;
  429         rply.acpted_rply.ar_vers.high = (uint32_t)high_vers;
  430 
  431         SVC_REPLY(xprt, &rply);
  432 }
  433 
  434 /* ******************* SERVER INPUT STUFF ******************* */
  435 
  436 /*
  437  * Get server side input from some transport.
  438  *
  439  * Statement of authentication parameters management:
  440  * This function owns and manages all authentication parameters, specifically
  441  * the "raw" parameters (msg.rm_call.cb_cred and msg.rm_call.cb_verf) and
  442  * the "cooked" credentials (rqst->rq_clntcred).
  443  * In-kernel, we represent non-trivial cooked creds with struct ucred.
  444  * In all events, all three parameters are freed upon exit from this routine.
  445  * The storage is trivially management on the call stack in user land, but
  446  * is mallocated in kernel land.
  447  */
  448 
  449 static void
  450 svc_getreq(SVCXPRT *xprt)
  451 {
  452         SVCPOOL *pool = xprt->xp_pool;
  453         struct svc_req r;
  454         struct rpc_msg msg;
  455         int prog_found;
  456         rpcvers_t low_vers;
  457         rpcvers_t high_vers;
  458         enum xprt_stat stat;
  459         char cred_area[2*MAX_AUTH_BYTES + sizeof(struct xucred)];
  460 
  461         msg.rm_call.cb_cred.oa_base = cred_area;
  462         msg.rm_call.cb_verf.oa_base = &cred_area[MAX_AUTH_BYTES];
  463         r.rq_clntcred = &cred_area[2*MAX_AUTH_BYTES];
  464 
  465         /* now receive msgs from xprtprt (support batch calls) */
  466         do {
  467                 if (SVC_RECV(xprt, &msg)) {
  468 
  469                         /* now find the exported program and call it */
  470                         struct svc_callout *s;
  471                         enum auth_stat why;
  472 
  473                         r.rq_xprt = xprt;
  474                         r.rq_prog = msg.rm_call.cb_prog;
  475                         r.rq_vers = msg.rm_call.cb_vers;
  476                         r.rq_proc = msg.rm_call.cb_proc;
  477                         r.rq_cred = msg.rm_call.cb_cred;
  478                         /* first authenticate the message */
  479                         if ((why = _authenticate(&r, &msg)) != AUTH_OK) {
  480                                 svcerr_auth(xprt, why);
  481                                 goto call_done;
  482                         }
  483                         /* now match message with a registered service*/
  484                         prog_found = FALSE;
  485                         low_vers = (rpcvers_t) -1L;
  486                         high_vers = (rpcvers_t) 0L;
  487                         TAILQ_FOREACH(s, &pool->sp_callouts, sc_link) {
  488                                 if (s->sc_prog == r.rq_prog) {
  489                                         if (s->sc_vers == r.rq_vers) {
  490                                                 (*s->sc_dispatch)(&r, xprt);
  491                                                 goto call_done;
  492                                         }  /* found correct version */
  493                                         prog_found = TRUE;
  494                                         if (s->sc_vers < low_vers)
  495                                                 low_vers = s->sc_vers;
  496                                         if (s->sc_vers > high_vers)
  497                                                 high_vers = s->sc_vers;
  498                                 }   /* found correct program */
  499                         }
  500                         /*
  501                          * if we got here, the program or version
  502                          * is not served ...
  503                          */
  504                         if (prog_found)
  505                                 svcerr_progvers(xprt, low_vers, high_vers);
  506                         else
  507                                 svcerr_noprog(xprt);
  508                         /* Fall through to ... */
  509                 }
  510                 /*
  511                  * Check if the xprt has been disconnected in a
  512                  * recursive call in the service dispatch routine.
  513                  * If so, then break.
  514                  */
  515                 mtx_lock(&pool->sp_lock);
  516                 if (!xprt->xp_registered) {
  517                         mtx_unlock(&pool->sp_lock);
  518                         break;
  519                 }
  520                 mtx_unlock(&pool->sp_lock);
  521 call_done:
  522                 if ((stat = SVC_STAT(xprt)) == XPRT_DIED) {
  523                         SVC_DESTROY(xprt);
  524                         break;
  525                 }
  526         } while (stat == XPRT_MOREREQS);
  527 }
  528 
  529 void
  530 svc_run(SVCPOOL *pool)
  531 {
  532         SVCXPRT *xprt;
  533         int error;
  534 
  535         mtx_lock(&pool->sp_lock);
  536 
  537         pool->sp_exited = FALSE;
  538 
  539         while (!pool->sp_exited) {
  540                 xprt = TAILQ_FIRST(&pool->sp_active);
  541                 if (!xprt) {
  542                         error = msleep(&pool->sp_active, &pool->sp_lock, PCATCH,
  543                             "rpcsvc", 0);
  544                         if (error)
  545                                 break;
  546                         continue;
  547                 }
  548 
  549                 /*
  550                  * Move this transport to the end to ensure fairness
  551                  * when multiple transports are active. If this was
  552                  * the last queued request, svc_getreq will end up
  553                  * calling xprt_inactive to remove from the active
  554                  * list.
  555                  */
  556                 TAILQ_REMOVE(&pool->sp_active, xprt, xp_alink);
  557                 TAILQ_INSERT_TAIL(&pool->sp_active, xprt, xp_alink);
  558 
  559                 mtx_unlock(&pool->sp_lock);
  560                 svc_getreq(xprt);
  561                 mtx_lock(&pool->sp_lock);
  562         }
  563 
  564         mtx_unlock(&pool->sp_lock);
  565 }
  566 
  567 void
  568 svc_exit(SVCPOOL *pool)
  569 {
  570         mtx_lock(&pool->sp_lock);
  571         pool->sp_exited = TRUE;
  572         wakeup(&pool->sp_active);
  573         mtx_unlock(&pool->sp_lock);
  574 }

Cache object: 6b6a1209d93b3b2e5957ae19f5358183


[ 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.