blob: 413ee2349d1af6f0ca24d53b17dc3b4941489f01 [file] [log] [blame]
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +00001/*
2 * Contains the CIFS DFS referral mounting routines used for handling
3 * traversal via DFS junction point
4 *
5 * Copyright (c) 2007 Igor Mammedov
Steve French366781c2008-01-25 10:12:41 +00006 * Copyright (C) International Business Machines Corp., 2008
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +00007 * Author(s): Igor Mammedov (niallain@gmail.com)
Steve French366781c2008-01-25 10:12:41 +00008 * Steve French (sfrench@us.ibm.com)
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +00009 * 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
26LIST_HEAD(cifs_dfs_automount_list);
27
28/*
29 * DFS functions
30*/
31
32void dfs_shrink_umount_helper(struct vfsmount *vfsmnt)
33{
34 mark_mounts_for_expiry(&cifs_dfs_automount_list);
35 mark_mounts_for_expiry(&cifs_dfs_automount_list);
36 shrink_submounts(vfsmnt, &cifs_dfs_automount_list);
37}
38
39/**
40 * cifs_get_share_name - extracts share name from UNC
41 * @node_name: pointer to UNC string
42 *
43 * Extracts sharename form full UNC.
44 * i.e. strips from UNC trailing path that is not part of share
45 * name and fixup missing '\' in the begining of DFS node refferal
46 * if neccessary.
47 * Returns pointer to share name on success or NULL on error.
48 * Caller is responsible for freeing returned string.
49 */
50static char *cifs_get_share_name(const char *node_name)
51{
52 int len;
53 char *UNC;
54 char *pSep;
55
56 len = strlen(node_name);
57 UNC = kmalloc(len+2 /*for term null and additional \ if it's missed */,
58 GFP_KERNEL);
59 if (!UNC)
60 return NULL;
61
62 /* get share name and server name */
63 if (node_name[1] != '\\') {
64 UNC[0] = '\\';
65 strncpy(UNC+1, node_name, len);
66 len++;
67 UNC[len] = 0;
68 } else {
69 strncpy(UNC, node_name, len);
70 UNC[len] = 0;
71 }
72
73 /* find server name end */
74 pSep = memchr(UNC+2, '\\', len-2);
75 if (!pSep) {
76 cERROR(1, ("%s: no server name end in node name: %s",
77 __FUNCTION__, node_name));
78 kfree(UNC);
79 return NULL;
80 }
81
82 /* find sharename end */
83 pSep++;
84 pSep = memchr(UNC+(pSep-UNC), '\\', len-(pSep-UNC));
85 if (!pSep) {
86 cERROR(1, ("%s:2 cant find share name in node name: %s",
87 __FUNCTION__, node_name));
88 kfree(UNC);
89 return NULL;
90 }
91 /* trim path up to sharename end
92 * * now we have share name in UNC */
93 *pSep = 0;
94
95 return UNC;
96}
97
98
99/**
100 * compose_mount_options - creates mount options for refferral
101 * @sb_mountdata: parent/root DFS mount options (template)
102 * @ref_unc: refferral server UNC
103 * @devname: pointer for saving device name
104 *
105 * creates mount options for submount based on template options sb_mountdata
106 * and replacing unc,ip,prefixpath options with ones we've got form ref_unc.
107 *
108 * Returns: pointer to new mount options or ERR_PTR.
109 * Caller is responcible for freeing retunrned value if it is not error.
110 */
Steve French366781c2008-01-25 10:12:41 +0000111static char *compose_mount_options(const char *sb_mountdata,
112 const char *ref_unc,
113 char **devname)
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +0000114{
115 int rc;
116 char *mountdata;
117 int md_len;
118 char *tkn_e;
119 char *srvIP = NULL;
120 char sep = ',';
121 int off, noff;
122
123 if (sb_mountdata == NULL)
124 return ERR_PTR(-EINVAL);
125
126 *devname = cifs_get_share_name(ref_unc);
127 rc = dns_resolve_server_name_to_ip(*devname, &srvIP);
128 if (rc != 0) {
129 cERROR(1, ("%s: Failed to resolve server part of %s to IP",
130 __FUNCTION__, *devname));
131 mountdata = ERR_PTR(rc);
132 goto compose_mount_options_out;
133 }
134 md_len = strlen(sb_mountdata) + strlen(srvIP) + strlen(ref_unc) + 3;
135 mountdata = kzalloc(md_len+1, GFP_KERNEL);
136 if (mountdata == NULL) {
137 mountdata = ERR_PTR(-ENOMEM);
138 goto compose_mount_options_out;
139 }
140
141 /* copy all options except of unc,ip,prefixpath */
142 off = 0;
143 if (strncmp(sb_mountdata, "sep=", 4) == 0) {
144 sep = sb_mountdata[4];
145 strncpy(mountdata, sb_mountdata, 5);
146 off += 5;
147 }
148 while ((tkn_e = strchr(sb_mountdata+off, sep))) {
149 noff = (tkn_e - (sb_mountdata+off)) + 1;
150 if (strnicmp(sb_mountdata+off, "unc=", 4) == 0) {
151 off += noff;
152 continue;
153 }
154 if (strnicmp(sb_mountdata+off, "ip=", 3) == 0) {
155 off += noff;
156 continue;
157 }
158 if (strnicmp(sb_mountdata+off, "prefixpath=", 3) == 0) {
159 off += noff;
160 continue;
161 }
162 strncat(mountdata, sb_mountdata+off, noff);
163 off += noff;
164 }
165 strcat(mountdata, sb_mountdata+off);
166 mountdata[md_len] = '\0';
167
168 /* copy new IP and ref share name */
169 strcat(mountdata, ",ip=");
170 strcat(mountdata, srvIP);
171 strcat(mountdata, ",unc=");
172 strcat(mountdata, *devname);
173
174 /* find & copy prefixpath */
175 tkn_e = strchr(ref_unc+2, '\\');
176 if (tkn_e) {
177 tkn_e = strchr(tkn_e+1, '\\');
178 if (tkn_e) {
179 strcat(mountdata, ",prefixpath=");
180 strcat(mountdata, tkn_e);
181 }
182 }
183
184 /*cFYI(1,("%s: parent mountdata: %s", __FUNCTION__,sb_mountdata));*/
185 /*cFYI(1, ("%s: submount mountdata: %s", __FUNCTION__, mountdata ));*/
186
187compose_mount_options_out:
188 kfree(srvIP);
189 return mountdata;
190}
191
192
Steve French366781c2008-01-25 10:12:41 +0000193static struct vfsmount *cifs_dfs_do_refmount(const struct vfsmount *mnt_parent,
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +0000194 struct dentry *dentry, char *ref_unc)
195{
196 struct cifs_sb_info *cifs_sb;
197 struct vfsmount *mnt;
198 char *mountdata;
Steve French366781c2008-01-25 10:12:41 +0000199 char *devname = NULL;
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +0000200
201 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
202 mountdata = compose_mount_options(cifs_sb->mountdata,
203 ref_unc, &devname);
204
205 if (IS_ERR(mountdata))
206 return (struct vfsmount *)mountdata;
207
208 mnt = vfs_kern_mount(&cifs_fs_type, 0, devname, mountdata);
209 kfree(mountdata);
210 kfree(devname);
211 return mnt;
212
213}
214
215static char *build_full_dfs_path_from_dentry(struct dentry *dentry)
216{
217 char *full_path = NULL;
218 char *search_path;
219 char *tmp_path;
220 size_t l_max_len;
221 struct cifs_sb_info *cifs_sb;
222
223 if (dentry->d_inode == NULL)
224 return NULL;
225
226 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
227
228 if (cifs_sb->tcon == NULL)
229 return NULL;
230
231 search_path = build_path_from_dentry(dentry);
232 if (search_path == NULL)
233 return NULL;
234
235 if (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS) {
236 /* we should use full path name to correct working with DFS */
237 l_max_len = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE+1) +
238 strnlen(search_path, MAX_PATHCONF) + 1;
239 tmp_path = kmalloc(l_max_len, GFP_KERNEL);
240 if (tmp_path == NULL) {
241 kfree(search_path);
242 return NULL;
243 }
244 strncpy(tmp_path, cifs_sb->tcon->treeName, l_max_len);
245 strcat(tmp_path, search_path);
246 tmp_path[l_max_len-1] = 0;
247 full_path = tmp_path;
248 kfree(search_path);
249 } else {
250 full_path = search_path;
251 }
252 return full_path;
253}
254
255static int add_mount_helper(struct vfsmount *newmnt, struct nameidata *nd,
256 struct list_head *mntlist)
257{
258 /* stolen from afs code */
259 int err;
260
261 mntget(newmnt);
262 err = do_add_mount(newmnt, nd, nd->mnt->mnt_flags, mntlist);
263 switch (err) {
264 case 0:
265 dput(nd->dentry);
266 mntput(nd->mnt);
267 nd->mnt = newmnt;
268 nd->dentry = dget(newmnt->mnt_root);
269 break;
270 case -EBUSY:
271 /* someone else made a mount here whilst we were busy */
272 while (d_mountpoint(nd->dentry) &&
273 follow_down(&nd->mnt, &nd->dentry))
274 ;
275 err = 0;
276 default:
277 mntput(newmnt);
278 break;
279 }
280 return err;
281}
282
Steve French366781c2008-01-25 10:12:41 +0000283static void dump_referral(const struct dfs_info3_param *ref)
Igor Mammedov6d5ae0d2008-01-25 03:28:31 +0000284{
285 cFYI(1, ("DFS: ref path: %s", ref->path_name));
286 cFYI(1, ("DFS: node path: %s", ref->node_name));
287 cFYI(1, ("DFS: fl: %hd, srv_type: %hd", ref->flags, ref->server_type));
288 cFYI(1, ("DFS: ref_flags: %hd, path_consumed: %hd", ref->ref_flag,
289 ref->PathConsumed));
290}
291
292
293static void*
294cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
295{
296 struct dfs_info3_param *referrals = NULL;
297 unsigned int num_referrals = 0;
298 struct cifs_sb_info *cifs_sb;
299 struct cifsSesInfo *ses;
300 char *full_path = NULL;
301 int xid, i;
302 int rc = 0;
303 struct vfsmount *mnt = ERR_PTR(-ENOENT);
304
305 cFYI(1, ("in %s", __FUNCTION__));
306 BUG_ON(IS_ROOT(dentry));
307
308 xid = GetXid();
309
310 dput(nd->dentry);
311 nd->dentry = dget(dentry);
312
313 cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
314 ses = cifs_sb->tcon->ses;
315
316 if (!ses) {
317 rc = -EINVAL;
318 goto out_err;
319 }
320
321 full_path = build_full_dfs_path_from_dentry(dentry);
322 if (full_path == NULL) {
323 rc = -ENOMEM;
324 goto out_err;
325 }
326
327 rc = get_dfs_path(xid, ses , full_path, cifs_sb->local_nls,
328 &num_referrals, &referrals,
329 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
330
331 for (i = 0; i < num_referrals; i++) {
332 dump_referral(referrals+i);
333 /* connect to a storage node */
334 if (referrals[i].flags & DFSREF_STORAGE_SERVER) {
335 int len;
336 len = strlen(referrals[i].node_name);
337 if (len < 2) {
338 cERROR(1, ("%s: Net Address path too short: %s",
339 __FUNCTION__, referrals[i].node_name));
340 rc = -EINVAL;
341 goto out_err;
342 }
343 mnt = cifs_dfs_do_refmount(nd->mnt, nd->dentry,
344 referrals[i].node_name);
345 cFYI(1, ("%s: cifs_dfs_do_refmount:%s , mnt:%p",
346 __FUNCTION__,
347 referrals[i].node_name, mnt));
348
349 /* complete mount procedure if we accured submount */
350 if (!IS_ERR(mnt))
351 break;
352 }
353 }
354
355 /* we need it cause for() above could exit without valid submount */
356 rc = PTR_ERR(mnt);
357 if (IS_ERR(mnt))
358 goto out_err;
359
360 nd->mnt->mnt_flags |= MNT_SHRINKABLE;
361 rc = add_mount_helper(mnt, nd, &cifs_dfs_automount_list);
362
363out:
364 FreeXid(xid);
365 free_dfs_info_array(referrals, num_referrals);
366 kfree(full_path);
367 cFYI(1, ("leaving %s" , __FUNCTION__));
368 return ERR_PTR(rc);
369out_err:
370 path_release(nd);
371 goto out;
372}
373
374struct inode_operations cifs_dfs_referral_inode_operations = {
375 .follow_link = cifs_dfs_follow_mountpoint,
376};
377