1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/dcache.h>
16#include <linux/mount.h>
17#include <linux/namei.h>
18#include <linux/vfs.h>
19#include <linux/fs.h>
20#include "cifsglob.h"
21#include "cifsproto.h"
22#include "cifsfs.h"
23#include "dns_resolve.h"
24#include "cifs_debug.h"
25
26static LIST_HEAD(cifs_dfs_automount_list);
27
28static void cifs_dfs_expire_automounts(struct work_struct *work);
29static DECLARE_DELAYED_WORK(cifs_dfs_automount_task,
30 cifs_dfs_expire_automounts);
31static int cifs_dfs_mountpoint_expiry_timeout = 500 * HZ;
32
33static void cifs_dfs_expire_automounts(struct work_struct *work)
34{
35 struct list_head *list = &cifs_dfs_automount_list;
36
37 mark_mounts_for_expiry(list);
38 if (!list_empty(list))
39 schedule_delayed_work(&cifs_dfs_automount_task,
40 cifs_dfs_mountpoint_expiry_timeout);
41}
42
43void cifs_dfs_release_automount_timer(void)
44{
45 BUG_ON(!list_empty(&cifs_dfs_automount_list));
46 cancel_delayed_work(&cifs_dfs_automount_task);
47 flush_scheduled_work();
48}
49
50
51
52
53
54
55
56
57
58
59
60
61static char *cifs_get_share_name(const char *node_name)
62{
63 int len;
64 char *UNC;
65 char *pSep;
66
67 len = strlen(node_name);
68 UNC = kmalloc(len+2 ,
69 GFP_KERNEL);
70 if (!UNC)
71 return ERR_PTR(-ENOMEM);
72
73
74 if (node_name[1] != '\\') {
75 UNC[0] = '\\';
76 strncpy(UNC+1, node_name, len);
77 len++;
78 UNC[len] = 0;
79 } else {
80 strncpy(UNC, node_name, len);
81 UNC[len] = 0;
82 }
83
84
85 pSep = memchr(UNC+2, '\\', len-2);
86 if (!pSep) {
87 cERROR(1, ("%s: no server name end in node name: %s",
88 __func__, node_name));
89 kfree(UNC);
90 return ERR_PTR(-EINVAL);
91 }
92
93
94 pSep++;
95 pSep = memchr(UNC+(pSep-UNC), '\\', len-(pSep-UNC));
96 if (pSep) {
97
98
99 *pSep = 0;
100 }
101
102 return UNC;
103}
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119char *cifs_compose_mount_options(const char *sb_mountdata,
120 const char *fullpath,
121 const struct dfs_info3_param *ref,
122 char **devname)
123{
124 int rc;
125 char *mountdata = NULL;
126 int md_len;
127 char *tkn_e;
128 char *srvIP = NULL;
129 char sep = ',';
130 int off, noff;
131
132 if (sb_mountdata == NULL)
133 return ERR_PTR(-EINVAL);
134
135 *devname = cifs_get_share_name(ref->node_name);
136 if (IS_ERR(*devname)) {
137 rc = PTR_ERR(*devname);
138 *devname = NULL;
139 goto compose_mount_options_err;
140 }
141
142 rc = dns_resolve_server_name_to_ip(*devname, &srvIP);
143 if (rc != 0) {
144 cERROR(1, ("%s: Failed to resolve server part of %s to IP: %d",
145 __func__, *devname, rc));
146 goto compose_mount_options_err;
147 }
148
149
150
151
152 md_len = strlen(sb_mountdata) + strlen(srvIP) +
153 strlen(ref->node_name) + 12;
154 mountdata = kzalloc(md_len+1, GFP_KERNEL);
155 if (mountdata == NULL) {
156 rc = -ENOMEM;
157 goto compose_mount_options_err;
158 }
159
160
161 off = 0;
162 if (strncmp(sb_mountdata, "sep=", 4) == 0) {
163 sep = sb_mountdata[4];
164 strncpy(mountdata, sb_mountdata, 5);
165 off += 5;
166 }
167
168 do {
169 tkn_e = strchr(sb_mountdata + off, sep);
170 if (tkn_e == NULL)
171 noff = strlen(sb_mountdata + off);
172 else
173 noff = tkn_e - (sb_mountdata + off) + 1;
174
175 if (strnicmp(sb_mountdata + off, "unc=", 4) == 0) {
176 off += noff;
177 continue;
178 }
179 if (strnicmp(sb_mountdata + off, "ip=", 3) == 0) {
180 off += noff;
181 continue;
182 }
183 if (strnicmp(sb_mountdata + off, "prefixpath=", 11) == 0) {
184 off += noff;
185 continue;
186 }
187 strncat(mountdata, sb_mountdata + off, noff);
188 off += noff;
189 } while (tkn_e);
190 strcat(mountdata, sb_mountdata + off);
191 mountdata[md_len] = '\0';
192
193
194 if (mountdata[strlen(mountdata) - 1] != sep)
195 strncat(mountdata, &sep, 1);
196 strcat(mountdata, "ip=");
197 strcat(mountdata, srvIP);
198 strncat(mountdata, &sep, 1);
199 strcat(mountdata, "unc=");
200 strcat(mountdata, *devname);
201
202
203 tkn_e = strchr(ref->node_name + 2, '\\');
204 if (tkn_e == NULL) {
205
206 rc = -EINVAL;
207 goto compose_mount_options_err;
208 }
209
210 tkn_e = strchr(tkn_e + 1, '\\');
211 if (tkn_e || (strlen(fullpath) - ref->path_consumed)) {
212 strncat(mountdata, &sep, 1);
213 strcat(mountdata, "prefixpath=");
214 if (tkn_e)
215 strcat(mountdata, tkn_e + 1);
216 strcat(mountdata, fullpath + ref->path_consumed);
217 }
218
219
220
221
222compose_mount_options_out:
223 kfree(srvIP);
224 return mountdata;
225
226compose_mount_options_err:
227 kfree(mountdata);
228 mountdata = ERR_PTR(rc);
229 goto compose_mount_options_out;
230}
231
232
233static struct vfsmount *cifs_dfs_do_refmount(const struct vfsmount *mnt_parent,
234 struct dentry *dentry, const struct dfs_info3_param *ref)
235{
236 struct cifs_sb_info *cifs_sb;
237 struct vfsmount *mnt;
238 char *mountdata;
239 char *devname = NULL;
240 char *fullpath;
241
242 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
243
244
245
246
247 fullpath = build_path_from_dentry(dentry);
248 if (!fullpath)
249 return ERR_PTR(-ENOMEM);
250
251 mountdata = cifs_compose_mount_options(cifs_sb->mountdata,
252 fullpath + 1, ref, &devname);
253 kfree(fullpath);
254
255 if (IS_ERR(mountdata))
256 return (struct vfsmount *)mountdata;
257
258 mnt = vfs_kern_mount(&cifs_fs_type, 0, devname, mountdata);
259 kfree(mountdata);
260 kfree(devname);
261 return mnt;
262
263}
264
265static int add_mount_helper(struct vfsmount *newmnt, struct nameidata *nd,
266 struct list_head *mntlist)
267{
268
269 int err;
270
271 mntget(newmnt);
272 err = do_add_mount(newmnt, &nd->path, nd->path.mnt->mnt_flags, mntlist);
273 switch (err) {
274 case 0:
275 path_put(&nd->path);
276 nd->path.mnt = newmnt;
277 nd->path.dentry = dget(newmnt->mnt_root);
278 schedule_delayed_work(&cifs_dfs_automount_task,
279 cifs_dfs_mountpoint_expiry_timeout);
280 break;
281 case -EBUSY:
282
283 while (d_mountpoint(nd->path.dentry) &&
284 follow_down(&nd->path))
285 ;
286 err = 0;
287 default:
288 mntput(newmnt);
289 break;
290 }
291 return err;
292}
293
294static void dump_referral(const struct dfs_info3_param *ref)
295{
296 cFYI(1, ("DFS: ref path: %s", ref->path_name));
297 cFYI(1, ("DFS: node path: %s", ref->node_name));
298 cFYI(1, ("DFS: fl: %hd, srv_type: %hd", ref->flags, ref->server_type));
299 cFYI(1, ("DFS: ref_flags: %hd, path_consumed: %hd", ref->ref_flag,
300 ref->path_consumed));
301}
302
303
304static void*
305cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
306{
307 struct dfs_info3_param *referrals = NULL;
308 unsigned int num_referrals = 0;
309 struct cifs_sb_info *cifs_sb;
310 struct cifsSesInfo *ses;
311 char *full_path = NULL;
312 int xid, i;
313 int rc = 0;
314 struct vfsmount *mnt = ERR_PTR(-ENOENT);
315
316 cFYI(1, ("in %s", __func__));
317 BUG_ON(IS_ROOT(dentry));
318
319 xid = GetXid();
320
321 dput(nd->path.dentry);
322 nd->path.dentry = dget(dentry);
323
324 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
325 ses = cifs_sb->tcon->ses;
326
327 if (!ses) {
328 rc = -EINVAL;
329 goto out_err;
330 }
331
332
333
334
335
336
337
338 full_path = build_path_from_dentry(dentry);
339 if (full_path == NULL) {
340 rc = -ENOMEM;
341 goto out_err;
342 }
343
344 rc = get_dfs_path(xid, ses , full_path + 1, cifs_sb->local_nls,
345 &num_referrals, &referrals,
346 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
347
348 for (i = 0; i < num_referrals; i++) {
349 int len;
350 dump_referral(referrals+i);
351
352 len = strlen(referrals[i].node_name);
353 if (len < 2) {
354 cERROR(1, ("%s: Net Address path too short: %s",
355 __func__, referrals[i].node_name));
356 rc = -EINVAL;
357 goto out_err;
358 }
359 mnt = cifs_dfs_do_refmount(nd->path.mnt,
360 nd->path.dentry, referrals + i);
361 cFYI(1, ("%s: cifs_dfs_do_refmount:%s , mnt:%p", __func__,
362 referrals[i].node_name, mnt));
363
364
365 if (!IS_ERR(mnt))
366 break;
367 }
368
369
370 rc = PTR_ERR(mnt);
371 if (IS_ERR(mnt))
372 goto out_err;
373
374 nd->path.mnt->mnt_flags |= MNT_SHRINKABLE;
375 rc = add_mount_helper(mnt, nd, &cifs_dfs_automount_list);
376
377out:
378 FreeXid(xid);
379 free_dfs_info_array(referrals, num_referrals);
380 kfree(full_path);
381 cFYI(1, ("leaving %s" , __func__));
382 return ERR_PTR(rc);
383out_err:
384 path_put(&nd->path);
385 goto out;
386}
387
388const struct inode_operations cifs_dfs_referral_inode_operations = {
389 .follow_link = cifs_dfs_follow_mountpoint,
390};
391
392