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 CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
  96 {
  97         unsigned int link_len;
  98         unsigned int ofs;
  99         struct MD5Context md5_ctx;
 100         u8 md5_hash[16];
 101
 102         if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
 103                 return -EINVAL;
 104
 105         link_len = strlen(link_str);
 106
 107         if (link_len > CIFS_MF_SYMLINK_LINK_MAXLEN)
 108                 return -ENAMETOOLONG;
 109
 110         cifs_MD5_init(&md5_ctx);
 111         cifs_MD5_update(&md5_ctx, (const u8 *)link_str, link_len);
 112         cifs_MD5_final(md5_hash, &md5_ctx);
 113
 114         snprintf(buf, buf_len,
 115                  CIFS_MF_SYMLINK_LEN_FORMAT CIFS_MF_SYMLINK_MD5_FORMAT,
 116                  link_len,
 117                  CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
 118
 119         ofs = CIFS_MF_SYMLINK_LINK_OFFSET;
 120         memcpy(buf + ofs, link_str, link_len);
 121
 122         ofs += link_len;
 123         if (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
 124                 buf[ofs] = '\n';
 125                 ofs++;
 126         }
 127
 128         while (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
 129                 buf[ofs] = ' ';
 130                 ofs++;
 131         }
 132
 133         return 0;
 134 }
 135
 136 CIFSQueryMFSymLink(const int xid, struct cifsTconInfo *tcon,
 137                    const unsigned char *searchName, char **symlinkinfo,
 138                    const struct nls_table *nls_codepage, int remap)
 139 {
 140         int rc;
 141         int oplock = 0;
 142         __u16 netfid = 0;
 143         u8 *buf;
 144         char *pbuf;
 145         unsigned int bytes_read = 0;
 146         int buf_type = CIFS_NO_BUFFER;
 147         unsigned int link_len = 0;
 148         FILE_ALL_INFO file_info;
 149
 150         rc = CIFSSMBOpen(xid, tcon, searchName, FILE_OPEN, GENERIC_READ,
 151                          CREATE_NOT_DIR, &netfid, &oplock, &file_info,
 152                          nls_codepage, remap);
 153         if (rc != 0)
 154                 return rc;
 155
 156         if (file_info.EndOfFile != CIFS_MF_SYMLINK_FILE_SIZE) {
 157                 CIFSSMBClose(xid, tcon, netfid);
 158                 /* it's not a symlink */
 159                 return -EINVAL;
 160         }
 161
 162         buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
 163         if (!buf)
 164                 return -ENOMEM;
 165         pbuf = buf;
 166
 167         rc = CIFSSMBRead(xid, tcon, netfid,
 168                          CIFS_MF_SYMLINK_FILE_SIZE /* length */,
 169                          0 /* offset */,
 170                          &bytes_read, &pbuf, &buf_type);
 171         CIFSSMBClose(xid, tcon, netfid);
 172         if (rc != 0) {
 173                 kfree(buf);
 174                 return rc;
 175         }
 176
 177         rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, symlinkinfo);
 178         kfree(buf);
 179         if (rc != 0)
 180                 return rc;
 181
 182         return 0;
 183 }
 184
 185 bool
 186 CIFSCouldBeMFSymlink(const struct cifs_fattr *fattr)
 187 {
 188         if (!(fattr->cf_mode & S_IFREG))
 189                 /* it's not a symlink */
 190                 return false;
 191
 192         if (fattr->cf_eof != CIFS_MF_SYMLINK_FILE_SIZE)
 193                 /* it's not a symlink */
 194                 return false;
 195
 196         return true;
 197 }
 198
 199 int
 200 CIFSCheckMFSymlink(struct cifs_fattr *fattr,
 201                    const unsigned char *path,
 202                    struct cifs_sb_info *cifs_sb, int xid)
 203 {
 204         int rc;
 205         int oplock = 0;
 206         __u16 netfid = 0;
 207         struct cifsTconInfo *pTcon = cifs_sb->tcon;
 208         u8 *buf;
 209         char *pbuf;
 210         unsigned int bytes_read = 0;
 211         int buf_type = CIFS_NO_BUFFER;
 212         unsigned int link_len = 0;
 213         FILE_ALL_INFO file_info;
 214
 215         if (!CIFSCouldBeMFSymlink(fattr))
 216                 /* it's not a symlink */
 217                 return 0;
 218
 219         rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
 220                          CREATE_NOT_DIR, &netfid, &oplock, &file_info,
 221                          cifs_sb->local_nls,
 222                          cifs_sb->mnt_cifs_flags &
 223                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 224         if (rc != 0)
 225                 return rc;
 226
 227         if (file_info.EndOfFile != CIFS_MF_SYMLINK_FILE_SIZE) {
 228                 CIFSSMBClose(xid, pTcon, netfid);
 229                 /* it's not a symlink */
 230                 return 0;
 231         }
 232
 233         buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
 234         if (!buf)
 235                 return -ENOMEM;
 236         pbuf = buf;
 237
 238         rc = CIFSSMBRead(xid, pTcon, netfid,
 239                          CIFS_MF_SYMLINK_FILE_SIZE /* length */,
 240                          0 /* offset */,
 241                          &bytes_read, &pbuf, &buf_type);
 242         CIFSSMBClose(xid, pTcon, netfid);
 243         if (rc != 0) {
 244                 kfree(buf);
 245                 return rc;
 246         }
 247
 248         rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, NULL);
 249         kfree(buf);
 250         if (rc == -EINVAL)
 251                 /* it's not a symlink */
 252                 return 0;
 253         if (rc != 0)
 254                 return rc;
 255
 256         /* it is a symlink */
 257         fattr->cf_eof = link_len;
 258         fattr->cf_mode &= ~S_IFMT;
 259         fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
 260         fattr->cf_dtype = DT_LNK;
 261         return 0;
 262 }
 263
 264 int
 265 cifs_hardlink(struct dentry *old_file, struct inode *inode,
 266               struct dentry *direntry)
 267 {
 268         int rc = -EACCES;
 269         int xid;
 270         char *fromName = NULL;
 271         char *toName = NULL;
 272         struct cifs_sb_info *cifs_sb_target;
 273         struct cifsTconInfo *pTcon;
 274         struct cifsInodeInfo *cifsInode;
 275
 276         xid = GetXid();
 277
 278         cifs_sb_target = CIFS_SB(inode->i_sb);
 279         pTcon = cifs_sb_target->tcon;
 280
 281 /* No need to check for cross device links since server will do that
 282    BB note DFS case in future though (when we may have to check) */
 283
 284         fromName = build_path_from_dentry(old_file);
 285         toName = build_path_from_dentry(direntry);
 286         if ((fromName == NULL) || (toName == NULL)) {
 287                 rc = -ENOMEM;
 288                 goto cifs_hl_exit;
 289         }
 290
 291 /*      if (cifs_sb_target->tcon->ses->capabilities & CAP_UNIX)*/
 292         if (pTcon->unix_ext)
 293                 rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
 294                                             cifs_sb_target->local_nls,
 295                                             cifs_sb_target->mnt_cifs_flags &
 296                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 297         else {
 298                 rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
 299                                         cifs_sb_target->local_nls,
 300                                         cifs_sb_target->mnt_cifs_flags &
 301                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 302                 if ((rc == -EIO) || (rc == -EINVAL))
 303                         rc = -EOPNOTSUPP;
 304         }
 305
 306         d_drop(direntry);       /* force new lookup from server of target */
 307
 308         /* if source file is cached (oplocked) revalidate will not go to server
 309            until the file is closed or oplock broken so update nlinks locally */
 310         if (old_file->d_inode) {
 311                 cifsInode = CIFS_I(old_file->d_inode);
 312                 if (rc == 0) {
 313                         old_file->d_inode->i_nlink++;
 314 /* BB should we make this contingent on superblock flag NOATIME? */
 315 /*                      old_file->d_inode->i_ctime = CURRENT_TIME;*/
 316                         /* parent dir timestamps will update from srv
 317                         within a second, would it really be worth it
 318                         to set the parent dir cifs inode time to zero
 319                         to force revalidate (faster) for it too? */
 320                 }
 321                 /* if not oplocked will force revalidate to get info
 322                    on source file from srv */
 323                 cifsInode->time = 0;
 324
 325                 /* Will update parent dir timestamps from srv within a second.
 326                    Would it really be worth it to set the parent dir (cifs
 327                    inode) time field to zero to force revalidate on parent
 328                    directory faster ie
 329                         CIFS_I(inode)->time = 0;  */
 330         }
 331
 332 cifs_hl_exit:
 333         kfree(fromName);
 334         kfree(toName);
 335         FreeXid(xid);
 336         return rc;
 337 }
 338
 339 void *
 340 cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 341 {
 342         struct inode *inode = direntry->d_inode;
 343         int rc = -ENOMEM;
 344         int xid;
 345         char *full_path = NULL;
 346         char *target_path = NULL;
 347         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 348         struct cifsTconInfo *tcon = cifs_sb->tcon;
 349
 350         xid = GetXid();
 351
 352         /*
 353          * For now, we just handle symlinks with unix extensions enabled.
 354          * Eventually we should handle NTFS reparse points, and MacOS
 355          * symlink support. For instance...
 356          *
 357          * rc = CIFSSMBQueryReparseLinkInfo(...)
 358          *
 359          * For now, just return -EACCES when the server doesn't support posix
 360          * extensions. Note that we still allow querying symlinks when posix
 361          * extensions are manually disabled. We could disable these as well
 362          * but there doesn't seem to be any harm in allowing the client to
 363          * read them.
 364          */
 365         if (!(tcon->ses->capabilities & CAP_UNIX)) {
 366                 rc = -EACCES;
 367                 goto out;
 368         }
 369
 370         full_path = build_path_from_dentry(direntry);
 371         if (!full_path)
 372                 goto out;
 373
 374         cFYI(1, "Full path: %s inode = 0x%p", full_path, inode);
 375
 376         rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
 377                                      cifs_sb->local_nls);
 378         kfree(full_path);
 379 out:
 380         if (rc != 0) {
 381                 kfree(target_path);
 382                 target_path = ERR_PTR(rc);
 383         }
 384
 385         FreeXid(xid);
 386         nd_set_link(nd, target_path);
 387         return NULL;
 388 }
 389
 390 int
 391 cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
 392 {
 393         int rc = -EOPNOTSUPP;
 394         int xid;
 395         struct cifs_sb_info *cifs_sb;
 396         struct cifsTconInfo *pTcon;
 397         char *full_path = NULL;
 398         struct inode *newinode = NULL;
 399
 400         xid = GetXid();
 401
 402         cifs_sb = CIFS_SB(inode->i_sb);
 403         pTcon = cifs_sb->tcon;
 404
 405         full_path = build_path_from_dentry(direntry);
 406
 407         if (full_path == NULL) {
 408                 rc = -ENOMEM;
 409                 FreeXid(xid);
 410                 return rc;
 411         }
 412
 413         cFYI(1, "Full path: %s", full_path);
 414         cFYI(1, "symname is %s", symname);
 415
 416         /* BB what if DFS and this volume is on different share? BB */
 417         if (pTcon->unix_ext)
 418                 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
 419                                            cifs_sb->local_nls);
 420         /* else
 421            rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
 422                                         cifs_sb_target->local_nls); */
 423
 424         if (rc == 0) {
 425                 if (pTcon->unix_ext)
 426                         rc = cifs_get_inode_info_unix(&newinode, full_path,
 427                                                       inode->i_sb, xid);
 428                 else
 429                         rc = cifs_get_inode_info(&newinode, full_path, NULL,
 430                                                  inode->i_sb, xid, NULL);
 431
 432                 if (rc != 0) {
 433                         cFYI(1, "Create symlink ok, getinodeinfo fail rc = %d",
 434                               rc);
 435                 } else {
 436                         if (pTcon->nocase)
 437                                 direntry->d_op = &cifs_ci_dentry_ops;
 438                         else
 439                                 direntry->d_op = &cifs_dentry_ops;
 440                         d_instantiate(direntry, newinode);
 441                 }
 442         }
 443
 444         kfree(full_path);
 445         FreeXid(xid);
 446         return rc;
 447 }
 448
 449 void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
 450 {
 451         char *p = nd_get_link(nd);
 452         if (!IS_ERR(p))
 453                 kfree(p);
 454 }