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