sys/nlm/nlm_prot_server.c

   1 /*-
   2  * Copyright (c) 2008 Isilon Inc http://www.isilon.com/
   3  * Authors: Doug Rabson <dfr@rabson.org>
   4  * Developed with Red Inc: Alfred Perlstein <alfred@freebsd.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 #ifndef lint
  30 /*static char sccsid[] = "from: @(#)nlm_prot.x 1.8 87/09/21 Copyr 1987 Sun Micro";*/
  31 /*static char sccsid[] = "from: * @(#)nlm_prot.x        2.1 88/08/01 4.0 RPCSRC";*/
  32 __RCSID("$NetBSD: nlm_prot.x,v 1.6 2000/06/07 14:30:15 bouyer Exp $");
  33 #endif /* not lint */
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/malloc.h>
  38 #include <sys/systm.h>
  39
  40 #include <nlm/nlm_prot.h>
  41 #include <nlm/nlm.h>
  42
  43 /**********************************************************************/
  44
  45 /*
  46  * Convert between various versions of the protocol structures.
  47  */
  48
  49 static void
  50 nlm_convert_to_nlm4_lock(struct nlm4_lock *dst, struct nlm_lock *src)
  51 {
  52
  53         dst->caller_name = src->caller_name;
  54         dst->fh = src->fh;
  55         dst->oh = src->oh;
  56         dst->svid = src->svid;
  57         dst->l_offset = src->l_offset;
  58         dst->l_len = src->l_len;
  59 }
  60
  61 static void
  62 nlm_convert_to_nlm4_share(struct nlm4_share *dst, struct nlm_share *src)
  63 {
  64
  65         dst->caller_name = src->caller_name;
  66         dst->fh = src->fh;
  67         dst->oh = src->oh;
  68         dst->mode = src->mode;
  69         dst->access = src->access;
  70 }
  71
  72 static void
  73 nlm_convert_to_nlm_holder(struct nlm_holder *dst, struct nlm4_holder *src)
  74 {
  75
  76         dst->exclusive = src->exclusive;
  77         dst->svid = src->svid;
  78         dst->oh = src->oh;
  79         dst->l_offset = src->l_offset;
  80         dst->l_len = src->l_len;
  81 }
  82
  83 static void
  84 nlm_convert_to_nlm4_holder(struct nlm4_holder *dst, struct nlm_holder *src)
  85 {
  86
  87         dst->exclusive = src->exclusive;
  88         dst->svid = src->svid;
  89         dst->oh = src->oh;
  90         dst->l_offset = src->l_offset;
  91         dst->l_len = src->l_len;
  92 }
  93
  94 static enum nlm_stats
  95 nlm_convert_to_nlm_stats(enum nlm4_stats src)
  96 {
  97         if (src > nlm4_deadlck)
  98                 return nlm_denied;
  99         return (enum nlm_stats) src;
 100 }
 101
 102 static void
 103 nlm_convert_to_nlm_res(struct nlm_res *dst, struct nlm4_res *src)
 104 {
 105         dst->cookie = src->cookie;
 106         dst->stat.stat = nlm_convert_to_nlm_stats(src->stat.stat);
 107 }
 108
 109 static void
 110 nlm_convert_to_nlm4_res(struct nlm4_res *dst, struct nlm_res *src)
 111 {
 112         dst->cookie = src->cookie;
 113         dst->stat.stat = (enum nlm4_stats) src->stat.stat;
 114 }
 115
 116 /**********************************************************************/
 117
 118 /*
 119  * RPC server stubs.
 120  */
 121
 122 bool_t
 123 nlm_sm_notify_0_svc(struct nlm_sm_status *argp, void *result, struct svc_req *rqstp)
 124 {
 125         nlm_sm_notify(argp);
 126
 127         return (TRUE);
 128 }
 129
 130 bool_t
 131 nlm_test_1_svc(struct nlm_testargs *argp, nlm_testres *result, struct svc_req *rqstp)
 132 {
 133         bool_t retval;
 134         nlm4_testargs args4;
 135         nlm4_testres res4;
 136
 137         args4.cookie = argp->cookie;
 138         args4.exclusive = argp->exclusive;
 139         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 140
 141         retval = nlm4_test_4_svc(&args4, &res4, rqstp);
 142         if (retval) {
 143                 result->cookie = res4.cookie;
 144                 result->stat.stat = nlm_convert_to_nlm_stats(res4.stat.stat);
 145                 if (result->stat.stat == nlm_denied)
 146                         nlm_convert_to_nlm_holder(
 147                                 &result->stat.nlm_testrply_u.holder,
 148                                 &res4.stat.nlm4_testrply_u.holder);
 149         }
 150
 151         return (retval);
 152 }
 153
 154 bool_t
 155 nlm_lock_1_svc(struct nlm_lockargs *argp, nlm_res *result, struct svc_req *rqstp)
 156 {
 157         bool_t retval;
 158         nlm4_lockargs args4;
 159         nlm4_res res4;
 160
 161         args4.cookie = argp->cookie;
 162         args4.block = argp->block;
 163         args4.exclusive = argp->exclusive;
 164         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 165         args4.reclaim = argp->reclaim;
 166         args4.state = argp->state;
 167
 168         retval = nlm4_lock_4_svc(&args4, &res4, rqstp);
 169         if (retval)
 170                 nlm_convert_to_nlm_res(result, &res4);
 171
 172         return (retval);
 173 }
 174
 175 bool_t
 176 nlm_cancel_1_svc(struct nlm_cancargs *argp, nlm_res *result, struct svc_req *rqstp)
 177 {
 178         bool_t retval;
 179         nlm4_cancargs args4;
 180         nlm4_res res4;
 181
 182         args4.cookie = argp->cookie;
 183         args4.block = argp->block;
 184         args4.exclusive = argp->exclusive;
 185         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 186
 187         retval = nlm4_cancel_4_svc(&args4, &res4, rqstp);
 188         if (retval)
 189                 nlm_convert_to_nlm_res(result, &res4);
 190
 191         return (retval);
 192 }
 193
 194 bool_t
 195 nlm_unlock_1_svc(struct nlm_unlockargs *argp, nlm_res *result, struct svc_req *rqstp)
 196 {
 197         bool_t retval;
 198         nlm4_unlockargs args4;
 199         nlm4_res res4;
 200
 201         args4.cookie = argp->cookie;
 202         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 203
 204         retval = nlm4_unlock_4_svc(&args4, &res4, rqstp);
 205         if (retval)
 206                 nlm_convert_to_nlm_res(result, &res4);
 207
 208         return (retval);
 209 }
 210
 211 bool_t
 212 nlm_granted_1_svc(struct nlm_testargs *argp, nlm_res *result, struct svc_req *rqstp)
 213 {
 214         bool_t retval;
 215         nlm4_testargs args4;
 216         nlm4_res res4;
 217
 218         args4.cookie = argp->cookie;
 219         args4.exclusive = argp->exclusive;
 220         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 221
 222         retval = nlm4_granted_4_svc(&args4, &res4, rqstp);
 223         if (retval)
 224                 nlm_convert_to_nlm_res(result, &res4);
 225
 226         return (retval);
 227 }
 228
 229 bool_t
 230 nlm_test_msg_1_svc(struct nlm_testargs *argp, void *result, struct svc_req *rqstp)
 231 {
 232         nlm4_testargs args4;
 233         nlm4_testres res4;
 234         nlm_testres res;
 235         CLIENT *rpc;
 236         char dummy;
 237
 238         args4.cookie = argp->cookie;
 239         args4.exclusive = argp->exclusive;
 240         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 241
 242         if (nlm_do_test(&args4, &res4, rqstp, &rpc))
 243                 return (FALSE);
 244
 245         res.cookie = res4.cookie;
 246         res.stat.stat = nlm_convert_to_nlm_stats(res4.stat.stat);
 247         if (res.stat.stat == nlm_denied)
 248                 nlm_convert_to_nlm_holder(
 249                         &res.stat.nlm_testrply_u.holder,
 250                         &res4.stat.nlm4_testrply_u.holder);
 251
 252         if (rpc) {
 253                 nlm_test_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
 254                 CLNT_RELEASE(rpc);
 255         }
 256         xdr_free((xdrproc_t) xdr_nlm_testres, &res);
 257
 258         return (FALSE);
 259 }
 260
 261 bool_t
 262 nlm_lock_msg_1_svc(struct nlm_lockargs *argp, void *result, struct svc_req *rqstp)
 263 {
 264         nlm4_lockargs args4;
 265         nlm4_res res4;
 266         nlm_res res;
 267         CLIENT *rpc;
 268         char dummy;
 269
 270         args4.cookie = argp->cookie;
 271         args4.block = argp->block;
 272         args4.exclusive = argp->exclusive;
 273         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 274         args4.reclaim = argp->reclaim;
 275         args4.state = argp->state;
 276
 277         if (nlm_do_lock(&args4, &res4, rqstp, TRUE, &rpc))
 278                 return (FALSE);
 279
 280         nlm_convert_to_nlm_res(&res, &res4);
 281
 282         if (rpc) {
 283                 nlm_lock_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
 284                 CLNT_RELEASE(rpc);
 285         }
 286         xdr_free((xdrproc_t) xdr_nlm_res, &res);
 287
 288         return (FALSE);
 289 }
 290
 291 bool_t
 292 nlm_cancel_msg_1_svc(struct nlm_cancargs *argp, void *result, struct svc_req *rqstp)
 293 {
 294         nlm4_cancargs args4;
 295         nlm4_res res4;
 296         nlm_res res;
 297         CLIENT *rpc;
 298         char dummy;
 299
 300         args4.cookie = argp->cookie;
 301         args4.block = argp->block;
 302         args4.exclusive = argp->exclusive;
 303         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 304
 305         if (nlm_do_cancel(&args4, &res4, rqstp, &rpc))
 306                 return (FALSE);
 307
 308         nlm_convert_to_nlm_res(&res, &res4);
 309
 310         if (rpc) {
 311                 nlm_cancel_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
 312                 CLNT_RELEASE(rpc);
 313         }
 314         xdr_free((xdrproc_t) xdr_nlm_res, &res);
 315
 316         return (FALSE);
 317 }
 318
 319 bool_t
 320 nlm_unlock_msg_1_svc(struct nlm_unlockargs *argp, void *result, struct svc_req *rqstp)
 321 {
 322         nlm4_unlockargs args4;
 323         nlm4_res res4;
 324         nlm_res res;
 325         CLIENT *rpc;
 326         char dummy;
 327
 328         args4.cookie = argp->cookie;
 329         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 330
 331         if (nlm_do_unlock(&args4, &res4, rqstp, &rpc))
 332                 return (FALSE);
 333
 334         nlm_convert_to_nlm_res(&res, &res4);
 335
 336         if (rpc) {
 337                 nlm_unlock_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
 338                 CLNT_RELEASE(rpc);
 339         }
 340         xdr_free((xdrproc_t) xdr_nlm_res, &res);
 341
 342         return (FALSE);
 343 }
 344
 345 bool_t
 346 nlm_granted_msg_1_svc(struct nlm_testargs *argp, void *result, struct svc_req *rqstp)
 347 {
 348         nlm4_testargs args4;
 349         nlm4_res res4;
 350         nlm_res res;
 351         CLIENT *rpc;
 352         char dummy;
 353
 354         args4.cookie = argp->cookie;
 355         args4.exclusive = argp->exclusive;
 356         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 357
 358         if (nlm_do_granted(&args4, &res4, rqstp, &rpc))
 359                 return (FALSE);
 360
 361         nlm_convert_to_nlm_res(&res, &res4);
 362
 363         if (rpc) {
 364                 nlm_granted_res_1(&res, &dummy, rpc, NULL, nlm_zero_tv);
 365                 CLNT_RELEASE(rpc);
 366         }
 367         xdr_free((xdrproc_t) xdr_nlm_res, &res);
 368
 369         return (FALSE);
 370 }
 371
 372 bool_t
 373 nlm_test_res_1_svc(nlm_testres *argp, void *result, struct svc_req *rqstp)
 374 {
 375         nlm4_testres args4;
 376
 377         args4.cookie = argp->cookie;
 378         if (argp->stat.stat == nlm_denied)
 379                 nlm_convert_to_nlm4_holder(
 380                         &args4.stat.nlm4_testrply_u.holder,
 381                         &argp->stat.nlm_testrply_u.holder);
 382
 383         return (nlm4_test_res_4_svc(&args4, result, rqstp));
 384 }
 385
 386 bool_t
 387 nlm_lock_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
 388 {
 389         nlm4_res arg4;
 390
 391         nlm_convert_to_nlm4_res(&arg4, argp);
 392         return (nlm4_lock_res_4_svc(&arg4, result, rqstp));
 393 }
 394
 395 bool_t
 396 nlm_cancel_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
 397 {
 398         nlm4_res arg4;
 399
 400         nlm_convert_to_nlm4_res(&arg4, argp);
 401         return (nlm4_cancel_res_4_svc(&arg4, result, rqstp));
 402 }
 403
 404 bool_t
 405 nlm_unlock_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
 406 {
 407         nlm4_res arg4;
 408
 409         nlm_convert_to_nlm4_res(&arg4, argp);
 410         return (nlm4_unlock_res_4_svc(&arg4, result, rqstp));
 411 }
 412
 413 bool_t
 414 nlm_granted_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp)
 415 {
 416         nlm4_res arg4;
 417
 418         nlm_convert_to_nlm4_res(&arg4, argp);
 419         return (nlm4_granted_res_4_svc(&arg4, result, rqstp));
 420 }
 421
 422 int
 423 nlm_prog_1_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
 424 {
 425
 426         (void) xdr_free(xdr_result, result);
 427         return (TRUE);
 428 }
 429
 430 bool_t
 431 nlm_share_3_svc(nlm_shareargs *argp, nlm_shareres *result, struct svc_req *rqstp)
 432 {
 433         bool_t retval;
 434         nlm4_shareargs args4;
 435         nlm4_shareres res4;
 436
 437         args4.cookie = argp->cookie;
 438         nlm_convert_to_nlm4_share(&args4.share, &argp->share);
 439         args4.reclaim = argp->reclaim;
 440
 441         retval = nlm4_share_4_svc(&args4, &res4, rqstp);
 442         if (retval) {
 443                 result->cookie = res4.cookie;
 444                 result->stat = nlm_convert_to_nlm_stats(res4.stat);
 445                 result->sequence = res4.sequence;
 446         }
 447
 448         return (retval);
 449 }
 450
 451 bool_t
 452 nlm_unshare_3_svc(nlm_shareargs *argp, nlm_shareres *result, struct svc_req *rqstp)
 453 {
 454         bool_t retval;
 455         nlm4_shareargs args4;
 456         nlm4_shareres res4;
 457
 458         args4.cookie = argp->cookie;
 459         nlm_convert_to_nlm4_share(&args4.share, &argp->share);
 460         args4.reclaim = argp->reclaim;
 461
 462         retval = nlm4_unshare_4_svc(&args4, &res4, rqstp);
 463         if (retval) {
 464                 result->cookie = res4.cookie;
 465                 result->stat = nlm_convert_to_nlm_stats(res4.stat);
 466                 result->sequence = res4.sequence;
 467         }
 468
 469         return (retval);
 470 }
 471
 472 bool_t
 473 nlm_nm_lock_3_svc(nlm_lockargs *argp, nlm_res *result, struct svc_req *rqstp)
 474 {
 475         bool_t retval;
 476         nlm4_lockargs args4;
 477         nlm4_res res4;
 478
 479         args4.cookie = argp->cookie;
 480         args4.block = argp->block;
 481         args4.exclusive = argp->exclusive;
 482         nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock);
 483         args4.reclaim = argp->reclaim;
 484         args4.state = argp->state;
 485
 486         retval = nlm4_nm_lock_4_svc(&args4, &res4, rqstp);
 487         if (retval)
 488                 nlm_convert_to_nlm_res(result, &res4);
 489
 490         return (retval);
 491 }
 492
 493 bool_t
 494 nlm_free_all_3_svc(nlm_notify *argp, void *result, struct svc_req *rqstp)
 495 {
 496         struct nlm4_notify args4;
 497
 498         args4.name = argp->name;
 499         args4.state = argp->state;
 500
 501         return (nlm4_free_all_4_svc(&args4, result, rqstp));
 502 }
 503
 504 int
 505 nlm_prog_3_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
 506 {
 507
 508         (void) xdr_free(xdr_result, result);
 509         return (TRUE);
 510 }
 511
 512 bool_t
 513 nlm4_test_4_svc(nlm4_testargs *argp, nlm4_testres *result, struct svc_req *rqstp)
 514 {
 515
 516         nlm_do_test(argp, result, rqstp, NULL);
 517         return (TRUE);
 518 }
 519
 520 bool_t
 521 nlm4_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp)
 522 {
 523
 524         nlm_do_lock(argp, result, rqstp, TRUE, NULL);
 525         return (TRUE);
 526 }
 527
 528 bool_t
 529 nlm4_cancel_4_svc(nlm4_cancargs *argp, nlm4_res *result, struct svc_req *rqstp)
 530 {
 531
 532         nlm_do_cancel(argp, result, rqstp, NULL);
 533         return (TRUE);
 534 }
 535
 536 bool_t
 537 nlm4_unlock_4_svc(nlm4_unlockargs *argp, nlm4_res *result, struct svc_req *rqstp)
 538 {
 539
 540         nlm_do_unlock(argp, result, rqstp, NULL);
 541         return (TRUE);
 542 }
 543
 544 bool_t
 545 nlm4_granted_4_svc(nlm4_testargs *argp, nlm4_res *result, struct svc_req *rqstp)
 546 {
 547
 548         nlm_do_granted(argp, result, rqstp, NULL);
 549         return (TRUE);
 550 }
 551
 552 bool_t
 553 nlm4_test_msg_4_svc(nlm4_testargs *argp, void *result, struct svc_req *rqstp)
 554 {
 555         nlm4_testres res4;
 556         CLIENT *rpc;
 557         char dummy;
 558
 559         if (nlm_do_test(argp, &res4, rqstp, &rpc))
 560                 return (FALSE);
 561         if (rpc) {
 562                 nlm4_test_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
 563                 CLNT_RELEASE(rpc);
 564         }
 565         xdr_free((xdrproc_t) xdr_nlm4_testres, &res4);
 566
 567         return (FALSE);
 568 }
 569
 570 bool_t
 571 nlm4_lock_msg_4_svc(nlm4_lockargs *argp, void *result, struct svc_req *rqstp)
 572 {
 573         nlm4_res res4;
 574         CLIENT *rpc;
 575         char dummy;
 576
 577         if (nlm_do_lock(argp, &res4, rqstp, TRUE, &rpc))
 578                 return (FALSE);
 579         if (rpc) {
 580                 nlm4_lock_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
 581                 CLNT_RELEASE(rpc);
 582         }
 583         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
 584
 585         return (FALSE);
 586 }
 587
 588 bool_t
 589 nlm4_cancel_msg_4_svc(nlm4_cancargs *argp, void *result, struct svc_req *rqstp)
 590 {
 591         nlm4_res res4;
 592         CLIENT *rpc;
 593         char dummy;
 594
 595         if (nlm_do_cancel(argp, &res4, rqstp, &rpc))
 596                 return (FALSE);
 597         if (rpc) {
 598                 nlm4_cancel_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
 599                 CLNT_RELEASE(rpc);
 600         }
 601         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
 602
 603         return (FALSE);
 604 }
 605
 606 bool_t
 607 nlm4_unlock_msg_4_svc(nlm4_unlockargs *argp, void *result, struct svc_req *rqstp)
 608 {
 609         nlm4_res res4;
 610         CLIENT *rpc;
 611         char dummy;
 612
 613         if (nlm_do_unlock(argp, &res4, rqstp, &rpc))
 614                 return (FALSE);
 615         if (rpc) {
 616                 nlm4_unlock_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
 617                 CLNT_RELEASE(rpc);
 618         }
 619         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
 620
 621         return (FALSE);
 622 }
 623
 624 bool_t
 625 nlm4_granted_msg_4_svc(nlm4_testargs *argp, void *result, struct svc_req *rqstp)
 626 {
 627         nlm4_res res4;
 628         CLIENT *rpc;
 629         char dummy;
 630
 631         if (nlm_do_granted(argp, &res4, rqstp, &rpc))
 632                 return (FALSE);
 633         if (rpc) {
 634                 nlm4_granted_res_4(&res4, &dummy, rpc, NULL, nlm_zero_tv);
 635                 CLNT_RELEASE(rpc);
 636         }
 637         xdr_free((xdrproc_t) xdr_nlm4_res, &res4);
 638
 639         return (FALSE);
 640 }
 641
 642 bool_t
 643 nlm4_test_res_4_svc(nlm4_testres *argp, void *result, struct svc_req *rqstp)
 644 {
 645
 646         return (FALSE);
 647 }
 648
 649 bool_t
 650 nlm4_lock_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
 651 {
 652
 653         return (FALSE);
 654 }
 655
 656 bool_t
 657 nlm4_cancel_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
 658 {
 659
 660         return (FALSE);
 661 }
 662
 663 bool_t
 664 nlm4_unlock_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
 665 {
 666
 667         return (FALSE);
 668 }
 669
 670 bool_t
 671 nlm4_granted_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp)
 672 {
 673
 674         return (FALSE);
 675 }
 676
 677 bool_t
 678 nlm4_share_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp)
 679 {
 680
 681         memset(result, 0, sizeof(*result));
 682         result->stat = nlm4_denied;
 683         return (TRUE);
 684 }
 685
 686 bool_t
 687 nlm4_unshare_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp)
 688 {
 689
 690         memset(result, 0, sizeof(*result));
 691         result->stat = nlm4_denied;
 692         return (TRUE);
 693 }
 694
 695 bool_t
 696 nlm4_nm_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp)
 697 {
 698
 699         nlm_do_lock(argp, result, rqstp, FALSE, NULL);
 700         return (TRUE);
 701 }
 702
 703 bool_t
 704 nlm4_free_all_4_svc(nlm4_notify *argp, void *result, struct svc_req *rqstp)
 705 {
 706
 707         nlm_do_free_all(argp);
 708         return (TRUE);
 709 }
 710
 711 int
 712 nlm_prog_4_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
 713 {
 714
 715         (void) xdr_free(xdr_result, result);
 716         return (TRUE);
 717 }