LXR linux/fs/cifs/xattr.c

   1/*
   2 *   fs/cifs/xattr.c
   3 *
   4 *   Copyright (c) International Business Machines  Corp., 2003, 2007
   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
  22#include <linux/fs.h>
  23#include <linux/posix_acl_xattr.h>
  24#include <linux/slab.h>
  25#include <linux/xattr.h>
  26#include "cifsfs.h"
  27#include "cifspdu.h"
  28#include "cifsglob.h"
  29#include "cifsproto.h"
  30#include "cifs_debug.h"
  31#include "cifs_fs_sb.h"
  32#include "cifs_unicode.h"
  33
  34#define MAX_EA_VALUE_SIZE CIFSMaxBufSize
  35#define CIFS_XATTR_CIFS_ACL "system.cifs_acl" /* DACL only */
  36#define CIFS_XATTR_CIFS_NTSD "system.cifs_ntsd" /* owner plus DACL */
  37#define CIFS_XATTR_ATTRIB "cifs.dosattrib"  /* full name: user.cifs.dosattrib */
  38#define CIFS_XATTR_CREATETIME "cifs.creationtime"  /* user.cifs.creationtime */
  39/*
  40 * Although these three are just aliases for the above, need to move away from
  41 * confusing users and using the 20+ year old term 'cifs' when it is no longer
  42 * secure, replaced by SMB2 (then even more highly secure SMB3) many years ago
  43 */
  44#define SMB3_XATTR_CIFS_ACL "system.smb3_acl" /* DACL only */
  45#define SMB3_XATTR_CIFS_NTSD "system.smb3_ntsd" /* owner plus DACL */
  46#define SMB3_XATTR_ATTRIB "smb3.dosattrib"  /* full name: user.smb3.dosattrib */
  47#define SMB3_XATTR_CREATETIME "smb3.creationtime"  /* user.smb3.creationtime */
  48/* BB need to add server (Samba e.g) support for security and trusted prefix */
  49
  50enum { XATTR_USER, XATTR_CIFS_ACL, XATTR_ACL_ACCESS, XATTR_ACL_DEFAULT,
  51        XATTR_CIFS_NTSD };
  52
  53static int cifs_attrib_set(unsigned int xid, struct cifs_tcon *pTcon,
  54                           struct inode *inode, char *full_path,
  55                           const void *value, size_t size)
  56{
  57        ssize_t rc = -EOPNOTSUPP;
  58        __u32 *pattrib = (__u32 *)value;
  59        __u32 attrib;
  60        FILE_BASIC_INFO info_buf;
  61
  62        if ((value == NULL) || (size != sizeof(__u32)))
  63                return -ERANGE;
  64
  65        memset(&info_buf, 0, sizeof(info_buf));
  66        attrib = *pattrib;
  67        info_buf.Attributes = cpu_to_le32(attrib);
  68        if (pTcon->ses->server->ops->set_file_info)
  69                rc = pTcon->ses->server->ops->set_file_info(inode, full_path,
  70                                &info_buf, xid);
  71        if (rc == 0)
  72                CIFS_I(inode)->cifsAttrs = attrib;
  73
  74        return rc;
  75}
  76
  77static int cifs_creation_time_set(unsigned int xid, struct cifs_tcon *pTcon,
  78                                  struct inode *inode, char *full_path,
  79                                  const void *value, size_t size)
  80{
  81        ssize_t rc = -EOPNOTSUPP;
  82        __u64 *pcreation_time = (__u64 *)value;
  83        __u64 creation_time;
  84        FILE_BASIC_INFO info_buf;
  85
  86        if ((value == NULL) || (size != sizeof(__u64)))
  87                return -ERANGE;
  88
  89        memset(&info_buf, 0, sizeof(info_buf));
  90        creation_time = *pcreation_time;
  91        info_buf.CreationTime = cpu_to_le64(creation_time);
  92        if (pTcon->ses->server->ops->set_file_info)
  93                rc = pTcon->ses->server->ops->set_file_info(inode, full_path,
  94                                &info_buf, xid);
  95        if (rc == 0)
  96                CIFS_I(inode)->createtime = creation_time;
  97
  98        return rc;
  99}
 100
 101static int cifs_xattr_set(const struct xattr_handler *handler,
 102                          struct dentry *dentry, struct inode *inode,
 103                          const char *name, const void *value,
 104                          size_t size, int flags)
 105{
 106        int rc = -EOPNOTSUPP;
 107        unsigned int xid;
 108        struct super_block *sb = dentry->d_sb;
 109        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 110        struct tcon_link *tlink;
 111        struct cifs_tcon *pTcon;
 112        char *full_path;
 113
 114        tlink = cifs_sb_tlink(cifs_sb);
 115        if (IS_ERR(tlink))
 116                return PTR_ERR(tlink);
 117        pTcon = tlink_tcon(tlink);
 118
 119        xid = get_xid();
 120
 121        full_path = build_path_from_dentry(dentry);
 122        if (full_path == NULL) {
 123                rc = -ENOMEM;
 124                goto out;
 125        }
 126        /* return dos attributes as pseudo xattr */
 127        /* return alt name if available as pseudo attr */
 128
 129        /* if proc/fs/cifs/streamstoxattr is set then
 130                search server for EAs or streams to
 131                returns as xattrs */
 132        if (size > MAX_EA_VALUE_SIZE) {
 133                cifs_dbg(FYI, "size of EA value too large\n");
 134                rc = -EOPNOTSUPP;
 135                goto out;
 136        }
 137
 138        switch (handler->flags) {
 139        case XATTR_USER:
 140                cifs_dbg(FYI, "%s:setting user xattr %s\n", __func__, name);
 141                if ((strcmp(name, CIFS_XATTR_ATTRIB) == 0) ||
 142                    (strcmp(name, SMB3_XATTR_ATTRIB) == 0)) {
 143                        rc = cifs_attrib_set(xid, pTcon, inode, full_path,
 144                                        value, size);
 145                        if (rc == 0) /* force revalidate of the inode */
 146                                CIFS_I(inode)->time = 0;
 147                        break;
 148                } else if ((strcmp(name, CIFS_XATTR_CREATETIME) == 0) ||
 149                           (strcmp(name, SMB3_XATTR_CREATETIME) == 0)) {
 150                        rc = cifs_creation_time_set(xid, pTcon, inode,
 151                                        full_path, value, size);
 152                        if (rc == 0) /* force revalidate of the inode */
 153                                CIFS_I(inode)->time = 0;
 154                        break;
 155                }
 156
 157                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 158                        goto out;
 159
 160                if (pTcon->ses->server->ops->set_EA)
 161                        rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
 162                                full_path, name, value, (__u16)size,
 163                                cifs_sb->local_nls, cifs_sb);
 164                break;
 165
 166        case XATTR_CIFS_ACL:
 167        case XATTR_CIFS_NTSD: {
 168                struct cifs_ntsd *pacl;
 169
 170                if (!value)
 171                        goto out;
 172                pacl = kmalloc(size, GFP_KERNEL);
 173                if (!pacl) {
 174                        rc = -ENOMEM;
 175                } else {
 176                        memcpy(pacl, value, size);
 177                        if (value &&
 178                            pTcon->ses->server->ops->set_acl) {
 179                                rc = 0;
 180                                if (handler->flags == XATTR_CIFS_NTSD) {
 181                                        /* set owner and DACL */
 182                                        rc = pTcon->ses->server->ops->set_acl(
 183                                                        pacl, size, inode,
 184                                                        full_path,
 185                                                        CIFS_ACL_OWNER);
 186                                }
 187                                if (rc == 0) {
 188                                        /* set DACL */
 189                                        rc = pTcon->ses->server->ops->set_acl(
 190                                                        pacl, size, inode,
 191                                                        full_path,
 192                                                        CIFS_ACL_DACL);
 193                                }
 194                        } else {
 195                                rc = -EOPNOTSUPP;
 196                        }
 197                        if (rc == 0) /* force revalidate of the inode */
 198                                CIFS_I(inode)->time = 0;
 199                        kfree(pacl);
 200                }
 201                break;
 202        }
 203
 204        case XATTR_ACL_ACCESS:
 205#ifdef CONFIG_CIFS_POSIX
 206                if (!value)
 207                        goto out;
 208                if (sb->s_flags & SB_POSIXACL)
 209                        rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 210                                value, (const int)size,
 211                                ACL_TYPE_ACCESS, cifs_sb->local_nls,
 212                                cifs_remap(cifs_sb));
 213#endif  /* CONFIG_CIFS_POSIX */
 214                break;
 215
 216        case XATTR_ACL_DEFAULT:
 217#ifdef CONFIG_CIFS_POSIX
 218                if (!value)
 219                        goto out;
 220                if (sb->s_flags & SB_POSIXACL)
 221                        rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 222                                value, (const int)size,
 223                                ACL_TYPE_DEFAULT, cifs_sb->local_nls,
 224                                cifs_remap(cifs_sb));
 225#endif  /* CONFIG_CIFS_POSIX */
 226                break;
 227        }
 228
 229out:
 230        kfree(full_path);
 231        free_xid(xid);
 232        cifs_put_tlink(tlink);
 233        return rc;
 234}
 235
 236static int cifs_attrib_get(struct dentry *dentry,
 237                           struct inode *inode, void *value,
 238                           size_t size)
 239{
 240        ssize_t rc;
 241        __u32 *pattribute;
 242
 243        rc = cifs_revalidate_dentry_attr(dentry);
 244
 245        if (rc)
 246                return rc;
 247
 248        if ((value == NULL) || (size == 0))
 249                return sizeof(__u32);
 250        else if (size < sizeof(__u32))
 251                return -ERANGE;
 252
 253        /* return dos attributes as pseudo xattr */
 254        pattribute = (__u32 *)value;
 255        *pattribute = CIFS_I(inode)->cifsAttrs;
 256
 257        return sizeof(__u32);
 258}
 259
 260static int cifs_creation_time_get(struct dentry *dentry, struct inode *inode,
 261                                  void *value, size_t size)
 262{
 263        ssize_t rc;
 264        __u64 *pcreatetime;
 265
 266        rc = cifs_revalidate_dentry_attr(dentry);
 267        if (rc)
 268                return rc;
 269
 270        if ((value == NULL) || (size == 0))
 271                return sizeof(__u64);
 272        else if (size < sizeof(__u64))
 273                return -ERANGE;
 274
 275        /* return dos attributes as pseudo xattr */
 276        pcreatetime = (__u64 *)value;
 277        *pcreatetime = CIFS_I(inode)->createtime;
 278        return sizeof(__u64);
 279}
 280
 281
 282static int cifs_xattr_get(const struct xattr_handler *handler,
 283                          struct dentry *dentry, struct inode *inode,
 284                          const char *name, void *value, size_t size)
 285{
 286        ssize_t rc = -EOPNOTSUPP;
 287        unsigned int xid;
 288        struct super_block *sb = dentry->d_sb;
 289        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 290        struct tcon_link *tlink;
 291        struct cifs_tcon *pTcon;
 292        char *full_path;
 293
 294        tlink = cifs_sb_tlink(cifs_sb);
 295        if (IS_ERR(tlink))
 296                return PTR_ERR(tlink);
 297        pTcon = tlink_tcon(tlink);
 298
 299        xid = get_xid();
 300
 301        full_path = build_path_from_dentry(dentry);
 302        if (full_path == NULL) {
 303                rc = -ENOMEM;
 304                goto out;
 305        }
 306
 307        /* return alt name if available as pseudo attr */
 308        switch (handler->flags) {
 309        case XATTR_USER:
 310                cifs_dbg(FYI, "%s:querying user xattr %s\n", __func__, name);
 311                if ((strcmp(name, CIFS_XATTR_ATTRIB) == 0) ||
 312                    (strcmp(name, SMB3_XATTR_ATTRIB) == 0)) {
 313                        rc = cifs_attrib_get(dentry, inode, value, size);
 314                        break;
 315                } else if ((strcmp(name, CIFS_XATTR_CREATETIME) == 0) ||
 316                    (strcmp(name, SMB3_XATTR_CREATETIME) == 0)) {
 317                        rc = cifs_creation_time_get(dentry, inode, value, size);
 318                        break;
 319                }
 320
 321                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 322                        goto out;
 323
 324                if (pTcon->ses->server->ops->query_all_EAs)
 325                        rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 326                                full_path, name, value, size, cifs_sb);
 327                break;
 328
 329        case XATTR_CIFS_ACL:
 330        case XATTR_CIFS_NTSD: {
 331                /* the whole ntsd is fetched regardless */
 332                u32 acllen;
 333                struct cifs_ntsd *pacl;
 334
 335                if (pTcon->ses->server->ops->get_acl == NULL)
 336                        goto out; /* rc already EOPNOTSUPP */
 337
 338                pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
 339                                inode, full_path, &acllen);
 340                if (IS_ERR(pacl)) {
 341                        rc = PTR_ERR(pacl);
 342                        cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
 343                                 __func__, rc);
 344                } else {
 345                        if (value) {
 346                                if (acllen > size)
 347                                        acllen = -ERANGE;
 348                                else
 349                                        memcpy(value, pacl, acllen);
 350                        }
 351                        rc = acllen;
 352                        kfree(pacl);
 353                }
 354                break;
 355        }
 356
 357        case XATTR_ACL_ACCESS:
 358#ifdef CONFIG_CIFS_POSIX
 359                if (sb->s_flags & SB_POSIXACL)
 360                        rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 361                                value, size, ACL_TYPE_ACCESS,
 362                                cifs_sb->local_nls,
 363                                cifs_remap(cifs_sb));
 364#endif  /* CONFIG_CIFS_POSIX */
 365                break;
 366
 367        case XATTR_ACL_DEFAULT:
 368#ifdef CONFIG_CIFS_POSIX
 369                if (sb->s_flags & SB_POSIXACL)
 370                        rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 371                                value, size, ACL_TYPE_DEFAULT,
 372                                cifs_sb->local_nls,
 373                                cifs_remap(cifs_sb));
 374#endif  /* CONFIG_CIFS_POSIX */
 375                break;
 376        }
 377
 378        /* We could add an additional check for streams ie
 379            if proc/fs/cifs/streamstoxattr is set then
 380                search server for EAs or streams to
 381                returns as xattrs */
 382
 383        if (rc == -EINVAL)
 384                rc = -EOPNOTSUPP;
 385
 386out:
 387        kfree(full_path);
 388        free_xid(xid);
 389        cifs_put_tlink(tlink);
 390        return rc;
 391}
 392
 393ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 394{
 395        ssize_t rc = -EOPNOTSUPP;
 396        unsigned int xid;
 397        struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
 398        struct tcon_link *tlink;
 399        struct cifs_tcon *pTcon;
 400        char *full_path;
 401
 402        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 403                return -EOPNOTSUPP;
 404
 405        tlink = cifs_sb_tlink(cifs_sb);
 406        if (IS_ERR(tlink))
 407                return PTR_ERR(tlink);
 408        pTcon = tlink_tcon(tlink);
 409
 410        xid = get_xid();
 411
 412        full_path = build_path_from_dentry(direntry);
 413        if (full_path == NULL) {
 414                rc = -ENOMEM;
 415                goto list_ea_exit;
 416        }
 417        /* return dos attributes as pseudo xattr */
 418        /* return alt name if available as pseudo attr */
 419
 420        /* if proc/fs/cifs/streamstoxattr is set then
 421                search server for EAs or streams to
 422                returns as xattrs */
 423
 424        if (pTcon->ses->server->ops->query_all_EAs)
 425                rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 426                                full_path, NULL, data, buf_size, cifs_sb);
 427list_ea_exit:
 428        kfree(full_path);
 429        free_xid(xid);
 430        cifs_put_tlink(tlink);
 431        return rc;
 432}
 433
 434static const struct xattr_handler cifs_user_xattr_handler = {
 435        .prefix = XATTR_USER_PREFIX,
 436        .flags = XATTR_USER,
 437        .get = cifs_xattr_get,
 438        .set = cifs_xattr_set,
 439};
 440
 441/* os2.* attributes are treated like user.* attributes */
 442static const struct xattr_handler cifs_os2_xattr_handler = {
 443        .prefix = XATTR_OS2_PREFIX,
 444        .flags = XATTR_USER,
 445        .get = cifs_xattr_get,
 446        .set = cifs_xattr_set,
 447};
 448
 449static const struct xattr_handler cifs_cifs_acl_xattr_handler = {
 450        .name = CIFS_XATTR_CIFS_ACL,
 451        .flags = XATTR_CIFS_ACL,
 452        .get = cifs_xattr_get,
 453        .set = cifs_xattr_set,
 454};
 455
 456/*
 457 * Although this is just an alias for the above, need to move away from
 458 * confusing users and using the 20 year old term 'cifs' when it is no
 459 * longer secure and was replaced by SMB2/SMB3 a long time ago, and
 460 * SMB3 and later are highly secure.
 461 */
 462static const struct xattr_handler smb3_acl_xattr_handler = {
 463        .name = SMB3_XATTR_CIFS_ACL,
 464        .flags = XATTR_CIFS_ACL,
 465        .get = cifs_xattr_get,
 466        .set = cifs_xattr_set,
 467};
 468
 469static const struct xattr_handler cifs_cifs_ntsd_xattr_handler = {
 470        .name = CIFS_XATTR_CIFS_NTSD,
 471        .flags = XATTR_CIFS_NTSD,
 472        .get = cifs_xattr_get,
 473        .set = cifs_xattr_set,
 474};
 475
 476/*
 477 * Although this is just an alias for the above, need to move away from
 478 * confusing users and using the 20 year old term 'cifs' when it is no
 479 * longer secure and was replaced by SMB2/SMB3 a long time ago, and
 480 * SMB3 and later are highly secure.
 481 */
 482static const struct xattr_handler smb3_ntsd_xattr_handler = {
 483        .name = SMB3_XATTR_CIFS_NTSD,
 484        .flags = XATTR_CIFS_NTSD,
 485        .get = cifs_xattr_get,
 486        .set = cifs_xattr_set,
 487};
 488
 489static const struct xattr_handler cifs_posix_acl_access_xattr_handler = {
 490        .name = XATTR_NAME_POSIX_ACL_ACCESS,
 491        .flags = XATTR_ACL_ACCESS,
 492        .get = cifs_xattr_get,
 493        .set = cifs_xattr_set,
 494};
 495
 496static const struct xattr_handler cifs_posix_acl_default_xattr_handler = {
 497        .name = XATTR_NAME_POSIX_ACL_DEFAULT,
 498        .flags = XATTR_ACL_DEFAULT,
 499        .get = cifs_xattr_get,
 500        .set = cifs_xattr_set,
 501};
 502
 503const struct xattr_handler *cifs_xattr_handlers[] = {
 504        &cifs_user_xattr_handler,
 505        &cifs_os2_xattr_handler,
 506        &cifs_cifs_acl_xattr_handler,
 507        &smb3_acl_xattr_handler, /* alias for above since avoiding "cifs" */
 508        &cifs_cifs_ntsd_xattr_handler,
 509        &smb3_ntsd_xattr_handler, /* alias for above since avoiding "cifs" */
 510        &cifs_posix_acl_access_xattr_handler,
 511        &cifs_posix_acl_default_xattr_handler,
 512        NULL
 513};
 514