1/*
2 * In-kernel MOUNT protocol client
3 *
4 * Copyright (C) 1997, Olaf Kirch <okir@monad.swb.de>
5 */
6
7#include <linux/types.h>
8#include <linux/socket.h>
9#include <linux/kernel.h>
10#include <linux/errno.h>
11#include <linux/uio.h>
12#include <linux/net.h>
13#include <linux/in.h>
14#include <linux/sunrpc/clnt.h>
15#include <linux/sunrpc/sched.h>
16#include <linux/nfs_fs.h>
17#include "internal.h"
18
19#ifdef NFS_DEBUG
20# define NFSDBG_FACILITY	NFSDBG_MOUNT
21#endif
22
23/*
24 * Defined by RFC 1094, section A.3; and RFC 1813, section 5.1.4
25 */
26#define MNTPATHLEN		(1024)
27
28/*
29 * XDR data type sizes
30 */
31#define encode_dirpath_sz	(1 + XDR_QUADLEN(MNTPATHLEN))
32#define MNT_status_sz		(1)
33#define MNT_fhs_status_sz	(1)
34#define MNT_fhandle_sz		XDR_QUADLEN(NFS2_FHSIZE)
35#define MNT_fhandle3_sz		(1 + XDR_QUADLEN(NFS3_FHSIZE))
36#define MNT_authflav3_sz	(1 + NFS_MAX_SECFLAVORS)
37
38/*
39 * XDR argument and result sizes
40 */
41#define MNT_enc_dirpath_sz	encode_dirpath_sz
42#define MNT_dec_mountres_sz	(MNT_status_sz + MNT_fhandle_sz)
43#define MNT_dec_mountres3_sz	(MNT_status_sz + MNT_fhandle_sz + \
44				 MNT_authflav3_sz)
45
46/*
47 * Defined by RFC 1094, section A.5
48 */
49enum {
50	MOUNTPROC_NULL		= 0,
51	MOUNTPROC_MNT		= 1,
52	MOUNTPROC_DUMP		= 2,
53	MOUNTPROC_UMNT		= 3,
54	MOUNTPROC_UMNTALL	= 4,
55	MOUNTPROC_EXPORT	= 5,
56};
57
58/*
59 * Defined by RFC 1813, section 5.2
60 */
61enum {
62	MOUNTPROC3_NULL		= 0,
63	MOUNTPROC3_MNT		= 1,
64	MOUNTPROC3_DUMP		= 2,
65	MOUNTPROC3_UMNT		= 3,
66	MOUNTPROC3_UMNTALL	= 4,
67	MOUNTPROC3_EXPORT	= 5,
68};
69
70static const struct rpc_program mnt_program;
71
72/*
73 * Defined by OpenGroup XNFS Version 3W, chapter 8
74 */
75enum mountstat {
76	MNT_OK			= 0,
77	MNT_EPERM		= 1,
78	MNT_ENOENT		= 2,
79	MNT_EACCES		= 13,
80	MNT_EINVAL		= 22,
81};
82
83static struct {
84	u32 status;
85	int errno;
86} mnt_errtbl[] = {
87	{ .status = MNT_OK,			.errno = 0,		},
88	{ .status = MNT_EPERM,			.errno = -EPERM,	},
89	{ .status = MNT_ENOENT,			.errno = -ENOENT,	},
90	{ .status = MNT_EACCES,			.errno = -EACCES,	},
91	{ .status = MNT_EINVAL,			.errno = -EINVAL,	},
92};
93
94/*
95 * Defined by RFC 1813, section 5.1.5
96 */
97enum mountstat3 {
98	MNT3_OK			= 0,		/* no error */
99	MNT3ERR_PERM		= 1,		/* Not owner */
100	MNT3ERR_NOENT		= 2,		/* No such file or directory */
101	MNT3ERR_IO		= 5,		/* I/O error */
102	MNT3ERR_ACCES		= 13,		/* Permission denied */
103	MNT3ERR_NOTDIR		= 20,		/* Not a directory */
104	MNT3ERR_INVAL		= 22,		/* Invalid argument */
105	MNT3ERR_NAMETOOLONG	= 63,		/* Filename too long */
106	MNT3ERR_NOTSUPP		= 10004,	/* Operation not supported */
107	MNT3ERR_SERVERFAULT	= 10006,	/* A failure on the server */
108};
109
110static struct {
111	u32 status;
112	int errno;
113} mnt3_errtbl[] = {
114	{ .status = MNT3_OK,			.errno = 0,		},
115	{ .status = MNT3ERR_PERM,		.errno = -EPERM,	},
116	{ .status = MNT3ERR_NOENT,		.errno = -ENOENT,	},
117	{ .status = MNT3ERR_IO,			.errno = -EIO,		},
118	{ .status = MNT3ERR_ACCES,		.errno = -EACCES,	},
119	{ .status = MNT3ERR_NOTDIR,		.errno = -ENOTDIR,	},
120	{ .status = MNT3ERR_INVAL,		.errno = -EINVAL,	},
121	{ .status = MNT3ERR_NAMETOOLONG,	.errno = -ENAMETOOLONG,	},
122	{ .status = MNT3ERR_NOTSUPP,		.errno = -ENOTSUPP,	},
123	{ .status = MNT3ERR_SERVERFAULT,	.errno = -EREMOTEIO,	},
124};
125
126struct mountres {
127	int errno;
128	struct nfs_fh *fh;
129	unsigned int *auth_count;
130	rpc_authflavor_t *auth_flavors;
131};
132
133struct mnt_fhstatus {
134	u32 status;
135	struct nfs_fh *fh;
136};
137
138/**
139 * nfs_mount - Obtain an NFS file handle for the given host and path
140 * @info: pointer to mount request arguments
141 *
142 * Uses default timeout parameters specified by underlying transport. On
143 * successful return, the auth_flavs list and auth_flav_len will be populated
144 * with the list from the server or a faked-up list if the server didn't
145 * provide one.
146 */
147int nfs_mount(struct nfs_mount_request *info)
148{
149	struct mountres	result = {
150		.fh		= info->fh,
151		.auth_count	= info->auth_flav_len,
152		.auth_flavors	= info->auth_flavs,
153	};
154	struct rpc_message msg	= {
155		.rpc_argp	= info->dirpath,
156		.rpc_resp	= &result,
157	};
158	struct rpc_create_args args = {
159		.net		= info->net,
160		.protocol	= info->protocol,
161		.address	= info->sap,
162		.addrsize	= info->salen,
163		.servername	= info->hostname,
164		.program	= &mnt_program,
165		.version	= info->version,
166		.authflavor	= RPC_AUTH_UNIX,
167	};
168	struct rpc_clnt		*mnt_clnt;
169	int			status;
170
171	dprintk("NFS: sending MNT request for %s:%s\n",
172		(info->hostname ? info->hostname : "server"),
173			info->dirpath);
174
175	if (strlen(info->dirpath) > MNTPATHLEN)
176		return -ENAMETOOLONG;
177
178	if (info->noresvport)
179		args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
180
181	mnt_clnt = rpc_create(&args);
182	if (IS_ERR(mnt_clnt))
183		goto out_clnt_err;
184
185	if (info->version == NFS_MNT3_VERSION)
186		msg.rpc_proc = &mnt_clnt->cl_procinfo[MOUNTPROC3_MNT];
187	else
188		msg.rpc_proc = &mnt_clnt->cl_procinfo[MOUNTPROC_MNT];
189
190	status = rpc_call_sync(mnt_clnt, &msg, RPC_TASK_SOFT|RPC_TASK_TIMEOUT);
191	rpc_shutdown_client(mnt_clnt);
192
193	if (status < 0)
194		goto out_call_err;
195	if (result.errno != 0)
196		goto out_mnt_err;
197
198	dprintk("NFS: MNT request succeeded\n");
199	status = 0;
200
201	/*
202	 * If the server didn't provide a flavor list, allow the
203	 * client to try any flavor.
204	 */
205	if (info->version != NFS_MNT3_VERSION || *info->auth_flav_len == 0) {
206		dprintk("NFS: Faking up auth_flavs list\n");
207		info->auth_flavs[0] = RPC_AUTH_NULL;
208		*info->auth_flav_len = 1;
209	}
210out:
211	return status;
212
213out_clnt_err:
214	status = PTR_ERR(mnt_clnt);
215	dprintk("NFS: failed to create MNT RPC client, status=%d\n", status);
216	goto out;
217
218out_call_err:
219	dprintk("NFS: MNT request failed, status=%d\n", status);
220	goto out;
221
222out_mnt_err:
223	dprintk("NFS: MNT server returned result %d\n", result.errno);
224	status = result.errno;
225	goto out;
226}
227
228/**
229 * nfs_umount - Notify a server that we have unmounted this export
230 * @info: pointer to umount request arguments
231 *
232 * MOUNTPROC_UMNT is advisory, so we set a short timeout, and always
233 * use UDP.
234 */
235void nfs_umount(const struct nfs_mount_request *info)
236{
237	static const struct rpc_timeout nfs_umnt_timeout = {
238		.to_initval = 1 * HZ,
239		.to_maxval = 3 * HZ,
240		.to_retries = 2,
241	};
242	struct rpc_create_args args = {
243		.net		= info->net,
244		.protocol	= IPPROTO_UDP,
245		.address	= info->sap,
246		.addrsize	= info->salen,
247		.timeout	= &nfs_umnt_timeout,
248		.servername	= info->hostname,
249		.program	= &mnt_program,
250		.version	= info->version,
251		.authflavor	= RPC_AUTH_UNIX,
252		.flags		= RPC_CLNT_CREATE_NOPING,
253	};
254	struct rpc_message msg	= {
255		.rpc_argp	= info->dirpath,
256	};
257	struct rpc_clnt *clnt;
258	int status;
259
260	if (strlen(info->dirpath) > MNTPATHLEN)
261		return;
262
263	if (info->noresvport)
264		args.flags |= RPC_CLNT_CREATE_NONPRIVPORT;
265
266	clnt = rpc_create(&args);
267	if (IS_ERR(clnt))
268		goto out_clnt_err;
269
270	dprintk("NFS: sending UMNT request for %s:%s\n",
271		(info->hostname ? info->hostname : "server"), info->dirpath);
272
273	if (info->version == NFS_MNT3_VERSION)
274		msg.rpc_proc = &clnt->cl_procinfo[MOUNTPROC3_UMNT];
275	else
276		msg.rpc_proc = &clnt->cl_procinfo[MOUNTPROC_UMNT];
277
278	status = rpc_call_sync(clnt, &msg, 0);
279	rpc_shutdown_client(clnt);
280
281	if (unlikely(status < 0))
282		goto out_call_err;
283
284	return;
285
286out_clnt_err:
287	dprintk("NFS: failed to create UMNT RPC client, status=%ld\n",
288			PTR_ERR(clnt));
289	return;
290
291out_call_err:
292	dprintk("NFS: UMNT request failed, status=%d\n", status);
293}
294
295/*
296 * XDR encode/decode functions for MOUNT
297 */
298
299static void encode_mntdirpath(struct xdr_stream *xdr, const char *pathname)
300{
301	const u32 pathname_len = strlen(pathname);
302	__be32 *p;
303
304	p = xdr_reserve_space(xdr, 4 + pathname_len);
305	xdr_encode_opaque(p, pathname, pathname_len);
306}
307
308static void mnt_xdr_enc_dirpath(struct rpc_rqst *req, struct xdr_stream *xdr,
309				const char *dirpath)
310{
311	encode_mntdirpath(xdr, dirpath);
312}
313
314/*
315 * RFC 1094: "A non-zero status indicates some sort of error.  In this
316 * case, the status is a UNIX error number."  This can be problematic
317 * if the server and client use different errno values for the same
318 * error.
319 *
320 * However, the OpenGroup XNFS spec provides a simple mapping that is
321 * independent of local errno values on the server and the client.
322 */
323static int decode_status(struct xdr_stream *xdr, struct mountres *res)
324{
325	unsigned int i;
326	u32 status;
327	__be32 *p;
328
329	p = xdr_inline_decode(xdr, 4);
330	if (unlikely(p == NULL))
331		return -EIO;
332	status = be32_to_cpup(p);
333
334	for (i = 0; i < ARRAY_SIZE(mnt_errtbl); i++) {
335		if (mnt_errtbl[i].status == status) {
336			res->errno = mnt_errtbl[i].errno;
337			return 0;
338		}
339	}
340
341	dprintk("NFS: unrecognized MNT status code: %u\n", status);
342	res->errno = -EACCES;
343	return 0;
344}
345
346static int decode_fhandle(struct xdr_stream *xdr, struct mountres *res)
347{
348	struct nfs_fh *fh = res->fh;
349	__be32 *p;
350
351	p = xdr_inline_decode(xdr, NFS2_FHSIZE);
352	if (unlikely(p == NULL))
353		return -EIO;
354
355	fh->size = NFS2_FHSIZE;
356	memcpy(fh->data, p, NFS2_FHSIZE);
357	return 0;
358}
359
360static int mnt_xdr_dec_mountres(struct rpc_rqst *req,
361				struct xdr_stream *xdr,
362				struct mountres *res)
363{
364	int status;
365
366	status = decode_status(xdr, res);
367	if (unlikely(status != 0 || res->errno != 0))
368		return status;
369	return decode_fhandle(xdr, res);
370}
371
372static int decode_fhs_status(struct xdr_stream *xdr, struct mountres *res)
373{
374	unsigned int i;
375	u32 status;
376	__be32 *p;
377
378	p = xdr_inline_decode(xdr, 4);
379	if (unlikely(p == NULL))
380		return -EIO;
381	status = be32_to_cpup(p);
382
383	for (i = 0; i < ARRAY_SIZE(mnt3_errtbl); i++) {
384		if (mnt3_errtbl[i].status == status) {
385			res->errno = mnt3_errtbl[i].errno;
386			return 0;
387		}
388	}
389
390	dprintk("NFS: unrecognized MNT3 status code: %u\n", status);
391	res->errno = -EACCES;
392	return 0;
393}
394
395static int decode_fhandle3(struct xdr_stream *xdr, struct mountres *res)
396{
397	struct nfs_fh *fh = res->fh;
398	u32 size;
399	__be32 *p;
400
401	p = xdr_inline_decode(xdr, 4);
402	if (unlikely(p == NULL))
403		return -EIO;
404
405	size = be32_to_cpup(p);
406	if (size > NFS3_FHSIZE || size == 0)
407		return -EIO;
408
409	p = xdr_inline_decode(xdr, size);
410	if (unlikely(p == NULL))
411		return -EIO;
412
413	fh->size = size;
414	memcpy(fh->data, p, size);
415	return 0;
416}
417
418static int decode_auth_flavors(struct xdr_stream *xdr, struct mountres *res)
419{
420	rpc_authflavor_t *flavors = res->auth_flavors;
421	unsigned int *count = res->auth_count;
422	u32 entries, i;
423	__be32 *p;
424
425	if (*count == 0)
426		return 0;
427
428	p = xdr_inline_decode(xdr, 4);
429	if (unlikely(p == NULL))
430		return -EIO;
431	entries = be32_to_cpup(p);
432	dprintk("NFS: received %u auth flavors\n", entries);
433	if (entries > NFS_MAX_SECFLAVORS)
434		entries = NFS_MAX_SECFLAVORS;
435
436	p = xdr_inline_decode(xdr, 4 * entries);
437	if (unlikely(p == NULL))
438		return -EIO;
439
440	if (entries > *count)
441		entries = *count;
442
443	for (i = 0; i < entries; i++) {
444		flavors[i] = be32_to_cpup(p++);
445		dprintk("NFS:   auth flavor[%u]: %d\n", i, flavors[i]);
446	}
447	*count = i;
448
449	return 0;
450}
451
452static int mnt_xdr_dec_mountres3(struct rpc_rqst *req,
453				 struct xdr_stream *xdr,
454				 struct mountres *res)
455{
456	int status;
457
458	status = decode_fhs_status(xdr, res);
459	if (unlikely(status != 0 || res->errno != 0))
460		return status;
461	status = decode_fhandle3(xdr, res);
462	if (unlikely(status != 0)) {
463		res->errno = -EBADHANDLE;
464		return 0;
465	}
466	return decode_auth_flavors(xdr, res);
467}
468
469static struct rpc_procinfo mnt_procedures[] = {
470	[MOUNTPROC_MNT] = {
471		.p_proc		= MOUNTPROC_MNT,
472		.p_encode	= (kxdreproc_t)mnt_xdr_enc_dirpath,
473		.p_decode	= (kxdrdproc_t)mnt_xdr_dec_mountres,
474		.p_arglen	= MNT_enc_dirpath_sz,
475		.p_replen	= MNT_dec_mountres_sz,
476		.p_statidx	= MOUNTPROC_MNT,
477		.p_name		= "MOUNT",
478	},
479	[MOUNTPROC_UMNT] = {
480		.p_proc		= MOUNTPROC_UMNT,
481		.p_encode	= (kxdreproc_t)mnt_xdr_enc_dirpath,
482		.p_arglen	= MNT_enc_dirpath_sz,
483		.p_statidx	= MOUNTPROC_UMNT,
484		.p_name		= "UMOUNT",
485	},
486};
487
488static struct rpc_procinfo mnt3_procedures[] = {
489	[MOUNTPROC3_MNT] = {
490		.p_proc		= MOUNTPROC3_MNT,
491		.p_encode	= (kxdreproc_t)mnt_xdr_enc_dirpath,
492		.p_decode	= (kxdrdproc_t)mnt_xdr_dec_mountres3,
493		.p_arglen	= MNT_enc_dirpath_sz,
494		.p_replen	= MNT_dec_mountres3_sz,
495		.p_statidx	= MOUNTPROC3_MNT,
496		.p_name		= "MOUNT",
497	},
498	[MOUNTPROC3_UMNT] = {
499		.p_proc		= MOUNTPROC3_UMNT,
500		.p_encode	= (kxdreproc_t)mnt_xdr_enc_dirpath,
501		.p_arglen	= MNT_enc_dirpath_sz,
502		.p_statidx	= MOUNTPROC3_UMNT,
503		.p_name		= "UMOUNT",
504	},
505};
506
507
508static const struct rpc_version mnt_version1 = {
509	.number		= 1,
510	.nrprocs	= ARRAY_SIZE(mnt_procedures),
511	.procs		= mnt_procedures,
512};
513
514static const struct rpc_version mnt_version3 = {
515	.number		= 3,
516	.nrprocs	= ARRAY_SIZE(mnt3_procedures),
517	.procs		= mnt3_procedures,
518};
519
520static const struct rpc_version *mnt_version[] = {
521	NULL,
522	&mnt_version1,
523	NULL,
524	&mnt_version3,
525};
526
527static struct rpc_stat mnt_stats;
528
529static const struct rpc_program mnt_program = {
530	.name		= "mount",
531	.number		= NFS_MNT_PROGRAM,
532	.nrvers		= ARRAY_SIZE(mnt_version),
533	.version	= mnt_version,
534	.stats		= &mnt_stats,
535};
536