Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * linux/fs/nfs/nfs4namespace.c
4 : : *
5 : : * Copyright (C) 2005 Trond Myklebust <Trond.Myklebust@netapp.com>
6 : : * - Modified by David Howells <dhowells@redhat.com>
7 : : *
8 : : * NFSv4 namespace
9 : : */
10 : :
11 : : #include <linux/dcache.h>
12 : : #include <linux/mount.h>
13 : : #include <linux/namei.h>
14 : : #include <linux/nfs_fs.h>
15 : : #include <linux/nfs_mount.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/string.h>
18 : : #include <linux/sunrpc/clnt.h>
19 : : #include <linux/sunrpc/addr.h>
20 : : #include <linux/vfs.h>
21 : : #include <linux/inet.h>
22 : : #include "internal.h"
23 : : #include "nfs4_fs.h"
24 : : #include "dns_resolve.h"
25 : :
26 : : #define NFSDBG_FACILITY NFSDBG_VFS
27 : :
28 : : /*
29 : : * Convert the NFSv4 pathname components into a standard posix path.
30 : : *
31 : : * Note that the resulting string will be placed at the end of the buffer
32 : : */
33 : 0 : static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
34 : : char *buffer, ssize_t buflen)
35 : : {
36 : 0 : char *end = buffer + buflen;
37 : : int n;
38 : :
39 : 0 : *--end = '\0';
40 : 0 : buflen--;
41 : :
42 : 0 : n = pathname->ncomponents;
43 : 0 : while (--n >= 0) {
44 : : const struct nfs4_string *component = &pathname->components[n];
45 : 0 : buflen -= component->len + 1;
46 : 0 : if (buflen < 0)
47 : : goto Elong;
48 : 0 : end -= component->len;
49 : 0 : memcpy(end, component->data, component->len);
50 : 0 : *--end = '/';
51 : : }
52 : 0 : return end;
53 : : Elong:
54 : : return ERR_PTR(-ENAMETOOLONG);
55 : : }
56 : :
57 : : /*
58 : : * return the path component of "<server>:<path>"
59 : : * nfspath - the "<server>:<path>" string
60 : : * end - one past the last char that could contain "<server>:"
61 : : * returns NULL on failure
62 : : */
63 : 0 : static char *nfs_path_component(const char *nfspath, const char *end)
64 : : {
65 : : char *p;
66 : :
67 : 0 : if (*nfspath == '[') {
68 : : /* parse [] escaped IPv6 addrs */
69 : 0 : p = strchr(nfspath, ']');
70 : 0 : if (p != NULL && ++p < end && *p == ':')
71 : 0 : return p + 1;
72 : : } else {
73 : : /* otherwise split on first colon */
74 : 0 : p = strchr(nfspath, ':');
75 : 0 : if (p != NULL && p < end)
76 : 0 : return p + 1;
77 : : }
78 : : return NULL;
79 : : }
80 : :
81 : : /*
82 : : * Determine the mount path as a string
83 : : */
84 : 0 : static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
85 : : {
86 : : char *limit;
87 : 0 : char *path = nfs_path(&limit, dentry, buffer, buflen,
88 : : NFS_PATH_CANONICAL);
89 : 0 : if (!IS_ERR(path)) {
90 : 0 : char *path_component = nfs_path_component(path, limit);
91 : 0 : if (path_component)
92 : : return path_component;
93 : : }
94 : 0 : return path;
95 : : }
96 : :
97 : : /*
98 : : * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
99 : : * believe to be the server path to this dentry
100 : : */
101 : 0 : static int nfs4_validate_fspath(struct dentry *dentry,
102 : : const struct nfs4_fs_locations *locations,
103 : : char *page, char *page2)
104 : : {
105 : : const char *path, *fs_path;
106 : :
107 : 0 : path = nfs4_path(dentry, page, PAGE_SIZE);
108 : 0 : if (IS_ERR(path))
109 : 0 : return PTR_ERR(path);
110 : :
111 : 0 : fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
112 : 0 : if (IS_ERR(fs_path))
113 : 0 : return PTR_ERR(fs_path);
114 : :
115 : 0 : if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
116 : : dprintk("%s: path %s does not begin with fsroot %s\n",
117 : : __func__, path, fs_path);
118 : : return -ENOENT;
119 : : }
120 : :
121 : 0 : return 0;
122 : : }
123 : :
124 : 0 : static size_t nfs_parse_server_name(char *string, size_t len,
125 : : struct sockaddr *sa, size_t salen, struct net *net)
126 : : {
127 : : ssize_t ret;
128 : :
129 : 0 : ret = rpc_pton(net, string, len, sa, salen);
130 : 0 : if (ret == 0) {
131 : 0 : ret = nfs_dns_resolve_name(net, string, len, sa, salen);
132 : 0 : if (ret < 0)
133 : : ret = 0;
134 : : }
135 : 0 : return ret;
136 : : }
137 : :
138 : : /**
139 : : * nfs_find_best_sec - Find a security mechanism supported locally
140 : : * @clnt: pointer to rpc_clnt
141 : : * @server: NFS server struct
142 : : * @flavors: List of security tuples returned by SECINFO procedure
143 : : *
144 : : * Return an rpc client that uses the first security mechanism in
145 : : * "flavors" that is locally supported. The "flavors" array
146 : : * is searched in the order returned from the server, per RFC 3530
147 : : * recommendation and each flavor is checked for membership in the
148 : : * sec= mount option list if it exists.
149 : : *
150 : : * Return -EPERM if no matching flavor is found in the array.
151 : : *
152 : : * Please call rpc_shutdown_client() when you are done with this rpc client.
153 : : *
154 : : */
155 : 0 : static struct rpc_clnt *nfs_find_best_sec(struct rpc_clnt *clnt,
156 : : struct nfs_server *server,
157 : : struct nfs4_secinfo_flavors *flavors)
158 : : {
159 : : rpc_authflavor_t pflavor;
160 : : struct nfs4_secinfo4 *secinfo;
161 : : unsigned int i;
162 : :
163 : 0 : for (i = 0; i < flavors->num_flavors; i++) {
164 : : secinfo = &flavors->flavors[i];
165 : :
166 : 0 : switch (secinfo->flavor) {
167 : : case RPC_AUTH_NULL:
168 : : case RPC_AUTH_UNIX:
169 : : case RPC_AUTH_GSS:
170 : 0 : pflavor = rpcauth_get_pseudoflavor(secinfo->flavor,
171 : : &secinfo->flavor_info);
172 : : /* does the pseudoflavor match a sec= mount opt? */
173 : 0 : if (pflavor != RPC_AUTH_MAXFLAVOR &&
174 : 0 : nfs_auth_info_match(&server->auth_info, pflavor)) {
175 : : struct rpc_clnt *new;
176 : : struct rpc_cred *cred;
177 : :
178 : : /* Cloning creates an rpc_auth for the flavor */
179 : 0 : new = rpc_clone_client_set_auth(clnt, pflavor);
180 : 0 : if (IS_ERR(new))
181 : 0 : continue;
182 : : /**
183 : : * Check that the user actually can use the
184 : : * flavor. This is mostly for RPC_AUTH_GSS
185 : : * where cr_init obtains a gss context
186 : : */
187 : 0 : cred = rpcauth_lookupcred(new->cl_auth, 0);
188 : 0 : if (IS_ERR(cred)) {
189 : 0 : rpc_shutdown_client(new);
190 : 0 : continue;
191 : : }
192 : 0 : put_rpccred(cred);
193 : 0 : return new;
194 : : }
195 : : }
196 : : }
197 : : return ERR_PTR(-EPERM);
198 : : }
199 : :
200 : : /**
201 : : * nfs4_negotiate_security - in response to an NFS4ERR_WRONGSEC on lookup,
202 : : * return an rpc_clnt that uses the best available security flavor with
203 : : * respect to the secinfo flavor list and the sec= mount options.
204 : : *
205 : : * @clnt: RPC client to clone
206 : : * @inode: directory inode
207 : : * @name: lookup name
208 : : *
209 : : * Please call rpc_shutdown_client() when you are done with this rpc client.
210 : : */
211 : : struct rpc_clnt *
212 : 0 : nfs4_negotiate_security(struct rpc_clnt *clnt, struct inode *inode,
213 : : const struct qstr *name)
214 : : {
215 : : struct page *page;
216 : : struct nfs4_secinfo_flavors *flavors;
217 : : struct rpc_clnt *new;
218 : : int err;
219 : :
220 : : page = alloc_page(GFP_KERNEL);
221 : 0 : if (!page)
222 : : return ERR_PTR(-ENOMEM);
223 : :
224 : : flavors = page_address(page);
225 : :
226 : 0 : err = nfs4_proc_secinfo(inode, name, flavors);
227 : 0 : if (err < 0) {
228 : : new = ERR_PTR(err);
229 : 0 : goto out;
230 : : }
231 : :
232 : 0 : new = nfs_find_best_sec(clnt, NFS_SERVER(inode), flavors);
233 : :
234 : : out:
235 : 0 : put_page(page);
236 : 0 : return new;
237 : : }
238 : :
239 : 0 : static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
240 : : char *page, char *page2,
241 : : const struct nfs4_fs_location *location)
242 : : {
243 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
244 : 0 : struct net *net = rpc_net_ns(NFS_SB(mountdata->sb)->client);
245 : : struct vfsmount *mnt = ERR_PTR(-ENOENT);
246 : : char *mnt_path;
247 : : unsigned int maxbuflen;
248 : : unsigned int s;
249 : :
250 : 0 : mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
251 : 0 : if (IS_ERR(mnt_path))
252 : : return ERR_CAST(mnt_path);
253 : 0 : mountdata->mnt_path = mnt_path;
254 : 0 : maxbuflen = mnt_path - 1 - page2;
255 : :
256 : 0 : mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
257 : 0 : if (mountdata->addr == NULL)
258 : : return ERR_PTR(-ENOMEM);
259 : :
260 : 0 : for (s = 0; s < location->nservers; s++) {
261 : : const struct nfs4_string *buf = &location->servers[s];
262 : :
263 : 0 : if (buf->len <= 0 || buf->len >= maxbuflen)
264 : 0 : continue;
265 : :
266 : 0 : if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
267 : 0 : continue;
268 : :
269 : 0 : mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
270 : : mountdata->addr, addr_bufsize, net);
271 : 0 : if (mountdata->addrlen == 0)
272 : 0 : continue;
273 : :
274 : 0 : memcpy(page2, buf->data, buf->len);
275 : 0 : page2[buf->len] = '\0';
276 : 0 : mountdata->hostname = page2;
277 : :
278 : 0 : snprintf(page, PAGE_SIZE, "%s:%s",
279 : : mountdata->hostname,
280 : : mountdata->mnt_path);
281 : :
282 : 0 : mnt = vfs_submount(mountdata->dentry, &nfs4_referral_fs_type, page, mountdata);
283 : 0 : if (!IS_ERR(mnt))
284 : : break;
285 : : }
286 : 0 : kfree(mountdata->addr);
287 : 0 : return mnt;
288 : : }
289 : :
290 : : /**
291 : : * nfs_follow_referral - set up mountpoint when hitting a referral on moved error
292 : : * @dentry: parent directory
293 : : * @locations: array of NFSv4 server location information
294 : : *
295 : : */
296 : 0 : static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
297 : : const struct nfs4_fs_locations *locations)
298 : : {
299 : : struct vfsmount *mnt = ERR_PTR(-ENOENT);
300 : 0 : struct nfs_clone_mount mountdata = {
301 : 0 : .sb = dentry->d_sb,
302 : : .dentry = dentry,
303 : 0 : .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
304 : : };
305 : : char *page = NULL, *page2 = NULL;
306 : : int loc, error;
307 : :
308 : 0 : if (locations == NULL || locations->nlocations <= 0)
309 : : goto out;
310 : :
311 : : dprintk("%s: referral at %pd2\n", __func__, dentry);
312 : :
313 : 0 : page = (char *) __get_free_page(GFP_USER);
314 : 0 : if (!page)
315 : : goto out;
316 : :
317 : 0 : page2 = (char *) __get_free_page(GFP_USER);
318 : 0 : if (!page2)
319 : : goto out;
320 : :
321 : : /* Ensure fs path is a prefix of current dentry path */
322 : 0 : error = nfs4_validate_fspath(dentry, locations, page, page2);
323 : 0 : if (error < 0) {
324 : : mnt = ERR_PTR(error);
325 : 0 : goto out;
326 : : }
327 : :
328 : 0 : for (loc = 0; loc < locations->nlocations; loc++) {
329 : 0 : const struct nfs4_fs_location *location = &locations->locations[loc];
330 : :
331 : 0 : if (location == NULL || location->nservers <= 0 ||
332 : 0 : location->rootpath.ncomponents == 0)
333 : 0 : continue;
334 : :
335 : 0 : mnt = try_location(&mountdata, page, page2, location);
336 : 0 : if (!IS_ERR(mnt))
337 : : break;
338 : : }
339 : :
340 : : out:
341 : 0 : free_page((unsigned long) page);
342 : 0 : free_page((unsigned long) page2);
343 : 0 : return mnt;
344 : : }
345 : :
346 : : /*
347 : : * nfs_do_refmount - handle crossing a referral on server
348 : : * @dentry - dentry of referral
349 : : *
350 : : */
351 : 0 : static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry)
352 : : {
353 : : struct vfsmount *mnt = ERR_PTR(-ENOMEM);
354 : : struct dentry *parent;
355 : : struct nfs4_fs_locations *fs_locations = NULL;
356 : : struct page *page;
357 : : int err;
358 : :
359 : : /* BUG_ON(IS_ROOT(dentry)); */
360 : : page = alloc_page(GFP_KERNEL);
361 : 0 : if (page == NULL)
362 : : return mnt;
363 : :
364 : : fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
365 : 0 : if (fs_locations == NULL)
366 : : goto out_free;
367 : :
368 : : /* Get locations */
369 : : mnt = ERR_PTR(-ENOENT);
370 : :
371 : 0 : parent = dget_parent(dentry);
372 : : dprintk("%s: getting locations for %pd2\n",
373 : : __func__, dentry);
374 : :
375 : 0 : err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page);
376 : 0 : dput(parent);
377 : 0 : if (err != 0 ||
378 : 0 : fs_locations->nlocations <= 0 ||
379 : 0 : fs_locations->fs_path.ncomponents <= 0)
380 : : goto out_free;
381 : :
382 : 0 : mnt = nfs_follow_referral(dentry, fs_locations);
383 : : out_free:
384 : 0 : __free_page(page);
385 : 0 : kfree(fs_locations);
386 : 0 : return mnt;
387 : : }
388 : :
389 : 0 : struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
390 : : struct nfs_fh *fh, struct nfs_fattr *fattr)
391 : : {
392 : 0 : rpc_authflavor_t flavor = server->client->cl_auth->au_flavor;
393 : 0 : struct dentry *parent = dget_parent(dentry);
394 : : struct inode *dir = d_inode(parent);
395 : 0 : const struct qstr *name = &dentry->d_name;
396 : : struct rpc_clnt *client;
397 : : struct vfsmount *mnt;
398 : :
399 : : /* Look it up again to get its attributes and sec flavor */
400 : 0 : client = nfs4_proc_lookup_mountpoint(dir, name, fh, fattr);
401 : 0 : dput(parent);
402 : 0 : if (IS_ERR(client))
403 : : return ERR_CAST(client);
404 : :
405 : 0 : if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
406 : 0 : mnt = nfs_do_refmount(client, dentry);
407 : 0 : goto out;
408 : : }
409 : :
410 : 0 : if (client->cl_auth->au_flavor != flavor)
411 : : flavor = client->cl_auth->au_flavor;
412 : 0 : mnt = nfs_do_submount(dentry, fh, fattr, flavor);
413 : : out:
414 : 0 : rpc_shutdown_client(client);
415 : 0 : return mnt;
416 : : }
417 : :
418 : : /*
419 : : * Try one location from the fs_locations array.
420 : : *
421 : : * Returns zero on success, or a negative errno value.
422 : : */
423 : 0 : static int nfs4_try_replacing_one_location(struct nfs_server *server,
424 : : char *page, char *page2,
425 : : const struct nfs4_fs_location *location)
426 : : {
427 : : const size_t addr_bufsize = sizeof(struct sockaddr_storage);
428 : 0 : struct net *net = rpc_net_ns(server->client);
429 : : struct sockaddr *sap;
430 : : unsigned int s;
431 : : size_t salen;
432 : : int error;
433 : :
434 : : sap = kmalloc(addr_bufsize, GFP_KERNEL);
435 : 0 : if (sap == NULL)
436 : : return -ENOMEM;
437 : :
438 : : error = -ENOENT;
439 : 0 : for (s = 0; s < location->nservers; s++) {
440 : : const struct nfs4_string *buf = &location->servers[s];
441 : : char *hostname;
442 : :
443 : 0 : if (buf->len <= 0 || buf->len > PAGE_SIZE)
444 : 0 : continue;
445 : :
446 : 0 : if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len) != NULL)
447 : 0 : continue;
448 : :
449 : 0 : salen = nfs_parse_server_name(buf->data, buf->len,
450 : : sap, addr_bufsize, net);
451 : 0 : if (salen == 0)
452 : 0 : continue;
453 : : rpc_set_port(sap, NFS_PORT);
454 : :
455 : : error = -ENOMEM;
456 : 0 : hostname = kstrndup(buf->data, buf->len, GFP_KERNEL);
457 : 0 : if (hostname == NULL)
458 : : break;
459 : :
460 : 0 : error = nfs4_update_server(server, hostname, sap, salen, net);
461 : 0 : kfree(hostname);
462 : 0 : if (error == 0)
463 : : break;
464 : : }
465 : :
466 : 0 : kfree(sap);
467 : 0 : return error;
468 : : }
469 : :
470 : : /**
471 : : * nfs4_replace_transport - set up transport to destination server
472 : : *
473 : : * @server: export being migrated
474 : : * @locations: fs_locations array
475 : : *
476 : : * Returns zero on success, or a negative errno value.
477 : : *
478 : : * The client tries all the entries in the "locations" array, in the
479 : : * order returned by the server, until one works or the end of the
480 : : * array is reached.
481 : : */
482 : 0 : int nfs4_replace_transport(struct nfs_server *server,
483 : : const struct nfs4_fs_locations *locations)
484 : : {
485 : : char *page = NULL, *page2 = NULL;
486 : : int loc, error;
487 : :
488 : : error = -ENOENT;
489 : 0 : if (locations == NULL || locations->nlocations <= 0)
490 : : goto out;
491 : :
492 : : error = -ENOMEM;
493 : 0 : page = (char *) __get_free_page(GFP_USER);
494 : 0 : if (!page)
495 : : goto out;
496 : 0 : page2 = (char *) __get_free_page(GFP_USER);
497 : 0 : if (!page2)
498 : : goto out;
499 : :
500 : 0 : for (loc = 0; loc < locations->nlocations; loc++) {
501 : 0 : const struct nfs4_fs_location *location =
502 : : &locations->locations[loc];
503 : :
504 : 0 : if (location == NULL || location->nservers <= 0 ||
505 : 0 : location->rootpath.ncomponents == 0)
506 : 0 : continue;
507 : :
508 : 0 : error = nfs4_try_replacing_one_location(server, page,
509 : : page2, location);
510 : 0 : if (error == 0)
511 : : break;
512 : : }
513 : :
514 : : out:
515 : 0 : free_page((unsigned long)page);
516 : 0 : free_page((unsigned long)page2);
517 : 0 : return error;
518 : : }
|
