xref: /kernel/linux/linux-5.10/fs/lockd/xdr4.c (revision 8c2ecf20) 
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * linux/fs/lockd/xdr4.c
4 *
5 * XDR support for lockd and the lock client.
6 *
7 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
8 * Copyright (C) 1999, Trond Myklebust <trond.myklebust@fys.uio.no>
9 */
10
11#include <linux/types.h>
12#include <linux/sched.h>
13#include <linux/nfs.h>
14
15#include <linux/sunrpc/xdr.h>
16#include <linux/sunrpc/clnt.h>
17#include <linux/sunrpc/svc.h>
18#include <linux/sunrpc/stats.h>
19#include <linux/lockd/lockd.h>
20
21#define NLMDBG_FACILITY		NLMDBG_XDR
22
23static inline loff_t
24s64_to_loff_t(__s64 offset)
25{
26	return (loff_t)offset;
27}
28
29
30static inline s64
31loff_t_to_s64(loff_t offset)
32{
33	s64 res;
34	if (offset > NLM4_OFFSET_MAX)
35		res = NLM4_OFFSET_MAX;
36	else if (offset < -NLM4_OFFSET_MAX)
37		res = -NLM4_OFFSET_MAX;
38	else
39		res = offset;
40	return res;
41}
42
43/*
44 * XDR functions for basic NLM types
45 */
46static __be32 *
47nlm4_decode_cookie(__be32 *p, struct nlm_cookie *c)
48{
49	unsigned int	len;
50
51	len = ntohl(*p++);
52
53	if(len==0)
54	{
55		c->len=4;
56		memset(c->data, 0, 4);	/* hockeypux brain damage */
57	}
58	else if(len<=NLM_MAXCOOKIELEN)
59	{
60		c->len=len;
61		memcpy(c->data, p, len);
62		p+=XDR_QUADLEN(len);
63	}
64	else
65	{
66		dprintk("lockd: bad cookie size %d (only cookies under "
67			"%d bytes are supported.)\n",
68				len, NLM_MAXCOOKIELEN);
69		return NULL;
70	}
71	return p;
72}
73
74static __be32 *
75nlm4_encode_cookie(__be32 *p, struct nlm_cookie *c)
76{
77	*p++ = htonl(c->len);
78	memcpy(p, c->data, c->len);
79	p+=XDR_QUADLEN(c->len);
80	return p;
81}
82
83static __be32 *
84nlm4_decode_fh(__be32 *p, struct nfs_fh *f)
85{
86	memset(f->data, 0, sizeof(f->data));
87	f->size = ntohl(*p++);
88	if (f->size > NFS_MAXFHSIZE) {
89		dprintk("lockd: bad fhandle size %d (should be <=%d)\n",
90			f->size, NFS_MAXFHSIZE);
91		return NULL;
92	}
93      	memcpy(f->data, p, f->size);
94	return p + XDR_QUADLEN(f->size);
95}
96
97/*
98 * Encode and decode owner handle
99 */
100static __be32 *
101nlm4_decode_oh(__be32 *p, struct xdr_netobj *oh)
102{
103	return xdr_decode_netobj(p, oh);
104}
105
106static __be32 *
107nlm4_decode_lock(__be32 *p, struct nlm_lock *lock)
108{
109	struct file_lock	*fl = &lock->fl;
110	__u64			len, start;
111	__s64			end;
112
113	if (!(p = xdr_decode_string_inplace(p, &lock->caller,
114					    &lock->len, NLM_MAXSTRLEN))
115	 || !(p = nlm4_decode_fh(p, &lock->fh))
116	 || !(p = nlm4_decode_oh(p, &lock->oh)))
117		return NULL;
118	lock->svid  = ntohl(*p++);
119
120	locks_init_lock(fl);
121	fl->fl_flags = FL_POSIX;
122	fl->fl_type  = F_RDLCK;		/* as good as anything else */
123	p = xdr_decode_hyper(p, &start);
124	p = xdr_decode_hyper(p, &len);
125	end = start + len - 1;
126
127	fl->fl_start = s64_to_loff_t(start);
128
129	if (len == 0 || end < 0)
130		fl->fl_end = OFFSET_MAX;
131	else
132		fl->fl_end = s64_to_loff_t(end);
133	return p;
134}
135
136/*
137 * Encode result of a TEST/TEST_MSG call
138 */
139static __be32 *
140nlm4_encode_testres(__be32 *p, struct nlm_res *resp)
141{
142	s64		start, len;
143
144	dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp);
145	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
146		return NULL;
147	*p++ = resp->status;
148
149	if (resp->status == nlm_lck_denied) {
150		struct file_lock	*fl = &resp->lock.fl;
151
152		*p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;
153		*p++ = htonl(resp->lock.svid);
154
155		/* Encode owner handle. */
156		if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
157			return NULL;
158
159		start = loff_t_to_s64(fl->fl_start);
160		if (fl->fl_end == OFFSET_MAX)
161			len = 0;
162		else
163			len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
164
165		p = xdr_encode_hyper(p, start);
166		p = xdr_encode_hyper(p, len);
167		dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n",
168			resp->status, (int)resp->lock.svid, fl->fl_type,
169			(long long)fl->fl_start,  (long long)fl->fl_end);
170	}
171
172	dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp);
173	return p;
174}
175
176
177/*
178 * First, the server side XDR functions
179 */
180int
181nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p)
182{
183	struct nlm_args *argp = rqstp->rq_argp;
184	u32	exclusive;
185
186	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
187		return 0;
188
189	exclusive = ntohl(*p++);
190	if (!(p = nlm4_decode_lock(p, &argp->lock)))
191		return 0;
192	if (exclusive)
193		argp->lock.fl.fl_type = F_WRLCK;
194
195	return xdr_argsize_check(rqstp, p);
196}
197
198int
199nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p)
200{
201	struct nlm_res *resp = rqstp->rq_resp;
202
203	if (!(p = nlm4_encode_testres(p, resp)))
204		return 0;
205	return xdr_ressize_check(rqstp, p);
206}
207
208int
209nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p)
210{
211	struct nlm_args *argp = rqstp->rq_argp;
212	u32	exclusive;
213
214	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
215		return 0;
216	argp->block  = ntohl(*p++);
217	exclusive    = ntohl(*p++);
218	if (!(p = nlm4_decode_lock(p, &argp->lock)))
219		return 0;
220	if (exclusive)
221		argp->lock.fl.fl_type = F_WRLCK;
222	argp->reclaim = ntohl(*p++);
223	argp->state   = ntohl(*p++);
224	argp->monitor = 1;		/* monitor client by default */
225
226	return xdr_argsize_check(rqstp, p);
227}
228
229int
230nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p)
231{
232	struct nlm_args *argp = rqstp->rq_argp;
233	u32	exclusive;
234
235	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
236		return 0;
237	argp->block = ntohl(*p++);
238	exclusive = ntohl(*p++);
239	if (!(p = nlm4_decode_lock(p, &argp->lock)))
240		return 0;
241	if (exclusive)
242		argp->lock.fl.fl_type = F_WRLCK;
243	return xdr_argsize_check(rqstp, p);
244}
245
246int
247nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p)
248{
249	struct nlm_args *argp = rqstp->rq_argp;
250
251	if (!(p = nlm4_decode_cookie(p, &argp->cookie))
252	 || !(p = nlm4_decode_lock(p, &argp->lock)))
253		return 0;
254	argp->lock.fl.fl_type = F_UNLCK;
255	return xdr_argsize_check(rqstp, p);
256}
257
258int
259nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p)
260{
261	struct nlm_args *argp = rqstp->rq_argp;
262	struct nlm_lock	*lock = &argp->lock;
263
264	memset(lock, 0, sizeof(*lock));
265	locks_init_lock(&lock->fl);
266	lock->svid = ~(u32) 0;
267
268	if (!(p = nlm4_decode_cookie(p, &argp->cookie))
269	 || !(p = xdr_decode_string_inplace(p, &lock->caller,
270					    &lock->len, NLM_MAXSTRLEN))
271	 || !(p = nlm4_decode_fh(p, &lock->fh))
272	 || !(p = nlm4_decode_oh(p, &lock->oh)))
273		return 0;
274	argp->fsm_mode = ntohl(*p++);
275	argp->fsm_access = ntohl(*p++);
276	return xdr_argsize_check(rqstp, p);
277}
278
279int
280nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p)
281{
282	struct nlm_res *resp = rqstp->rq_resp;
283
284	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
285		return 0;
286	*p++ = resp->status;
287	*p++ = xdr_zero;		/* sequence argument */
288	return xdr_ressize_check(rqstp, p);
289}
290
291int
292nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p)
293{
294	struct nlm_res *resp = rqstp->rq_resp;
295
296	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
297		return 0;
298	*p++ = resp->status;
299	return xdr_ressize_check(rqstp, p);
300}
301
302int
303nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p)
304{
305	struct nlm_args *argp = rqstp->rq_argp;
306	struct nlm_lock	*lock = &argp->lock;
307
308	if (!(p = xdr_decode_string_inplace(p, &lock->caller,
309					    &lock->len, NLM_MAXSTRLEN)))
310		return 0;
311	argp->state = ntohl(*p++);
312	return xdr_argsize_check(rqstp, p);
313}
314
315int
316nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p)
317{
318	struct nlm_reboot *argp = rqstp->rq_argp;
319
320	if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
321		return 0;
322	argp->state = ntohl(*p++);
323	memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
324	p += XDR_QUADLEN(SM_PRIV_SIZE);
325	return xdr_argsize_check(rqstp, p);
326}
327
328int
329nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p)
330{
331	struct nlm_res *resp = rqstp->rq_argp;
332
333	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
334		return 0;
335	resp->status = *p++;
336	return xdr_argsize_check(rqstp, p);
337}
338
339int
340nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p)
341{
342	return xdr_argsize_check(rqstp, p);
343}
344
345int
346nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p)
347{
348	return xdr_ressize_check(rqstp, p);
349}
350