nlm_prot_server.c revision 177633
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: head/sys/nlm/nlm_prot_server.c 177633 2008-03-26 15:23:12Z dfr $"); 35 36#include <sys/param.h> 37#include <sys/malloc.h> 38#include <sys/systm.h> 39 40#include "nlm_prot.h" 41#include "nlm.h" 42 43/**********************************************************************/ 44 45/* 46 * Convert between various versions of the protocol structures. 47 */ 48 49static void 50nlm_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 61static void 62nlm_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 72static void 73nlm_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 83static void 84nlm_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 94static enum nlm_stats 95nlm_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 102static void 103nlm_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 109static void 110nlm_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 122bool_t 123nlm_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 130bool_t 131nlm_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 154bool_t 155nlm_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 175bool_t 176nlm_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 194bool_t 195nlm_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 211bool_t 212nlm_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 229bool_t 230nlm_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 struct nlm_host *host; 236 CLIENT *rpc; 237 char dummy; 238 239 args4.cookie = argp->cookie; 240 args4.exclusive = argp->exclusive; 241 nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock); 242 243 host = nlm_do_test(&args4, &res4, rqstp); 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 rpc = nlm_host_get_rpc(host); 253 if (rpc) 254 nlm_test_res_1(&res, &dummy, rpc); 255 xdr_free((xdrproc_t) xdr_nlm_testres, &res); 256 257 return (FALSE); 258} 259 260bool_t 261nlm_lock_msg_1_svc(struct nlm_lockargs *argp, void *result, struct svc_req *rqstp) 262{ 263 nlm4_lockargs args4; 264 nlm4_res res4; 265 nlm_res res; 266 struct nlm_host *host; 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 host = nlm_do_lock(&args4, &res4, rqstp, TRUE); 278 279 nlm_convert_to_nlm_res(&res, &res4); 280 281 rpc = nlm_host_get_rpc(host); 282 if (rpc) 283 nlm_lock_res_1(&res, &dummy, rpc); 284 xdr_free((xdrproc_t) xdr_nlm_res, &res); 285 286 return (FALSE); 287} 288 289bool_t 290nlm_cancel_msg_1_svc(struct nlm_cancargs *argp, void *result, struct svc_req *rqstp) 291{ 292 nlm4_cancargs args4; 293 nlm4_res res4; 294 nlm_res res; 295 struct nlm_host *host; 296 CLIENT *rpc; 297 char dummy; 298 299 args4.cookie = argp->cookie; 300 args4.block = argp->block; 301 args4.exclusive = argp->exclusive; 302 nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock); 303 304 host = nlm_do_cancel(&args4, &res4, rqstp); 305 306 nlm_convert_to_nlm_res(&res, &res4); 307 308 rpc = nlm_host_get_rpc(host); 309 if (rpc) 310 nlm_cancel_res_1(&res, &dummy, rpc); 311 xdr_free((xdrproc_t) xdr_nlm_res, &res); 312 313 return (FALSE); 314} 315 316bool_t 317nlm_unlock_msg_1_svc(struct nlm_unlockargs *argp, void *result, struct svc_req *rqstp) 318{ 319 nlm4_unlockargs args4; 320 nlm4_res res4; 321 nlm_res res; 322 struct nlm_host *host; 323 CLIENT *rpc; 324 char dummy; 325 326 args4.cookie = argp->cookie; 327 nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock); 328 329 host = nlm_do_unlock(&args4, &res4, rqstp); 330 331 nlm_convert_to_nlm_res(&res, &res4); 332 333 rpc = nlm_host_get_rpc(host); 334 if (rpc) 335 nlm_unlock_res_1(&res, &dummy, rpc); 336 xdr_free((xdrproc_t) xdr_nlm_res, &res); 337 338 return (FALSE); 339} 340 341bool_t 342nlm_granted_msg_1_svc(struct nlm_testargs *argp, void *result, struct svc_req *rqstp) 343{ 344 nlm4_testargs args4; 345 nlm4_res res4; 346 nlm_res res; 347 struct nlm_host *host; 348 CLIENT *rpc; 349 char dummy; 350 351 args4.cookie = argp->cookie; 352 args4.exclusive = argp->exclusive; 353 nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock); 354 355 /* 356 * We make a synchronous call to userland and send the reply 357 * back async. 358 */ 359 nlm4_granted_4_svc(&args4, &res4, rqstp); 360 361 nlm_convert_to_nlm_res(&res, &res4); 362 363 host = nlm_find_host_by_addr( 364 (struct sockaddr *) rqstp->rq_xprt->xp_rtaddr.buf, 365 rqstp->rq_vers); 366 rpc = nlm_host_get_rpc(host); 367 if (rpc) 368 nlm_granted_res_1(&res, &dummy, rpc); 369 xdr_free((xdrproc_t) xdr_nlm_res, &res); 370 371 return (FALSE); 372} 373 374bool_t 375nlm_test_res_1_svc(nlm_testres *argp, void *result, struct svc_req *rqstp) 376{ 377 nlm4_testres args4; 378 379 args4.cookie = argp->cookie; 380 if (argp->stat.stat == nlm_denied) 381 nlm_convert_to_nlm4_holder( 382 &args4.stat.nlm4_testrply_u.holder, 383 &argp->stat.nlm_testrply_u.holder); 384 385 return (nlm4_test_res_4_svc(&args4, result, rqstp)); 386} 387 388bool_t 389nlm_lock_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp) 390{ 391 nlm4_res arg4; 392 393 nlm_convert_to_nlm4_res(&arg4, argp); 394 return (nlm4_lock_res_4_svc(&arg4, result, rqstp)); 395} 396 397bool_t 398nlm_cancel_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp) 399{ 400 nlm4_res arg4; 401 402 nlm_convert_to_nlm4_res(&arg4, argp); 403 return (nlm4_cancel_res_4_svc(&arg4, result, rqstp)); 404} 405 406bool_t 407nlm_unlock_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp) 408{ 409 nlm4_res arg4; 410 411 nlm_convert_to_nlm4_res(&arg4, argp); 412 return (nlm4_unlock_res_4_svc(&arg4, result, rqstp)); 413} 414 415bool_t 416nlm_granted_res_1_svc(nlm_res *argp, void *result, struct svc_req *rqstp) 417{ 418 nlm4_res arg4; 419 420 nlm_convert_to_nlm4_res(&arg4, argp); 421 return (nlm4_granted_res_4_svc(&arg4, result, rqstp)); 422} 423 424int 425nlm_prog_1_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) 426{ 427 428 (void) xdr_free(xdr_result, result); 429 return (TRUE); 430} 431 432bool_t 433nlm_share_3_svc(nlm_shareargs *argp, nlm_shareres *result, struct svc_req *rqstp) 434{ 435 bool_t retval; 436 nlm4_shareargs args4; 437 nlm4_shareres res4; 438 439 args4.cookie = argp->cookie; 440 nlm_convert_to_nlm4_share(&args4.share, &argp->share); 441 args4.reclaim = argp->reclaim; 442 443 retval = nlm4_share_4_svc(&args4, &res4, rqstp); 444 if (retval) { 445 result->cookie = res4.cookie; 446 result->stat = nlm_convert_to_nlm_stats(res4.stat); 447 result->sequence = res4.sequence; 448 } 449 450 return (retval); 451} 452 453bool_t 454nlm_unshare_3_svc(nlm_shareargs *argp, nlm_shareres *result, struct svc_req *rqstp) 455{ 456 bool_t retval; 457 nlm4_shareargs args4; 458 nlm4_shareres res4; 459 460 args4.cookie = argp->cookie; 461 nlm_convert_to_nlm4_share(&args4.share, &argp->share); 462 args4.reclaim = argp->reclaim; 463 464 retval = nlm4_unshare_4_svc(&args4, &res4, rqstp); 465 if (retval) { 466 result->cookie = res4.cookie; 467 result->stat = nlm_convert_to_nlm_stats(res4.stat); 468 result->sequence = res4.sequence; 469 } 470 471 return (retval); 472} 473 474bool_t 475nlm_nm_lock_3_svc(nlm_lockargs *argp, nlm_res *result, struct svc_req *rqstp) 476{ 477 bool_t retval; 478 nlm4_lockargs args4; 479 nlm4_res res4; 480 481 args4.cookie = argp->cookie; 482 args4.block = argp->block; 483 args4.exclusive = argp->exclusive; 484 nlm_convert_to_nlm4_lock(&args4.alock, &argp->alock); 485 args4.reclaim = argp->reclaim; 486 args4.state = argp->state; 487 488 retval = nlm4_nm_lock_4_svc(&args4, &res4, rqstp); 489 if (retval) 490 nlm_convert_to_nlm_res(result, &res4); 491 492 return (retval); 493} 494 495bool_t 496nlm_free_all_3_svc(nlm_notify *argp, void *result, struct svc_req *rqstp) 497{ 498 struct nlm4_notify args4; 499 500 args4.name = argp->name; 501 args4.state = argp->state; 502 503 return (nlm4_free_all_4_svc(&args4, result, rqstp)); 504} 505 506int 507nlm_prog_3_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) 508{ 509 510 (void) xdr_free(xdr_result, result); 511 return (TRUE); 512} 513 514bool_t 515nlm4_test_4_svc(nlm4_testargs *argp, nlm4_testres *result, struct svc_req *rqstp) 516{ 517 518 nlm_do_test(argp, result, rqstp); 519 return (TRUE); 520} 521 522bool_t 523nlm4_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp) 524{ 525 526 nlm_do_lock(argp, result, rqstp, TRUE); 527 return (TRUE); 528} 529 530bool_t 531nlm4_cancel_4_svc(nlm4_cancargs *argp, nlm4_res *result, struct svc_req *rqstp) 532{ 533 534 nlm_do_cancel(argp, result, rqstp); 535 return (TRUE); 536} 537 538bool_t 539nlm4_unlock_4_svc(nlm4_unlockargs *argp, nlm4_res *result, struct svc_req *rqstp) 540{ 541 542 nlm_do_unlock(argp, result, rqstp); 543 return (TRUE); 544} 545 546bool_t 547nlm4_granted_4_svc(nlm4_testargs *argp, nlm4_res *result, struct svc_req *rqstp) 548{ 549 CLIENT* lockd; 550 struct timeval tv; 551 552 memset(result, 0, sizeof(*result)); 553 nlm_copy_netobj(&result->cookie, &argp->cookie, M_RPC); 554 555 /* 556 * Set a non-zero timeout to give the userland a chance to reply. 557 */ 558 lockd = nlm_user_lockd(); 559 if (!lockd) { 560 result->stat.stat = nlm4_failed; 561 return (TRUE); 562 } 563 tv.tv_sec = 20; 564 tv.tv_usec = 0; 565 CLNT_CONTROL(lockd, CLSET_TIMEOUT, &tv); 566 nlm4_granted_4(argp, result, lockd); 567 tv.tv_sec = 0; 568 tv.tv_usec = 0; 569 CLNT_CONTROL(lockd, CLSET_TIMEOUT, &tv); 570 571 return (TRUE); 572} 573 574bool_t 575nlm4_test_msg_4_svc(nlm4_testargs *argp, void *result, struct svc_req *rqstp) 576{ 577 nlm4_testres res4; 578 struct nlm_host *host; 579 CLIENT *rpc; 580 char dummy; 581 582 host = nlm_do_test(argp, &res4, rqstp); 583 rpc = nlm_host_get_rpc(host); 584 if (rpc) 585 nlm4_test_res_4(&res4, &dummy, rpc); 586 xdr_free((xdrproc_t) xdr_nlm4_testres, &res4); 587 588 return (FALSE); 589} 590 591bool_t 592nlm4_lock_msg_4_svc(nlm4_lockargs *argp, void *result, struct svc_req *rqstp) 593{ 594 nlm4_res res4; 595 struct nlm_host *host; 596 CLIENT *rpc; 597 char dummy; 598 599 host = nlm_do_lock(argp, &res4, rqstp, TRUE); 600 rpc = nlm_host_get_rpc(host); 601 if (rpc) 602 nlm4_lock_res_4(&res4, &dummy, rpc); 603 xdr_free((xdrproc_t) xdr_nlm4_res, &res4); 604 605 return (FALSE); 606} 607 608bool_t 609nlm4_cancel_msg_4_svc(nlm4_cancargs *argp, void *result, struct svc_req *rqstp) 610{ 611 nlm4_res res4; 612 struct nlm_host *host; 613 CLIENT *rpc; 614 char dummy; 615 616 host = nlm_do_cancel(argp, &res4, rqstp); 617 rpc = nlm_host_get_rpc(host); 618 if (rpc) 619 nlm4_cancel_res_4(&res4, &dummy, rpc); 620 xdr_free((xdrproc_t) xdr_nlm4_res, &res4); 621 622 return (FALSE); 623} 624 625bool_t 626nlm4_unlock_msg_4_svc(nlm4_unlockargs *argp, void *result, struct svc_req *rqstp) 627{ 628 nlm4_res res4; 629 struct nlm_host *host; 630 CLIENT *rpc; 631 char dummy; 632 633 host = nlm_do_unlock(argp, &res4, rqstp); 634 rpc = nlm_host_get_rpc(host); 635 if (rpc) 636 nlm4_unlock_res_4(&res4, &dummy, rpc); 637 xdr_free((xdrproc_t) xdr_nlm4_res, &res4); 638 639 return (FALSE); 640} 641 642bool_t 643nlm4_granted_msg_4_svc(nlm4_testargs *argp, void *result, struct svc_req *rqstp) 644{ 645 struct nlm_host *host; 646 CLIENT *rpc; 647 nlm4_res res4; 648 char dummy; 649 650 /* 651 * We make a synchronous call to userland and send the reply 652 * back async. 653 */ 654 nlm4_granted_4_svc(argp, &res4, rqstp); 655 656 host = nlm_find_host_by_addr( 657 (struct sockaddr *) rqstp->rq_xprt->xp_rtaddr.buf, 658 rqstp->rq_vers); 659 rpc = nlm_host_get_rpc(host); 660 if (rpc) 661 nlm4_granted_res_4(&res4, &dummy, rpc); 662 xdr_free((xdrproc_t) xdr_nlm4_res, &res4); 663 664 return (FALSE); 665} 666 667bool_t 668nlm4_test_res_4_svc(nlm4_testres *argp, void *result, struct svc_req *rqstp) 669{ 670 CLIENT* lockd; 671 672 lockd = nlm_user_lockd(); 673 if (lockd) 674 nlm4_test_res_4(argp, result, lockd); 675 676 return (FALSE); 677} 678 679bool_t 680nlm4_lock_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp) 681{ 682 CLIENT* lockd; 683 684 lockd = nlm_user_lockd(); 685 if (lockd) 686 nlm4_lock_res_4(argp, result, lockd); 687 688 return (FALSE); 689} 690 691bool_t 692nlm4_cancel_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp) 693{ 694 CLIENT* lockd; 695 696 lockd = nlm_user_lockd(); 697 if (lockd) 698 nlm4_cancel_res_4(argp, result, lockd); 699 700 return (FALSE); 701} 702 703bool_t 704nlm4_unlock_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp) 705{ 706 CLIENT* lockd; 707 708 lockd = nlm_user_lockd(); 709 if (lockd) 710 nlm4_unlock_res_4(argp, result, lockd); 711 712 return (FALSE); 713} 714 715bool_t 716nlm4_granted_res_4_svc(nlm4_res *argp, void *result, struct svc_req *rqstp) 717{ 718 719 return (FALSE); 720} 721 722bool_t 723nlm4_share_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp) 724{ 725 726 memset(result, 0, sizeof(*result)); 727 result->stat = nlm4_denied; 728 return (TRUE); 729} 730 731bool_t 732nlm4_unshare_4_svc(nlm4_shareargs *argp, nlm4_shareres *result, struct svc_req *rqstp) 733{ 734 735 memset(result, 0, sizeof(*result)); 736 result->stat = nlm4_denied; 737 return (TRUE); 738} 739 740bool_t 741nlm4_nm_lock_4_svc(nlm4_lockargs *argp, nlm4_res *result, struct svc_req *rqstp) 742{ 743 744 nlm_do_lock(argp, result, rqstp, FALSE); 745 return (TRUE); 746} 747 748bool_t 749nlm4_free_all_4_svc(nlm4_notify *argp, void *result, struct svc_req *rqstp) 750{ 751 752 nlm_do_free_all(argp); 753 return (TRUE); 754} 755 756int 757nlm_prog_4_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) 758{ 759 760 (void) xdr_free(xdr_result, result); 761 return (TRUE); 762} 763