1
2
3
4
5
6
7
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
27
28
29
30static 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;
50Elong:
51 return ERR_PTR(-ENAMETOOLONG);
52}
53
54
55
56
57static char *nfs4_path(struct dentry *dentry, char *buffer, ssize_t buflen)
58{
59 char *limit;
60 char *path = nfs_path(&limit, dentry, buffer, buflen);
61 if (!IS_ERR(path)) {
62 char *colon = strchr(path, ':');
63 if (colon && colon < limit)
64 path = colon + 1;
65 }
66 return path;
67}
68
69
70
71
72
73static int nfs4_validate_fspath(struct dentry *dentry,
74 const struct nfs4_fs_locations *locations,
75 char *page, char *page2)
76{
77 const char *path, *fs_path;
78
79 path = nfs4_path(dentry, page, PAGE_SIZE);
80 if (IS_ERR(path))
81 return PTR_ERR(path);
82
83 fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
84 if (IS_ERR(fs_path))
85 return PTR_ERR(fs_path);
86
87 if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
88 dprintk("%s: path %s does not begin with fsroot %s\n",
89 __func__, path, fs_path);
90 return -ENOENT;
91 }
92
93 return 0;
94}
95
96static size_t nfs_parse_server_name(char *string, size_t len,
97 struct sockaddr *sa, size_t salen)
98{
99 ssize_t ret;
100
101 ret = rpc_pton(string, len, sa, salen);
102 if (ret == 0) {
103 ret = nfs_dns_resolve_name(string, len, sa, salen);
104 if (ret < 0)
105 ret = 0;
106 }
107 return ret;
108}
109
110static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
111 char *page, char *page2,
112 const struct nfs4_fs_location *location)
113{
114 const size_t addr_bufsize = sizeof(struct sockaddr_storage);
115 struct vfsmount *mnt = ERR_PTR(-ENOENT);
116 char *mnt_path;
117 unsigned int maxbuflen;
118 unsigned int s;
119
120 mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
121 if (IS_ERR(mnt_path))
122 return ERR_CAST(mnt_path);
123 mountdata->mnt_path = mnt_path;
124 maxbuflen = mnt_path - 1 - page2;
125
126 mountdata->addr = kmalloc(addr_bufsize, GFP_KERNEL);
127 if (mountdata->addr == NULL)
128 return ERR_PTR(-ENOMEM);
129
130 for (s = 0; s < location->nservers; s++) {
131 const struct nfs4_string *buf = &location->servers[s];
132
133 if (buf->len <= 0 || buf->len >= maxbuflen)
134 continue;
135
136 if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
137 continue;
138
139 mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
140 mountdata->addr, addr_bufsize);
141 if (mountdata->addrlen == 0)
142 continue;
143
144 rpc_set_port(mountdata->addr, NFS_PORT);
145
146 memcpy(page2, buf->data, buf->len);
147 page2[buf->len] = '\0';
148 mountdata->hostname = page2;
149
150 snprintf(page, PAGE_SIZE, "%s:%s",
151 mountdata->hostname,
152 mountdata->mnt_path);
153
154 mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, mountdata);
155 if (!IS_ERR(mnt))
156 break;
157 }
158 kfree(mountdata->addr);
159 return mnt;
160}
161
162
163
164
165
166
167
168static struct vfsmount *nfs_follow_referral(struct dentry *dentry,
169 const struct nfs4_fs_locations *locations)
170{
171 struct vfsmount *mnt = ERR_PTR(-ENOENT);
172 struct nfs_clone_mount mountdata = {
173 .sb = dentry->d_sb,
174 .dentry = dentry,
175 .authflavor = NFS_SB(dentry->d_sb)->client->cl_auth->au_flavor,
176 };
177 char *page = NULL, *page2 = NULL;
178 int loc, error;
179
180 if (locations == NULL || locations->nlocations <= 0)
181 goto out;
182
183 dprintk("%s: referral at %s/%s\n", __func__,
184 dentry->d_parent->d_name.name, dentry->d_name.name);
185
186 page = (char *) __get_free_page(GFP_USER);
187 if (!page)
188 goto out;
189
190 page2 = (char *) __get_free_page(GFP_USER);
191 if (!page2)
192 goto out;
193
194
195 error = nfs4_validate_fspath(dentry, locations, page, page2);
196 if (error < 0) {
197 mnt = ERR_PTR(error);
198 goto out;
199 }
200
201 for (loc = 0; loc < locations->nlocations; loc++) {
202 const struct nfs4_fs_location *location = &locations->locations[loc];
203
204 if (location == NULL || location->nservers <= 0 ||
205 location->rootpath.ncomponents == 0)
206 continue;
207
208 mnt = try_location(&mountdata, page, page2, location);
209 if (!IS_ERR(mnt))
210 break;
211 }
212
213out:
214 free_page((unsigned long) page);
215 free_page((unsigned long) page2);
216 dprintk("%s: done\n", __func__);
217 return mnt;
218}
219
220
221
222
223
224
225struct vfsmount *nfs_do_refmount(struct dentry *dentry)
226{
227 struct vfsmount *mnt = ERR_PTR(-ENOMEM);
228 struct dentry *parent;
229 struct nfs4_fs_locations *fs_locations = NULL;
230 struct page *page;
231 int err;
232
233
234 dprintk("%s: enter\n", __func__);
235
236 page = alloc_page(GFP_KERNEL);
237 if (page == NULL)
238 goto out;
239
240 fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
241 if (fs_locations == NULL)
242 goto out_free;
243
244
245 mnt = ERR_PTR(-ENOENT);
246
247 parent = dget_parent(dentry);
248 dprintk("%s: getting locations for %s/%s\n",
249 __func__, parent->d_name.name, dentry->d_name.name);
250
251 err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page);
252 dput(parent);
253 if (err != 0 ||
254 fs_locations->nlocations <= 0 ||
255 fs_locations->fs_path.ncomponents <= 0)
256 goto out_free;
257
258 mnt = nfs_follow_referral(dentry, fs_locations);
259out_free:
260 __free_page(page);
261 kfree(fs_locations);
262out:
263 dprintk("%s: done\n", __func__);
264 return mnt;
265}
266
