fs/cifs/cifs_dfs_ref.c

   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 LIST_HEAD(cifs_dfs_automount_list);
  27
  28 /*
  29  * DFS functions
  30 */
  31
  32 void 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  */
  50 static 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  */
 111 static char *compose_mount_options(const char *sb_mountdata,
 112                                    const char *ref_unc,
 113                                    char **devname)
 114 {
 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
 187 compose_mount_options_out:
 188         kfree(srvIP);
 189         return mountdata;
 190 }
 191
 192
 193 static struct vfsmount *cifs_dfs_do_refmount(const struct vfsmount *mnt_parent,
 194                 struct dentry *dentry, char *ref_unc)
 195 {
 196         struct cifs_sb_info *cifs_sb;
 197         struct vfsmount *mnt;
 198         char *mountdata;
 199         char *devname = NULL;
 200
 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
 215 static 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
 255 static 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
 283 static void dump_referral(const struct dfs_info3_param *ref)
 284 {
 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
 293 static void*
 294 cifs_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
 363 out:
 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);
 369 out_err:
 370         path_release(nd);
 371         goto out;
 372 }
 373
 374 struct inode_operations cifs_dfs_referral_inode_operations = {
 375         .follow_link = cifs_dfs_follow_mountpoint,
 376 };
 377