1 /*
2 * Contains the CIFS DFS referral mounting routines used for handling
3 * traversal via DFS junction point
4 *
5 * Copyright (c) 2007 Igor Mammedov
6 * Copyright (C) International Business Machines Corp., 2008
7 * Author(s): Igor Mammedov (niallain@gmail.com)
8 * Steve French (sfrench@us.ibm.com)
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
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
26 static LIST_HEAD(cifs_dfs_automount_list);
27
28 static void cifs_dfs_expire_automounts(struct work_struct *work);
29 static DECLARE_DELAYED_WORK(cifs_dfs_automount_task,
30 cifs_dfs_expire_automounts);
31 static int cifs_dfs_mountpoint_expiry_timeout = 500 * HZ;
32
cifs_dfs_expire_automounts(struct work_struct * work)33 static 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
cifs_dfs_release_automount_timer(void)43 void 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 * cifs_get_share_name - extracts share name from UNC
52 * @node_name: pointer to UNC string
53 *
54 * Extracts sharename form full UNC.
55 * i.e. strips from UNC trailing path that is not part of share
56 * name and fixup missing '\' in the begining of DFS node refferal
57 * if neccessary.
58 * Returns pointer to share name on success or NULL on error.
59 * Caller is responsible for freeing returned string.
60 */
cifs_get_share_name(const char * node_name)61 static 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 /*for term null and additional \ if it's missed */,
69 GFP_KERNEL);
70 if (!UNC)
71 return NULL;
72
73 /* get share name and server name */
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 /* find server name end */
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 NULL;
91 }
92
93 /* find sharename end */
94 pSep++;
95 pSep = memchr(UNC+(pSep-UNC), '\\', len-(pSep-UNC));
96 if (pSep) {
97 /* trim path up to sharename end
98 * now we have share name in UNC */
99 *pSep = 0;
100 }
101
102 return UNC;
103 }
104
105
106 /**
107 * compose_mount_options - creates mount options for refferral
108 * @sb_mountdata: parent/root DFS mount options (template)
109 * @dentry: point where we are going to mount
110 * @ref: server's referral
111 * @devname: pointer for saving device name
112 *
113 * creates mount options for submount based on template options sb_mountdata
114 * and replacing unc,ip,prefixpath options with ones we've got form ref_unc.
115 *
116 * Returns: pointer to new mount options or ERR_PTR.
117 * Caller is responcible for freeing retunrned value if it is not error.
118 */
compose_mount_options(const char * sb_mountdata,struct dentry * dentry,const struct dfs_info3_param * ref,char ** devname)119 static char *compose_mount_options(const char *sb_mountdata,
120 struct dentry *dentry,
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 char *fullpath;
132
133 if (sb_mountdata == NULL)
134 return ERR_PTR(-EINVAL);
135
136 *devname = cifs_get_share_name(ref->node_name);
137 rc = dns_resolve_server_name_to_ip(*devname, &srvIP);
138 if (rc != 0) {
139 cERROR(1, ("%s: Failed to resolve server part of %s to IP: %d",
140 __func__, *devname, rc));;
141 goto compose_mount_options_err;
142 }
143 /* md_len = strlen(...) + 12 for 'sep+prefixpath='
144 * assuming that we have 'unc=' and 'ip=' in
145 * the original sb_mountdata
146 */
147 md_len = strlen(sb_mountdata) + strlen(srvIP) +
148 strlen(ref->node_name) + 12;
149 mountdata = kzalloc(md_len+1, GFP_KERNEL);
150 if (mountdata == NULL) {
151 rc = -ENOMEM;
152 goto compose_mount_options_err;
153 }
154
155 /* copy all options except of unc,ip,prefixpath */
156 off = 0;
157 if (strncmp(sb_mountdata, "sep=", 4) == 0) {
158 sep = sb_mountdata[4];
159 strncpy(mountdata, sb_mountdata, 5);
160 off += 5;
161 }
162
163 do {
164 tkn_e = strchr(sb_mountdata + off, sep);
165 if (tkn_e == NULL)
166 noff = strlen(sb_mountdata + off);
167 else
168 noff = tkn_e - (sb_mountdata + off) + 1;
169
170 if (strnicmp(sb_mountdata + off, "unc=", 4) == 0) {
171 off += noff;
172 continue;
173 }
174 if (strnicmp(sb_mountdata + off, "ip=", 3) == 0) {
175 off += noff;
176 continue;
177 }
178 if (strnicmp(sb_mountdata + off, "prefixpath=", 11) == 0) {
179 off += noff;
180 continue;
181 }
182 strncat(mountdata, sb_mountdata + off, noff);
183 off += noff;
184 } while (tkn_e);
185 strcat(mountdata, sb_mountdata + off);
186 mountdata[md_len] = '\0';
187
188 /* copy new IP and ref share name */
189 if (mountdata[strlen(mountdata) - 1] != sep)
190 strncat(mountdata, &sep, 1);
191 strcat(mountdata, "ip=");
192 strcat(mountdata, srvIP);
193 strncat(mountdata, &sep, 1);
194 strcat(mountdata, "unc=");
195 strcat(mountdata, *devname);
196
197 /* find & copy prefixpath */
198 tkn_e = strchr(ref->node_name + 2, '\\');
199 if (tkn_e == NULL) {
200 /* invalid unc, missing share name*/
201 rc = -EINVAL;
202 goto compose_mount_options_err;
203 }
204
205 /*
206 * this function gives us a path with a double backslash prefix. We
207 * require a single backslash for DFS. Temporarily increment fullpath
208 * to put it in the proper form and decrement before freeing it.
209 */
210 fullpath = build_path_from_dentry(dentry);
211 if (!fullpath) {
212 rc = -ENOMEM;
213 goto compose_mount_options_err;
214 }
215 ++fullpath;
216 tkn_e = strchr(tkn_e + 1, '\\');
217 if (tkn_e || (strlen(fullpath) - ref->path_consumed)) {
218 strncat(mountdata, &sep, 1);
219 strcat(mountdata, "prefixpath=");
220 if (tkn_e)
221 strcat(mountdata, tkn_e + 1);
222 strcat(mountdata, fullpath + ref->path_consumed);
223 }
224 --fullpath;
225 kfree(fullpath);
226
227 /*cFYI(1,("%s: parent mountdata: %s", __func__,sb_mountdata));*/
228 /*cFYI(1, ("%s: submount mountdata: %s", __func__, mountdata ));*/
229
230 compose_mount_options_out:
231 kfree(srvIP);
232 return mountdata;
233
234 compose_mount_options_err:
235 kfree(mountdata);
236 mountdata = ERR_PTR(rc);
237 goto compose_mount_options_out;
238 }
239
240
cifs_dfs_do_refmount(const struct vfsmount * mnt_parent,struct dentry * dentry,const struct dfs_info3_param * ref)241 static struct vfsmount *cifs_dfs_do_refmount(const struct vfsmount *mnt_parent,
242 struct dentry *dentry, const struct dfs_info3_param *ref)
243 {
244 struct cifs_sb_info *cifs_sb;
245 struct vfsmount *mnt;
246 char *mountdata;
247 char *devname = NULL;
248
249 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
250 mountdata = compose_mount_options(cifs_sb->mountdata,
251 dentry, ref, &devname);
252
253 if (IS_ERR(mountdata))
254 return (struct vfsmount *)mountdata;
255
256 mnt = vfs_kern_mount(&cifs_fs_type, 0, devname, mountdata);
257 kfree(mountdata);
258 kfree(devname);
259 return mnt;
260
261 }
262
add_mount_helper(struct vfsmount * newmnt,struct nameidata * nd,struct list_head * mntlist)263 static int add_mount_helper(struct vfsmount *newmnt, struct nameidata *nd,
264 struct list_head *mntlist)
265 {
266 /* stolen from afs code */
267 int err;
268
269 mntget(newmnt);
270 err = do_add_mount(newmnt, &nd->path, nd->path.mnt->mnt_flags, mntlist);
271 switch (err) {
272 case 0:
273 path_put(&nd->path);
274 nd->path.mnt = newmnt;
275 nd->path.dentry = dget(newmnt->mnt_root);
276 schedule_delayed_work(&cifs_dfs_automount_task,
277 cifs_dfs_mountpoint_expiry_timeout);
278 break;
279 case -EBUSY:
280 /* someone else made a mount here whilst we were busy */
281 while (d_mountpoint(nd->path.dentry) &&
282 follow_down(&nd->path.mnt, &nd->path.dentry))
283 ;
284 err = 0;
285 default:
286 mntput(newmnt);
287 break;
288 }
289 return err;
290 }
291
dump_referral(const struct dfs_info3_param * ref)292 static void dump_referral(const struct dfs_info3_param *ref)
293 {
294 cFYI(1, ("DFS: ref path: %s", ref->path_name));
295 cFYI(1, ("DFS: node path: %s", ref->node_name));
296 cFYI(1, ("DFS: fl: %hd, srv_type: %hd", ref->flags, ref->server_type));
297 cFYI(1, ("DFS: ref_flags: %hd, path_consumed: %hd", ref->ref_flag,
298 ref->path_consumed));
299 }
300
301
302 static void*
cifs_dfs_follow_mountpoint(struct dentry * dentry,struct nameidata * nd)303 cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
304 {
305 struct dfs_info3_param *referrals = NULL;
306 unsigned int num_referrals = 0;
307 struct cifs_sb_info *cifs_sb;
308 struct cifsSesInfo *ses;
309 char *full_path = NULL;
310 int xid, i;
311 int rc = 0;
312 struct vfsmount *mnt = ERR_PTR(-ENOENT);
313
314 cFYI(1, ("in %s", __func__));
315 BUG_ON(IS_ROOT(dentry));
316
317 xid = GetXid();
318
319 dput(nd->path.dentry);
320 nd->path.dentry = dget(dentry);
321
322 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
323 ses = cifs_sb->tcon->ses;
324
325 if (!ses) {
326 rc = -EINVAL;
327 goto out_err;
328 }
329
330 /*
331 * The MSDFS spec states that paths in DFS referral requests and
332 * responses must be prefixed by a single '\' character instead of
333 * the double backslashes usually used in the UNC. This function
334 * gives us the latter, so we must adjust the result.
335 */
336 full_path = build_path_from_dentry(dentry);
337 if (full_path == NULL) {
338 rc = -ENOMEM;
339 goto out_err;
340 }
341
342 rc = get_dfs_path(xid, ses , full_path + 1, cifs_sb->local_nls,
343 &num_referrals, &referrals,
344 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
345
346 for (i = 0; i < num_referrals; i++) {
347 dump_referral(referrals+i);
348 /* connect to a storage node */
349 if (referrals[i].flags & DFSREF_STORAGE_SERVER) {
350 int len;
351 len = strlen(referrals[i].node_name);
352 if (len < 2) {
353 cERROR(1, ("%s: Net Address path too short: %s",
354 __func__, referrals[i].node_name));
355 rc = -EINVAL;
356 goto out_err;
357 }
358 mnt = cifs_dfs_do_refmount(nd->path.mnt,
359 nd->path.dentry,
360 referrals + i);
361 cFYI(1, ("%s: cifs_dfs_do_refmount:%s , mnt:%p",
362 __func__,
363 referrals[i].node_name, mnt));
364
365 /* complete mount procedure if we accured submount */
366 if (!IS_ERR(mnt))
367 break;
368 }
369 }
370
371 /* we need it cause for() above could exit without valid submount */
372 rc = PTR_ERR(mnt);
373 if (IS_ERR(mnt))
374 goto out_err;
375
376 nd->path.mnt->mnt_flags |= MNT_SHRINKABLE;
377 rc = add_mount_helper(mnt, nd, &cifs_dfs_automount_list);
378
379 out:
380 FreeXid(xid);
381 free_dfs_info_array(referrals, num_referrals);
382 kfree(full_path);
383 cFYI(1, ("leaving %s" , __func__));
384 return ERR_PTR(rc);
385 out_err:
386 path_put(&nd->path);
387 goto out;
388 }
389
390 struct inode_operations cifs_dfs_referral_inode_operations = {
391 .follow_link = cifs_dfs_follow_mountpoint,
392 };
393
394