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/nlm/nlm_prot_svc.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 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
    5  * Authors: Doug Rabson <dfr@rabson.org>
    6  * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  */
   29 
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 
   33 #include <nlm/nlm_prot.h>
   34 #include <nlm/nlm.h>
   35 
   36 #include <sys/cdefs.h>
   37 #ifndef lint
   38 /*static char sccsid[] = "from: @(#)nlm_prot.x 1.8 87/09/21 Copyr 1987 Sun Micro";*/
   39 /*static char sccsid[] = "from: * @(#)nlm_prot.x        2.1 88/08/01 4.0 RPCSRC";*/
   40 __RCSID("$NetBSD: nlm_prot.x,v 1.6 2000/06/07 14:30:15 bouyer Exp $");
   41 #endif /* not lint */
   42 __FBSDID("$FreeBSD: releng/12.0/sys/nlm/nlm_prot_svc.c 326272 2017-11-27 15:23:17Z pfg $");
   43 
   44 void nlm_prog_0(struct svc_req *rqstp, SVCXPRT *transp);
   45 void nlm_prog_1(struct svc_req *rqstp, SVCXPRT *transp);
   46 void nlm_prog_3(struct svc_req *rqstp, SVCXPRT *transp);
   47 void nlm_prog_4(struct svc_req *rqstp, SVCXPRT *transp);
   48 
   49 void
   50 nlm_prog_0(struct svc_req *rqstp, SVCXPRT *transp)
   51 {
   52         union {
   53                 struct nlm_sm_status nlm_sm_notify_0_arg;
   54         } argument;
   55         char result;
   56         bool_t retval;
   57         xdrproc_t xdr_argument, xdr_result;
   58         bool_t (*local)(char *, void *, struct svc_req *);
   59 
   60         switch (rqstp->rq_proc) {
   61         case NULLPROC:
   62                 (void) svc_sendreply(rqstp,
   63                         (xdrproc_t) xdr_void, (char *)NULL);
   64                 svc_freereq(rqstp);
   65                 return;
   66 
   67         case NLM_SM_NOTIFY:
   68                 xdr_argument = (xdrproc_t) xdr_nlm_sm_status;
   69                 xdr_result = (xdrproc_t) xdr_void;
   70                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_sm_notify_0_svc;
   71                 break;
   72 
   73         default:
   74                 svcerr_noproc(rqstp);
   75                 svc_freereq(rqstp);
   76                 return;
   77         }
   78         (void) memset((char *)&argument, 0, sizeof (argument));
   79         if (!svc_getargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
   80                 svcerr_decode(rqstp);
   81                 svc_freereq(rqstp);
   82                 return;
   83         }
   84         retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
   85         if (retval > 0 && !svc_sendreply(rqstp, xdr_result, (char *)&result)) {
   86                 svcerr_systemerr(rqstp);
   87         }
   88         if (!svc_freeargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
   89                 printf("unable to free arguments");
   90                 //exit(1);
   91         }
   92         svc_freereq(rqstp);
   93 
   94         return;
   95 }
   96 
   97 void
   98 nlm_prog_1(struct svc_req *rqstp, SVCXPRT *transp)
   99 {
  100         union {
  101                 struct nlm_testargs nlm_test_1_arg;
  102                 struct nlm_lockargs nlm_lock_1_arg;
  103                 struct nlm_cancargs nlm_cancel_1_arg;
  104                 struct nlm_unlockargs nlm_unlock_1_arg;
  105                 struct nlm_testargs nlm_granted_1_arg;
  106                 struct nlm_testargs nlm_test_msg_1_arg;
  107                 struct nlm_lockargs nlm_lock_msg_1_arg;
  108                 struct nlm_cancargs nlm_cancel_msg_1_arg;
  109                 struct nlm_unlockargs nlm_unlock_msg_1_arg;
  110                 struct nlm_testargs nlm_granted_msg_1_arg;
  111                 nlm_testres nlm_test_res_1_arg;
  112                 nlm_res nlm_lock_res_1_arg;
  113                 nlm_res nlm_cancel_res_1_arg;
  114                 nlm_res nlm_unlock_res_1_arg;
  115                 nlm_res nlm_granted_res_1_arg;
  116         } argument;
  117         union {
  118                 nlm_testres nlm_test_1_res;
  119                 nlm_res nlm_lock_1_res;
  120                 nlm_res nlm_cancel_1_res;
  121                 nlm_res nlm_unlock_1_res;
  122                 nlm_res nlm_granted_1_res;
  123         } result;
  124         bool_t retval;
  125         xdrproc_t xdr_argument, xdr_result;
  126         bool_t (*local)(char *, void *, struct svc_req *);
  127 
  128         switch (rqstp->rq_proc) {
  129         case NULLPROC:
  130                 (void) svc_sendreply(rqstp,
  131                         (xdrproc_t) xdr_void, (char *)NULL);
  132                 svc_freereq(rqstp);
  133                 return;
  134 
  135         case NLM_TEST:
  136                 xdr_argument = (xdrproc_t) xdr_nlm_testargs;
  137                 xdr_result = (xdrproc_t) xdr_nlm_testres;
  138                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_test_1_svc;
  139                 break;
  140 
  141         case NLM_LOCK:
  142                 xdr_argument = (xdrproc_t) xdr_nlm_lockargs;
  143                 xdr_result = (xdrproc_t) xdr_nlm_res;
  144                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_lock_1_svc;
  145                 break;
  146 
  147         case NLM_CANCEL:
  148                 xdr_argument = (xdrproc_t) xdr_nlm_cancargs;
  149                 xdr_result = (xdrproc_t) xdr_nlm_res;
  150                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_cancel_1_svc;
  151                 break;
  152 
  153         case NLM_UNLOCK:
  154                 xdr_argument = (xdrproc_t) xdr_nlm_unlockargs;
  155                 xdr_result = (xdrproc_t) xdr_nlm_res;
  156                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_unlock_1_svc;
  157                 break;
  158 
  159         case NLM_GRANTED:
  160                 xdr_argument = (xdrproc_t) xdr_nlm_testargs;
  161                 xdr_result = (xdrproc_t) xdr_nlm_res;
  162                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_granted_1_svc;
  163                 break;
  164 
  165         case NLM_TEST_MSG:
  166                 xdr_argument = (xdrproc_t) xdr_nlm_testargs;
  167                 xdr_result = (xdrproc_t) xdr_void;
  168                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_test_msg_1_svc;
  169                 break;
  170 
  171         case NLM_LOCK_MSG:
  172                 xdr_argument = (xdrproc_t) xdr_nlm_lockargs;
  173                 xdr_result = (xdrproc_t) xdr_void;
  174                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_lock_msg_1_svc;
  175                 break;
  176 
  177         case NLM_CANCEL_MSG:
  178                 xdr_argument = (xdrproc_t) xdr_nlm_cancargs;
  179                 xdr_result = (xdrproc_t) xdr_void;
  180                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_cancel_msg_1_svc;
  181                 break;
  182 
  183         case NLM_UNLOCK_MSG:
  184                 xdr_argument = (xdrproc_t) xdr_nlm_unlockargs;
  185                 xdr_result = (xdrproc_t) xdr_void;
  186                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_unlock_msg_1_svc;
  187                 break;
  188 
  189         case NLM_GRANTED_MSG:
  190                 xdr_argument = (xdrproc_t) xdr_nlm_testargs;
  191                 xdr_result = (xdrproc_t) xdr_void;
  192                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_granted_msg_1_svc;
  193                 break;
  194 
  195         case NLM_TEST_RES:
  196                 xdr_argument = (xdrproc_t) xdr_nlm_testres;
  197                 xdr_result = (xdrproc_t) xdr_void;
  198                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_test_res_1_svc;
  199                 break;
  200 
  201         case NLM_LOCK_RES:
  202                 xdr_argument = (xdrproc_t) xdr_nlm_res;
  203                 xdr_result = (xdrproc_t) xdr_void;
  204                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_lock_res_1_svc;
  205                 break;
  206 
  207         case NLM_CANCEL_RES:
  208                 xdr_argument = (xdrproc_t) xdr_nlm_res;
  209                 xdr_result = (xdrproc_t) xdr_void;
  210                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_cancel_res_1_svc;
  211                 break;
  212 
  213         case NLM_UNLOCK_RES:
  214                 xdr_argument = (xdrproc_t) xdr_nlm_res;
  215                 xdr_result = (xdrproc_t) xdr_void;
  216                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_unlock_res_1_svc;
  217                 break;
  218 
  219         case NLM_GRANTED_RES:
  220                 xdr_argument = (xdrproc_t) xdr_nlm_res;
  221                 xdr_result = (xdrproc_t) xdr_void;
  222                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_granted_res_1_svc;
  223                 break;
  224 
  225         default:
  226                 svcerr_noproc(rqstp);
  227                 svc_freereq(rqstp);
  228                 return;
  229         }
  230         (void) memset((char *)&argument, 0, sizeof (argument));
  231         if (!svc_getargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
  232                 svcerr_decode(rqstp);
  233                 svc_freereq(rqstp);
  234                 return;
  235         }
  236         retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
  237         if (retval > 0 && !svc_sendreply(rqstp, xdr_result, (char *)&result)) {
  238                 svcerr_systemerr(rqstp);
  239         }
  240         if (!svc_freeargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
  241                 printf("unable to free arguments");
  242                 //exit(1);
  243         }
  244         svc_freereq(rqstp);
  245         if (!nlm_prog_1_freeresult(transp, xdr_result, (caddr_t) &result))
  246                 printf("unable to free results");
  247 
  248         return;
  249 }
  250 
  251 void
  252 nlm_prog_3(struct svc_req *rqstp, SVCXPRT *transp)
  253 {
  254         union {
  255                 nlm_shareargs nlm_share_3_arg;
  256                 nlm_shareargs nlm_unshare_3_arg;
  257                 nlm_lockargs nlm_nm_lock_3_arg;
  258                 nlm_notify nlm_free_all_3_arg;
  259         } argument;
  260         union {
  261                 nlm_shareres nlm_share_3_res;
  262                 nlm_shareres nlm_unshare_3_res;
  263                 nlm_res nlm_nm_lock_3_res;
  264         } result;
  265         bool_t retval;
  266         xdrproc_t xdr_argument, xdr_result;
  267         bool_t (*local)(char *, void *, struct svc_req *);
  268 
  269         switch (rqstp->rq_proc) {
  270         case NULLPROC:
  271                 (void) svc_sendreply(rqstp,
  272                         (xdrproc_t) xdr_void, (char *)NULL);
  273                 svc_freereq(rqstp);
  274                 return;
  275 
  276         case NLM_TEST:
  277         case NLM_LOCK:
  278         case NLM_CANCEL:
  279         case NLM_UNLOCK:
  280         case NLM_GRANTED:
  281         case NLM_TEST_MSG:
  282         case NLM_LOCK_MSG:
  283         case NLM_CANCEL_MSG:
  284         case NLM_UNLOCK_MSG:
  285         case NLM_GRANTED_MSG:
  286         case NLM_TEST_RES:
  287         case NLM_LOCK_RES:
  288         case NLM_CANCEL_RES:
  289         case NLM_UNLOCK_RES:
  290         case NLM_GRANTED_RES:
  291                 nlm_prog_1(rqstp, transp);
  292                 return;
  293 
  294         case NLM_SHARE:
  295                 xdr_argument = (xdrproc_t) xdr_nlm_shareargs;
  296                 xdr_result = (xdrproc_t) xdr_nlm_shareres;
  297                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_share_3_svc;
  298                 break;
  299 
  300         case NLM_UNSHARE:
  301                 xdr_argument = (xdrproc_t) xdr_nlm_shareargs;
  302                 xdr_result = (xdrproc_t) xdr_nlm_shareres;
  303                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_unshare_3_svc;
  304                 break;
  305 
  306         case NLM_NM_LOCK:
  307                 xdr_argument = (xdrproc_t) xdr_nlm_lockargs;
  308                 xdr_result = (xdrproc_t) xdr_nlm_res;
  309                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_nm_lock_3_svc;
  310                 break;
  311 
  312         case NLM_FREE_ALL:
  313                 xdr_argument = (xdrproc_t) xdr_nlm_notify;
  314                 xdr_result = (xdrproc_t) xdr_void;
  315                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm_free_all_3_svc;
  316                 break;
  317 
  318         default:
  319                 svcerr_noproc(rqstp);
  320                 svc_freereq(rqstp);
  321                 return;
  322         }
  323         (void) memset((char *)&argument, 0, sizeof (argument));
  324         if (!svc_getargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
  325                 svcerr_decode(rqstp);
  326                 svc_freereq(rqstp);
  327                 return;
  328         }
  329         retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
  330         if (retval > 0 && !svc_sendreply(rqstp, xdr_result, (char *)&result)) {
  331                 svcerr_systemerr(rqstp);
  332         }
  333         if (!svc_freeargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
  334                 printf("unable to free arguments");
  335                 //exit(1);
  336         }
  337         svc_freereq(rqstp);
  338         if (!nlm_prog_3_freeresult(transp, xdr_result, (caddr_t) &result))
  339                 printf("unable to free results");
  340 
  341         return;
  342 }
  343 
  344 void
  345 nlm_prog_4(struct svc_req *rqstp, SVCXPRT *transp)
  346 {
  347         union {
  348                 nlm4_testargs nlm4_test_4_arg;
  349                 nlm4_lockargs nlm4_lock_4_arg;
  350                 nlm4_cancargs nlm4_cancel_4_arg;
  351                 nlm4_unlockargs nlm4_unlock_4_arg;
  352                 nlm4_testargs nlm4_granted_4_arg;
  353                 nlm4_testargs nlm4_test_msg_4_arg;
  354                 nlm4_lockargs nlm4_lock_msg_4_arg;
  355                 nlm4_cancargs nlm4_cancel_msg_4_arg;
  356                 nlm4_unlockargs nlm4_unlock_msg_4_arg;
  357                 nlm4_testargs nlm4_granted_msg_4_arg;
  358                 nlm4_testres nlm4_test_res_4_arg;
  359                 nlm4_res nlm4_lock_res_4_arg;
  360                 nlm4_res nlm4_cancel_res_4_arg;
  361                 nlm4_res nlm4_unlock_res_4_arg;
  362                 nlm4_res nlm4_granted_res_4_arg;
  363                 nlm4_shareargs nlm4_share_4_arg;
  364                 nlm4_shareargs nlm4_unshare_4_arg;
  365                 nlm4_lockargs nlm4_nm_lock_4_arg;
  366                 nlm4_notify nlm4_free_all_4_arg;
  367         } argument;
  368         union {
  369                 nlm4_testres nlm4_test_4_res;
  370                 nlm4_res nlm4_lock_4_res;
  371                 nlm4_res nlm4_cancel_4_res;
  372                 nlm4_res nlm4_unlock_4_res;
  373                 nlm4_res nlm4_granted_4_res;
  374                 nlm4_shareres nlm4_share_4_res;
  375                 nlm4_shareres nlm4_unshare_4_res;
  376                 nlm4_res nlm4_nm_lock_4_res;
  377         } result;
  378         bool_t retval;
  379         xdrproc_t xdr_argument, xdr_result;
  380         bool_t (*local)(char *, void *, struct svc_req *);
  381 
  382         switch (rqstp->rq_proc) {
  383         case NULLPROC:
  384                 (void) svc_sendreply(rqstp,
  385                         (xdrproc_t) xdr_void, (char *)NULL);
  386                 svc_freereq(rqstp);
  387                 return;
  388 
  389         case NLM4_TEST:
  390                 xdr_argument = (xdrproc_t) xdr_nlm4_testargs;
  391                 xdr_result = (xdrproc_t) xdr_nlm4_testres;
  392                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_test_4_svc;
  393                 break;
  394 
  395         case NLM4_LOCK:
  396                 xdr_argument = (xdrproc_t) xdr_nlm4_lockargs;
  397                 xdr_result = (xdrproc_t) xdr_nlm4_res;
  398                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_lock_4_svc;
  399                 break;
  400 
  401         case NLM4_CANCEL:
  402                 xdr_argument = (xdrproc_t) xdr_nlm4_cancargs;
  403                 xdr_result = (xdrproc_t) xdr_nlm4_res;
  404                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_cancel_4_svc;
  405                 break;
  406 
  407         case NLM4_UNLOCK:
  408                 xdr_argument = (xdrproc_t) xdr_nlm4_unlockargs;
  409                 xdr_result = (xdrproc_t) xdr_nlm4_res;
  410                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_unlock_4_svc;
  411                 break;
  412 
  413         case NLM4_GRANTED:
  414                 xdr_argument = (xdrproc_t) xdr_nlm4_testargs;
  415                 xdr_result = (xdrproc_t) xdr_nlm4_res;
  416                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_granted_4_svc;
  417                 break;
  418 
  419         case NLM4_TEST_MSG:
  420                 xdr_argument = (xdrproc_t) xdr_nlm4_testargs;
  421                 xdr_result = (xdrproc_t) xdr_void;
  422                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_test_msg_4_svc;
  423                 break;
  424 
  425         case NLM4_LOCK_MSG:
  426                 xdr_argument = (xdrproc_t) xdr_nlm4_lockargs;
  427                 xdr_result = (xdrproc_t) xdr_void;
  428                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_lock_msg_4_svc;
  429                 break;
  430 
  431         case NLM4_CANCEL_MSG:
  432                 xdr_argument = (xdrproc_t) xdr_nlm4_cancargs;
  433                 xdr_result = (xdrproc_t) xdr_void;
  434                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_cancel_msg_4_svc;
  435                 break;
  436 
  437         case NLM4_UNLOCK_MSG:
  438                 xdr_argument = (xdrproc_t) xdr_nlm4_unlockargs;
  439                 xdr_result = (xdrproc_t) xdr_void;
  440                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_unlock_msg_4_svc;
  441                 break;
  442 
  443         case NLM4_GRANTED_MSG:
  444                 xdr_argument = (xdrproc_t) xdr_nlm4_testargs;
  445                 xdr_result = (xdrproc_t) xdr_void;
  446                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_granted_msg_4_svc;
  447                 break;
  448 
  449         case NLM4_TEST_RES:
  450                 xdr_argument = (xdrproc_t) xdr_nlm4_testres;
  451                 xdr_result = (xdrproc_t) xdr_void;
  452                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_test_res_4_svc;
  453                 break;
  454 
  455         case NLM4_LOCK_RES:
  456                 xdr_argument = (xdrproc_t) xdr_nlm4_res;
  457                 xdr_result = (xdrproc_t) xdr_void;
  458                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_lock_res_4_svc;
  459                 break;
  460 
  461         case NLM4_CANCEL_RES:
  462                 xdr_argument = (xdrproc_t) xdr_nlm4_res;
  463                 xdr_result = (xdrproc_t) xdr_void;
  464                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_cancel_res_4_svc;
  465                 break;
  466 
  467         case NLM4_UNLOCK_RES:
  468                 xdr_argument = (xdrproc_t) xdr_nlm4_res;
  469                 xdr_result = (xdrproc_t) xdr_void;
  470                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_unlock_res_4_svc;
  471                 break;
  472 
  473         case NLM4_GRANTED_RES:
  474                 xdr_argument = (xdrproc_t) xdr_nlm4_res;
  475                 xdr_result = (xdrproc_t) xdr_void;
  476                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_granted_res_4_svc;
  477                 break;
  478 
  479         case NLM4_SHARE:
  480                 xdr_argument = (xdrproc_t) xdr_nlm4_shareargs;
  481                 xdr_result = (xdrproc_t) xdr_nlm4_shareres;
  482                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_share_4_svc;
  483                 break;
  484 
  485         case NLM4_UNSHARE:
  486                 xdr_argument = (xdrproc_t) xdr_nlm4_shareargs;
  487                 xdr_result = (xdrproc_t) xdr_nlm4_shareres;
  488                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_unshare_4_svc;
  489                 break;
  490 
  491         case NLM4_NM_LOCK:
  492                 xdr_argument = (xdrproc_t) xdr_nlm4_lockargs;
  493                 xdr_result = (xdrproc_t) xdr_nlm4_res;
  494                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_nm_lock_4_svc;
  495                 break;
  496 
  497         case NLM4_FREE_ALL:
  498                 xdr_argument = (xdrproc_t) xdr_nlm4_notify;
  499                 xdr_result = (xdrproc_t) xdr_void;
  500                 local = (bool_t (*) (char *,  void *,  struct svc_req *))nlm4_free_all_4_svc;
  501                 break;
  502 
  503         default:
  504                 svcerr_noproc(rqstp);
  505                 svc_freereq(rqstp);
  506                 return;
  507         }
  508         (void) memset((char *)&argument, 0, sizeof (argument));
  509         if (!svc_getargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
  510                 svcerr_decode(rqstp);
  511                 svc_freereq(rqstp);
  512                 return;
  513         }
  514         retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
  515         if (retval > 0 && !svc_sendreply(rqstp, xdr_result, (char *)&result)) {
  516                 svcerr_systemerr(rqstp);
  517         }
  518         if (!svc_freeargs(rqstp, xdr_argument, (char *)(caddr_t) &argument)) {
  519                 printf("unable to free arguments");
  520                 //exit(1);
  521         }
  522         svc_freereq(rqstp);
  523         if (!nlm_prog_4_freeresult(transp, xdr_result, (caddr_t) &result))
  524                 printf("unable to free results");
  525 
  526         return;
  527 }

Cache object: 61c2fb431f7c210513211496fe89609f


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