fs/cifs/link.c

   1 /*
   2  *   fs/cifs/link.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2008
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/stat.h>
  23 #include <linux/slab.h>
  24 #include <linux/namei.h>
  25 #include "cifsfs.h"
  26 #include "cifspdu.h"
  27 #include "cifsglob.h"
  28 #include "cifsproto.h"
  29 #include "cifs_debug.h"
  30 #include "cifs_fs_sb.h"
  31 #include "md5.h"
  32
  33 #define CIFS_MF_SYMLINK_LEN_OFFSET (4+1)
  34 #define CIFS_MF_SYMLINK_MD5_OFFSET (CIFS_MF_SYMLINK_LEN_OFFSET+(4+1))
  35 #define CIFS_MF_SYMLINK_LINK_OFFSET (CIFS_MF_SYMLINK_MD5_OFFSET+(32+1))
  36 #define CIFS_MF_SYMLINK_LINK_MAXLEN (1024)
  37 #define CIFS_MF_SYMLINK_FILE_SIZE \
  38         (CIFS_MF_SYMLINK_LINK_OFFSET + CIFS_MF_SYMLINK_LINK_MAXLEN)
  39
  40 #define CIFS_MF_SYMLINK_LEN_FORMAT "XSym\n%04u\n"
  41 #define CIFS_MF_SYMLINK_MD5_FORMAT \
  42         "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n"
  43 #define CIFS_MF_SYMLINK_MD5_ARGS(md5_hash) \
  44         md5_hash[0],  md5_hash[1],  md5_hash[2],  md5_hash[3], \
  45         md5_hash[4],  md5_hash[5],  md5_hash[6],  md5_hash[7], \
  46         md5_hash[8],  md5_hash[9],  md5_hash[10], md5_hash[11],\
  47         md5_hash[12], md5_hash[13], md5_hash[14], md5_hash[15]
  48
  49 static int
  50 CIFSParseMFSymlink(const u8 *buf,
  51                    unsigned int buf_len,
  52                    unsigned int *_link_len,
  53                    char **_link_str)
  54 {
  55         int rc;
  56         unsigned int link_len;
  57         const char *md5_str1;
  58         const char *link_str;
  59         struct MD5Context md5_ctx;
  60         u8 md5_hash[16];
  61         char md5_str2[34];
  62
  63         if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
  64                 return -EINVAL;
  65
  66         md5_str1 = (const char *)&buf[CIFS_MF_SYMLINK_MD5_OFFSET];
  67         link_str = (const char *)&buf[CIFS_MF_SYMLINK_LINK_OFFSET];
  68
  69         rc = sscanf(buf, CIFS_MF_SYMLINK_LEN_FORMAT, &link_len);
  70         if (rc != 1)
  71                 return -EINVAL;
  72
  73         cifs_MD5_init(&md5_ctx);
  74         cifs_MD5_update(&md5_ctx, (const u8 *)link_str, link_len);
  75         cifs_MD5_final(md5_hash, &md5_ctx);
  76
  77         snprintf(md5_str2, sizeof(md5_str2),
  78                  CIFS_MF_SYMLINK_MD5_FORMAT,
  79                  CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
  80
  81         if (strncmp(md5_str1, md5_str2, 17) != 0)
  82                 return -EINVAL;
  83
  84         if (_link_str) {
  85                 *_link_str = kstrndup(link_str, link_len, GFP_KERNEL);
  86                 if (!*_link_str)
  87                         return -ENOMEM;
  88         }
  89
  90         *_link_len = link_len;
  91         return 0;
  92 }
  93
  94 static int
  95 CIFSQueryMFSymLink(const int xid, struct cifsTconInfo *tcon,
  96                    const unsigned char *searchName, char **symlinkinfo,
  97                    const struct nls_table *nls_codepage, int remap)
  98 {
  99         int rc;
 100         int oplock = 0;
 101         __u16 netfid = 0;
 102         u8 *buf;
 103         char *pbuf;
 104         unsigned int bytes_read = 0;
 105         int buf_type = CIFS_NO_BUFFER;
 106         unsigned int link_len = 0;
 107         FILE_ALL_INFO file_info;
 108
 109         rc = CIFSSMBOpen(xid, tcon, searchName, FILE_OPEN, GENERIC_READ,
 110                          CREATE_NOT_DIR, &netfid, &oplock, &file_info,
 111                          nls_codepage, remap);
 112         if (rc != 0)
 113                 return rc;
 114
 115         if (file_info.EndOfFile != CIFS_MF_SYMLINK_FILE_SIZE) {
 116                 CIFSSMBClose(xid, tcon, netfid);
 117                 /* it's not a symlink */
 118                 return -EINVAL;
 119         }
 120
 121         buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
 122         if (!buf)
 123                 return -ENOMEM;
 124         pbuf = buf;
 125
 126         rc = CIFSSMBRead(xid, tcon, netfid,
 127                          CIFS_MF_SYMLINK_FILE_SIZE /* length */,
 128                          0 /* offset */,
 129                          &bytes_read, &pbuf, &buf_type);
 130         CIFSSMBClose(xid, tcon, netfid);
 131         if (rc != 0) {
 132                 kfree(buf);
 133                 return rc;
 134         }
 135
 136         rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, symlinkinfo);
 137         kfree(buf);
 138         if (rc != 0)
 139                 return rc;
 140
 141         return 0;
 142 }
 143
 144 bool
 145 CIFSCouldBeMFSymlink(const struct cifs_fattr *fattr)
 146 {
 147         if (!(fattr->cf_mode & S_IFREG))
 148                 /* it's not a symlink */
 149                 return false;
 150
 151         if (fattr->cf_eof != CIFS_MF_SYMLINK_FILE_SIZE)
 152                 /* it's not a symlink */
 153                 return false;
 154
 155         return true;
 156 }
 157
 158 int
 159 CIFSCheckMFSymlink(struct cifs_fattr *fattr,
 160                    const unsigned char *path,
 161                    struct cifs_sb_info *cifs_sb, int xid)
 162 {
 163         int rc;
 164         int oplock = 0;
 165         __u16 netfid = 0;
 166         struct cifsTconInfo *pTcon = cifs_sb->tcon;
 167         u8 *buf;
 168         char *pbuf;
 169         unsigned int bytes_read = 0;
 170         int buf_type = CIFS_NO_BUFFER;
 171         unsigned int link_len = 0;
 172         FILE_ALL_INFO file_info;
 173
 174         if (!CIFSCouldBeMFSymlink(fattr))
 175                 /* it's not a symlink */
 176                 return 0;
 177
 178         rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
 179                          CREATE_NOT_DIR, &netfid, &oplock, &file_info,
 180                          cifs_sb->local_nls,
 181                          cifs_sb->mnt_cifs_flags &
 182                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 183         if (rc != 0)
 184                 return rc;
 185
 186         if (file_info.EndOfFile != CIFS_MF_SYMLINK_FILE_SIZE) {
 187                 CIFSSMBClose(xid, pTcon, netfid);
 188                 /* it's not a symlink */
 189                 return 0;
 190         }
 191
 192         buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
 193         if (!buf)
 194                 return -ENOMEM;
 195         pbuf = buf;
 196
 197         rc = CIFSSMBRead(xid, pTcon, netfid,
 198                          CIFS_MF_SYMLINK_FILE_SIZE /* length */,
 199                          0 /* offset */,
 200                          &bytes_read, &pbuf, &buf_type);
 201         CIFSSMBClose(xid, pTcon, netfid);
 202         if (rc != 0) {
 203                 kfree(buf);
 204                 return rc;
 205         }
 206
 207         rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, NULL);
 208         kfree(buf);
 209         if (rc == -EINVAL)
 210                 /* it's not a symlink */
 211                 return 0;
 212         if (rc != 0)
 213                 return rc;
 214
 215         /* it is a symlink */
 216         fattr->cf_eof = link_len;
 217         fattr->cf_mode &= ~S_IFMT;
 218         fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
 219         fattr->cf_dtype = DT_LNK;
 220         return 0;
 221 }
 222
 223 int
 224 cifs_hardlink(struct dentry *old_file, struct inode *inode,
 225               struct dentry *direntry)
 226 {
 227         int rc = -EACCES;
 228         int xid;
 229         char *fromName = NULL;
 230         char *toName = NULL;
 231         struct cifs_sb_info *cifs_sb_target;
 232         struct cifsTconInfo *pTcon;
 233         struct cifsInodeInfo *cifsInode;
 234
 235         xid = GetXid();
 236
 237         cifs_sb_target = CIFS_SB(inode->i_sb);
 238         pTcon = cifs_sb_target->tcon;
 239
 240 /* No need to check for cross device links since server will do that
 241    BB note DFS case in future though (when we may have to check) */
 242
 243         fromName = build_path_from_dentry(old_file);
 244         toName = build_path_from_dentry(direntry);
 245         if ((fromName == NULL) || (toName == NULL)) {
 246                 rc = -ENOMEM;
 247                 goto cifs_hl_exit;
 248         }
 249
 250 /*      if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)*/
 251         if (pTcon->unix_ext)
 252                 rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
 253                                             cifs_sb_target->local_nls,
 254                                             cifs_sb_target->mnt_cifs_flags &
 255                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 256         else {
 257                 rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
 258                                         cifs_sb_target->local_nls,
 259                                         cifs_sb_target->mnt_cifs_flags &
 260                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 261                 if ((rc == -EIO) || (rc == -EINVAL))
 262                         rc = -EOPNOTSUPP;
 263         }
 264
 265         d_drop(direntry);       /* force new lookup from server of target */
 266
 267         /* if source file is cached (oplocked) revalidate will not go to server
 268            until the file is closed or oplock broken so update nlinks locally */
 269         if (old_file->d_inode) {
 270                 cifsInode = CIFS_I(old_file->d_inode);
 271                 if (rc == 0) {
 272                         old_file->d_inode->i_nlink++;
 273 /* BB should we make this contingent on superblock flag NOATIME? */
 274 /*                      old_file->d_inode->i_ctime = CURRENT_TIME;*/
 275                         /* parent dir timestamps will update from srv
 276                         within a second, would it really be worth it
 277                         to set the parent dir cifs inode time to zero
 278                         to force revalidate (faster) for it too? */
 279                 }
 280                 /* if not oplocked will force revalidate to get info
 281                    on source file from srv */
 282                 cifsInode->time = 0;
 283
 284                 /* Will update parent dir timestamps from srv within a second.
 285                    Would it really be worth it to set the parent dir (cifs
 286                    inode) time field to zero to force revalidate on parent
 287                    directory faster ie
 288                         CIFS_I(inode)->time = 0;  */
 289         }
 290
 291 cifs_hl_exit:
 292         kfree(fromName);
 293         kfree(toName);
 294         FreeXid(xid);
 295         return rc;
 296 }
 297
 298 void *
 299 cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 300 {
 301         struct inode *inode = direntry->d_inode;
 302         int rc = -ENOMEM;
 303         int xid;
 304         char *full_path = NULL;
 305         char *target_path = NULL;
 306         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 307         struct cifsTconInfo *tcon = cifs_sb->tcon;
 308
 309         xid = GetXid();
 310
 311         /*
 312          * For now, we just handle symlinks with unix extensions enabled.
 313          * Eventually we should handle NTFS reparse points, and MacOS
 314          * symlink support. For instance...
 315          *
 316          * rc = CIFSSMBQueryReparseLinkInfo(...)
 317          *
 318          * For now, just return -EACCES when the server doesn't support posix
 319          * extensions. Note that we still allow querying symlinks when posix
 320          * extensions are manually disabled. We could disable these as well
 321          * but there doesn't seem to be any harm in allowing the client to
 322          * read them.
 323          */
 324         if (!(tcon->ses->capabilities & CAP_UNIX)) {
 325                 rc = -EACCES;
 326                 goto out;
 327         }
 328
 329         full_path = build_path_from_dentry(direntry);
 330         if (!full_path)
 331                 goto out;
 332
 333         cFYI(1, "Full path: %s inode = 0x%p", full_path, inode);
 334
 335         rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
 336                                      cifs_sb->local_nls);
 337         kfree(full_path);
 338 out:
 339         if (rc != 0) {
 340                 kfree(target_path);
 341                 target_path = ERR_PTR(rc);
 342         }
 343
 344         FreeXid(xid);
 345         nd_set_link(nd, target_path);
 346         return NULL;
 347 }
 348
 349 int
 350 cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
 351 {
 352         int rc = -EOPNOTSUPP;
 353         int xid;
 354         struct cifs_sb_info *cifs_sb;
 355         struct cifsTconInfo *pTcon;
 356         char *full_path = NULL;
 357         struct inode *newinode = NULL;
 358
 359         xid = GetXid();
 360
 361         cifs_sb = CIFS_SB(inode->i_sb);
 362         pTcon = cifs_sb->tcon;
 363
 364         full_path = build_path_from_dentry(direntry);
 365
 366         if (full_path == NULL) {
 367                 rc = -ENOMEM;
 368                 FreeXid(xid);
 369                 return rc;
 370         }
 371
 372         cFYI(1, "Full path: %s", full_path);
 373         cFYI(1, "symname is %s", symname);
 374
 375         /* BB what if DFS and this volume is on different share? BB */
 376         if (pTcon->unix_ext)
 377                 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
 378                                            cifs_sb->local_nls);
 379         /* else
 380            rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
 381                                         cifs_sb_target->local_nls); */
 382
 383         if (rc == 0) {
 384                 if (pTcon->unix_ext)
 385                         rc = cifs_get_inode_info_unix(&newinode, full_path,
 386                                                       inode->i_sb, xid);
 387                 else
 388                         rc = cifs_get_inode_info(&newinode, full_path, NULL,
 389                                                  inode->i_sb, xid, NULL);
 390
 391                 if (rc != 0) {
 392                         cFYI(1, "Create symlink ok, getinodeinfo fail rc = %d",
 393                               rc);
 394                 } else {
 395                         if (pTcon->nocase)
 396                                 direntry->d_op = &cifs_ci_dentry_ops;
 397                         else
 398                                 direntry->d_op = &cifs_dentry_ops;
 399                         d_instantiate(direntry, newinode);
 400                 }
 401         }
 402
 403         kfree(full_path);
 404         FreeXid(xid);
 405         return rc;
 406 }
 407
 408 void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
 409 {
 410         char *p = nd_get_link(nd);
 411         if (!IS_ERR(p))
 412                 kfree(p);
 413 }