Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
nfs4namespace.c
Go to the documentation of this file.
1 /*
2  * linux/fs/nfs/nfs4namespace.c
3  *
4  * Copyright (C) 2005 Trond Myklebust <[email protected]>
5  * - Modified by David Howells <[email protected]>
6  *
7  * NFSv4 namespace
8  */
9 
10 #include <linux/dcache.h>
11 #include <linux/mount.h>
12 #include <linux/namei.h>
13 #include <linux/nfs_fs.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/sunrpc/clnt.h>
17 #include <linux/vfs.h>
18 #include <linux/inet.h>
19 #include "internal.h"
20 #include "nfs4_fs.h"
21 #include "dns_resolve.h"
22 
23 #define NFSDBG_FACILITY NFSDBG_VFS
24 
25 /*
26  * Convert the NFSv4 pathname components into a standard posix path.
27  *
28  * Note that the resulting string will be placed at the end of the buffer
29  */
30 static inline char *nfs4_pathname_string(const struct nfs4_pathname *pathname,
31  char *buffer, ssize_t buflen)
32 {
33  char *end = buffer + buflen;
34  int n;
35 
36  *--end = '\0';
37  buflen--;
38 
39  n = pathname->ncomponents;
40  while (--n >= 0) {
41  const struct nfs4_string *component = &pathname->components[n];
42  buflen -= component->len + 1;
43  if (buflen < 0)
44  goto Elong;
45  end -= component->len;
46  memcpy(end, component->data, component->len);
47  *--end = '/';
48  }
49  return end;
50 Elong:
51  return ERR_PTR(-ENAMETOOLONG);
52 }
53 
54 /*
55  * return the path component of "<server>:<path>"
56  * nfspath - the "<server>:<path>" string
57  * end - one past the last char that could contain "<server>:"
58  * returns NULL on failure
59  */
60 static char *nfs_path_component(const char *nfspath, const char *end)
61 {
62  char *p;
63 
64  if (*nfspath == '[') {
65  /* parse [] escaped IPv6 addrs */
66  p = strchr(nfspath, ']');
67  if (p != NULL && ++p < end && *p == ':')
68  return p + 1;
69  } else {
70  /* otherwise split on first colon */
71  p = strchr(nfspath, ':');
72  if (p != NULL && p < end)
73  return p + 1;
74  }
75  return NULL;
76 }
77 
78 /*
79  * Determine the mount path as a string
80  */
81 static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
82 {
83  char *limit;
84  char *path = nfs_path(&limit, dentry, buffer, buflen,
86  if (!IS_ERR(path)) {
87  char *path_component = nfs_path_component(path, limit);
88  if (path_component)
89  return path_component;
90  }
91  return path;
92 }
93 
94 /*
95  * Check that fs_locations::fs_root [RFC3530 6.3] is a prefix for what we
96  * believe to be the server path to this dentry
97  */
98 static int nfs4_validate_fspath(struct dentry *dentry,
99  const struct nfs4_fs_locations *locations,
100  char *page, char *page2)
101 {
102  const char *path, *fs_path;
103 
104  path = nfs4_path(dentry, page, PAGE_SIZE);
105  if (IS_ERR(path))
106  return PTR_ERR(path);
107 
108  fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
109  if (IS_ERR(fs_path))
110  return PTR_ERR(fs_path);
111 
112  if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
113  dprintk("%s: path %s does not begin with fsroot %s\n",
114  __func__, path, fs_path);
115  return -ENOENT;
116  }
117 
118  return 0;
119 }
120 
121 static size_t nfs_parse_server_name(char *string, size_t len,
122  struct sockaddr *sa, size_t salen, struct nfs_server *server)
123 {
124  struct net *net = rpc_net_ns(server->client);
125  ssize_t ret;
126 
127  ret = rpc_pton(net, string, len, sa, salen);
128  if (ret == 0) {
129  ret = nfs_dns_resolve_name(net, string, len, sa, salen);
130  if (ret < 0)
131  ret = 0;
132  }
133  return ret;
134 }
135 
136 rpc_authflavor_t nfs_find_best_sec(struct nfs4_secinfo_flavors *flavors)
137 {
138  struct gss_api_mech *mech;
139  struct xdr_netobj oid;
140  int i;
141  rpc_authflavor_t pseudoflavor = RPC_AUTH_UNIX;
142 
143  for (i = 0; i < flavors->num_flavors; i++) {
144  struct nfs4_secinfo_flavor *flavor;
145  flavor = &flavors->flavors[i];
146 
147  if (flavor->flavor == RPC_AUTH_NULL || flavor->flavor == RPC_AUTH_UNIX) {
148  pseudoflavor = flavor->flavor;
149  break;
150  } else if (flavor->flavor == RPC_AUTH_GSS) {
151  oid.len = flavor->gss.sec_oid4.len;
152  oid.data = flavor->gss.sec_oid4.data;
153  mech = gss_mech_get_by_OID(&oid);
154  if (!mech)
155  continue;
156  pseudoflavor = gss_svc_to_pseudoflavor(mech, flavor->gss.service);
157  gss_mech_put(mech);
158  break;
159  }
160  }
161 
162  return pseudoflavor;
163 }
164 
165 static rpc_authflavor_t nfs4_negotiate_security(struct inode *inode, struct qstr *name)
166 {
167  struct page *page;
168  struct nfs4_secinfo_flavors *flavors;
169  rpc_authflavor_t flavor;
170  int err;
171 
172  page = alloc_page(GFP_KERNEL);
173  if (!page)
174  return -ENOMEM;
175  flavors = page_address(page);
176 
177  err = nfs4_proc_secinfo(inode, name, flavors);
178  if (err < 0) {
179  flavor = err;
180  goto out;
181  }
182 
183  flavor = nfs_find_best_sec(flavors);
184 
185 out:
186  put_page(page);
187  return flavor;
188 }
189 
190 /*
191  * Please call rpc_shutdown_client() when you are done with this client.
192  */
193 struct rpc_clnt *nfs4_create_sec_client(struct rpc_clnt *clnt, struct inode *inode,
194  struct qstr *name)
195 {
196  rpc_authflavor_t flavor;
197 
198  flavor = nfs4_negotiate_security(inode, name);
199  if ((int)flavor < 0)
200  return ERR_PTR((int)flavor);
201 
202  return rpc_clone_client_set_auth(clnt, flavor);
203 }
204 
205 static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
206  char *page, char *page2,
207  const struct nfs4_fs_location *location)
208 {
209  const size_t addr_bufsize = sizeof(struct sockaddr_storage);
210  struct vfsmount *mnt = ERR_PTR(-ENOENT);
211  char *mnt_path;
212  unsigned int maxbuflen;
213  unsigned int s;
214 
215  mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
216  if (IS_ERR(mnt_path))
217  return ERR_CAST(mnt_path);
218  mountdata->mnt_path = mnt_path;
219  maxbuflen = mnt_path - 1 - page2;
220 
221  mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
222  if (mountdata->addr == NULL)
223  return ERR_PTR(-ENOMEM);
224 
225  for (s = 0; s < location->nservers; s++) {
226  const struct nfs4_string *buf = &location->servers[s];
227 
228  if (buf->len <= 0 || buf->len >= maxbuflen)
229  continue;
230 
231  if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
232  continue;
233 
234  mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
235  mountdata->addr, addr_bufsize,
236  NFS_SB(mountdata->sb));
237  if (mountdata->addrlen == 0)
238  continue;
239 
240  rpc_set_port(mountdata->addr, NFS_PORT);
241 
242  memcpy(page2, buf->data, buf->len);
243  page2[buf->len] = '\0';
244  mountdata->hostname = page2;
245 
246  snprintf(page, PAGE_SIZE, "%s:%s",
247  mountdata->hostname,
248  mountdata->mnt_path);
249 
250  mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
251  if (!IS_ERR(mnt))
252  break;
253  }
254  kfree(mountdata->addr);
255  return mnt;
256 }
257 
264 static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
265  const struct nfs4_fs_locations *locations)
266 {
267  struct vfsmount *mnt = ERR_PTR(-ENOENT);
268  struct nfs_clone_mount mountdata = {
269  .sb = dentry->d_sb,
270  .dentry = dentry,
271  .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
272  };
273  char *page = NULL, *page2 = NULL;
274  int loc, error;
275 
276  if (locations == NULL || locations->nlocations <= 0)
277  goto out;
278 
279  dprintk("%s: referral at %s/%s\n", __func__,
280  dentry->d_parent->d_name.name, dentry->d_name.name);
281 
282  page = (char *) __get_free_page(GFP_USER);
283  if (!page)
284  goto out;
285 
286  page2 = (char *) __get_free_page(GFP_USER);
287  if (!page2)
288  goto out;
289 
290  /* Ensure fs path is a prefix of current dentry path */
291  error = nfs4_validate_fspath(dentry, locations, page, page2);
292  if (error < 0) {
293  mnt = ERR_PTR(error);
294  goto out;
295  }
296 
297  for (loc = 0; loc < locations->nlocations; loc++) {
298  const struct nfs4_fs_location *location = &locations->locations[loc];
299 
300  if (location == NULL || location->nservers <= 0 ||
301  location->rootpath.ncomponents == 0)
302  continue;
303 
304  mnt = try_location(&mountdata, page, page2, location);
305  if (!IS_ERR(mnt))
306  break;
307  }
308 
309 out:
310  free_page((unsigned long) page);
311  free_page((unsigned long) page2);
312  dprintk("%s: done\n", __func__);
313  return mnt;
314 }
315 
316 /*
317  * nfs_do_refmount - handle crossing a referral on server
318  * @dentry - dentry of referral
319  *
320  */
321 static struct vfsmount *nfs_do_refmount(struct rpc_clnt *client, struct dentry *dentry)
322 {
323  struct vfsmount *mnt = ERR_PTR(-ENOMEM);
324  struct dentry *parent;
325  struct nfs4_fs_locations *fs_locations = NULL;
326  struct page *page;
327  int err;
328 
329  /* BUG_ON(IS_ROOT(dentry)); */
330  dprintk("%s: enter\n", __func__);
331 
332  page = alloc_page(GFP_KERNEL);
333  if (page == NULL)
334  goto out;
335 
336  fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
337  if (fs_locations == NULL)
338  goto out_free;
339 
340  /* Get locations */
341  mnt = ERR_PTR(-ENOENT);
342 
343  parent = dget_parent(dentry);
344  dprintk("%s: getting locations for %s/%s\n",
345  __func__, parent->d_name.name, dentry->d_name.name);
346 
347  err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page);
348  dput(parent);
349  if (err != 0 ||
350  fs_locations->nlocations <= 0 ||
351  fs_locations->fs_path.ncomponents <= 0)
352  goto out_free;
353 
354  mnt = nfs_follow_referral(dentry, fs_locations);
355 out_free:
356  __free_page(page);
357  kfree(fs_locations);
358 out:
359  dprintk("%s: done\n", __func__);
360  return mnt;
361 }
362 
363 struct vfsmount *nfs4_submount(struct nfs_server *server, struct dentry *dentry,
364  struct nfs_fh *fh, struct nfs_fattr *fattr)
365 {
366  struct dentry *parent = dget_parent(dentry);
367  struct rpc_clnt *client;
368  struct vfsmount *mnt;
369 
370  /* Look it up again to get its attributes and sec flavor */
371  client = nfs4_proc_lookup_mountpoint(parent->d_inode, &dentry->d_name, fh, fattr);
372  dput(parent);
373  if (IS_ERR(client))
374  return ERR_CAST(client);
375 
376  if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
377  mnt = nfs_do_refmount(client, dentry);
378  else
379  mnt = nfs_do_submount(dentry, fh, fattr, client->cl_auth->au_flavor);
380 
381  rpc_shutdown_client(client);
382  return mnt;
383 }