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
  32 #define MAX_EA_VALUE_SIZE 65535
  33 #define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib"
  34 #define CIFS_XATTR_CIFS_ACL "system.cifs_acl"
  35
  36 /* BB need to add server (Samba e.g) support for security and trusted prefix */
  37
  38 int cifs_removexattr(struct dentry *direntry, const char *ea_name)
  39 {
  40         int rc = -EOPNOTSUPP;
  41 #ifdef CONFIG_CIFS_XATTR
  42         unsigned int xid;
  43         struct cifs_sb_info *cifs_sb;
  44         struct tcon_link *tlink;
  45         struct cifs_tcon *pTcon;
  46         struct super_block *sb;
  47         char *full_path = NULL;
  48
  49         if (direntry == NULL)
  50                 return -EIO;
  51         if (direntry->d_inode == NULL)
  52                 return -EIO;
  53         sb = direntry->d_inode->i_sb;
  54         if (sb == NULL)
  55                 return -EIO;
  56
  57         cifs_sb = CIFS_SB(sb);
  58         tlink = cifs_sb_tlink(cifs_sb);
  59         if (IS_ERR(tlink))
  60                 return PTR_ERR(tlink);
  61         pTcon = tlink_tcon(tlink);
  62
  63         xid = get_xid();
  64
  65         full_path = build_path_from_dentry(direntry);
  66         if (full_path == NULL) {
  67                 rc = -ENOMEM;
  68                 goto remove_ea_exit;
  69         }
  70         if (ea_name == NULL) {
  71                 cifs_dbg(FYI, "Null xattr names not supported\n");
  72         } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
  73                 && (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))) {
  74                 cifs_dbg(FYI,
  75                          "illegal xattr request %s (only user namespace supported)\n",
  76                          ea_name);
  77                 /* BB what if no namespace prefix? */
  78                 /* Should we just pass them to server, except for
  79                 system and perhaps security prefixes? */
  80         } else {
  81                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
  82                         goto remove_ea_exit;
  83
  84                 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
  85                 if (pTcon->ses->server->ops->set_EA)
  86                         rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
  87                                 full_path, ea_name, NULL, (__u16)0,
  88                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
  89                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
  90         }
  91 remove_ea_exit:
  92         kfree(full_path);
  93         free_xid(xid);
  94         cifs_put_tlink(tlink);
  95 #endif
  96         return rc;
  97 }
  98
  99 int cifs_setxattr(struct dentry *direntry, const char *ea_name,
 100                   const void *ea_value, size_t value_size, int flags)
 101 {
 102         int rc = -EOPNOTSUPP;
 103 #ifdef CONFIG_CIFS_XATTR
 104         unsigned int xid;
 105         struct cifs_sb_info *cifs_sb;
 106         struct tcon_link *tlink;
 107         struct cifs_tcon *pTcon;
 108         struct super_block *sb;
 109         char *full_path;
 110
 111         if (direntry == NULL)
 112                 return -EIO;
 113         if (direntry->d_inode == NULL)
 114                 return -EIO;
 115         sb = direntry->d_inode->i_sb;
 116         if (sb == NULL)
 117                 return -EIO;
 118
 119         cifs_sb = CIFS_SB(sb);
 120         tlink = cifs_sb_tlink(cifs_sb);
 121         if (IS_ERR(tlink))
 122                 return PTR_ERR(tlink);
 123         pTcon = tlink_tcon(tlink);
 124
 125         xid = get_xid();
 126
 127         full_path = build_path_from_dentry(direntry);
 128         if (full_path == NULL) {
 129                 rc = -ENOMEM;
 130                 goto set_ea_exit;
 131         }
 132         /* return dos attributes as pseudo xattr */
 133         /* return alt name if available as pseudo attr */
 134
 135         /* if proc/fs/cifs/streamstoxattr is set then
 136                 search server for EAs or streams to
 137                 returns as xattrs */
 138         if (value_size > MAX_EA_VALUE_SIZE) {
 139                 cifs_dbg(FYI, "size of EA value too large\n");
 140                 rc = -EOPNOTSUPP;
 141                 goto set_ea_exit;
 142         }
 143
 144         if (ea_name == NULL) {
 145                 cifs_dbg(FYI, "Null xattr names not supported\n");
 146         } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
 147                    == 0) {
 148                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 149                         goto set_ea_exit;
 150                 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
 151                         cifs_dbg(FYI, "attempt to set cifs inode metadata\n");
 152
 153                 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
 154                 if (pTcon->ses->server->ops->set_EA)
 155                         rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
 156                                 full_path, ea_name, ea_value, (__u16)value_size,
 157                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 158                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 159         } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN)
 160                    == 0) {
 161                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 162                         goto set_ea_exit;
 163
 164                 ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
 165                 if (pTcon->ses->server->ops->set_EA)
 166                         rc = pTcon->ses->server->ops->set_EA(xid, pTcon,
 167                                 full_path, ea_name, ea_value, (__u16)value_size,
 168                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 169                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 170         } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
 171                         strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
 172 #ifdef CONFIG_CIFS_ACL
 173                 struct cifs_ntsd *pacl;
 174                 pacl = kmalloc(value_size, GFP_KERNEL);
 175                 if (!pacl) {
 176                         rc = -ENOMEM;
 177                 } else {
 178                         memcpy(pacl, ea_value, value_size);
 179                         if (pTcon->ses->server->ops->set_acl)
 180                                 rc = pTcon->ses->server->ops->set_acl(pacl,
 181                                                 value_size, direntry->d_inode,
 182                                                 full_path, CIFS_ACL_DACL);
 183                         else
 184                                 rc = -EOPNOTSUPP;
 185                         if (rc == 0) /* force revalidate of the inode */
 186                                 CIFS_I(direntry->d_inode)->time = 0;
 187                         kfree(pacl);
 188                 }
 189 #else
 190                 cifs_dbg(FYI, "Set CIFS ACL not supported yet\n");
 191 #endif /* CONFIG_CIFS_ACL */
 192         } else {
 193                 int temp;
 194                 temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
 195                         strlen(POSIX_ACL_XATTR_ACCESS));
 196                 if (temp == 0) {
 197 #ifdef CONFIG_CIFS_POSIX
 198                         if (sb->s_flags & MS_POSIXACL)
 199                                 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 200                                         ea_value, (const int)value_size,
 201                                         ACL_TYPE_ACCESS, cifs_sb->local_nls,
 202                                         cifs_sb->mnt_cifs_flags &
 203                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 204                         cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc);
 205 #else
 206                         cifs_dbg(FYI, "set POSIX ACL not supported\n");
 207 #endif
 208                 } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
 209                                    strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 210 #ifdef CONFIG_CIFS_POSIX
 211                         if (sb->s_flags & MS_POSIXACL)
 212                                 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 213                                         ea_value, (const int)value_size,
 214                                         ACL_TYPE_DEFAULT, cifs_sb->local_nls,
 215                                         cifs_sb->mnt_cifs_flags &
 216                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 217                         cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc);
 218 #else
 219                         cifs_dbg(FYI, "set default POSIX ACL not supported\n");
 220 #endif
 221                 } else {
 222                         cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n",
 223                                  ea_name);
 224                   /* BB what if no namespace prefix? */
 225                   /* Should we just pass them to server, except for
 226                   system and perhaps security prefixes? */
 227                 }
 228         }
 229
 230 set_ea_exit:
 231         kfree(full_path);
 232         free_xid(xid);
 233         cifs_put_tlink(tlink);
 234 #endif
 235         return rc;
 236 }
 237
 238 ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 239         void *ea_value, size_t buf_size)
 240 {
 241         ssize_t rc = -EOPNOTSUPP;
 242 #ifdef CONFIG_CIFS_XATTR
 243         unsigned int xid;
 244         struct cifs_sb_info *cifs_sb;
 245         struct tcon_link *tlink;
 246         struct cifs_tcon *pTcon;
 247         struct super_block *sb;
 248         char *full_path;
 249
 250         if (direntry == NULL)
 251                 return -EIO;
 252         if (direntry->d_inode == NULL)
 253                 return -EIO;
 254         sb = direntry->d_inode->i_sb;
 255         if (sb == NULL)
 256                 return -EIO;
 257
 258         cifs_sb = CIFS_SB(sb);
 259         tlink = cifs_sb_tlink(cifs_sb);
 260         if (IS_ERR(tlink))
 261                 return PTR_ERR(tlink);
 262         pTcon = tlink_tcon(tlink);
 263
 264         xid = get_xid();
 265
 266         full_path = build_path_from_dentry(direntry);
 267         if (full_path == NULL) {
 268                 rc = -ENOMEM;
 269                 goto get_ea_exit;
 270         }
 271         /* return dos attributes as pseudo xattr */
 272         /* return alt name if available as pseudo attr */
 273         if (ea_name == NULL) {
 274                 cifs_dbg(FYI, "Null xattr names not supported\n");
 275         } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
 276                    == 0) {
 277                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 278                         goto get_ea_exit;
 279
 280                 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
 281                         cifs_dbg(FYI, "attempt to query cifs inode metadata\n");
 282                         /* revalidate/getattr then populate from inode */
 283                 } /* BB add else when above is implemented */
 284                 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
 285                 if (pTcon->ses->server->ops->query_all_EAs)
 286                         rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 287                                 full_path, ea_name, ea_value, buf_size,
 288                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 289                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 290         } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
 291                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 292                         goto get_ea_exit;
 293
 294                 ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
 295                 if (pTcon->ses->server->ops->query_all_EAs)
 296                         rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 297                                 full_path, ea_name, ea_value, buf_size,
 298                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 299                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 300         } else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
 301                           strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
 302 #ifdef CONFIG_CIFS_POSIX
 303                 if (sb->s_flags & MS_POSIXACL)
 304                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 305                                 ea_value, buf_size, ACL_TYPE_ACCESS,
 306                                 cifs_sb->local_nls,
 307                                 cifs_sb->mnt_cifs_flags &
 308                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 309 #else
 310                 cifs_dbg(FYI, "Query POSIX ACL not supported yet\n");
 311 #endif /* CONFIG_CIFS_POSIX */
 312         } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
 313                           strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 314 #ifdef CONFIG_CIFS_POSIX
 315                 if (sb->s_flags & MS_POSIXACL)
 316                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 317                                 ea_value, buf_size, ACL_TYPE_DEFAULT,
 318                                 cifs_sb->local_nls,
 319                                 cifs_sb->mnt_cifs_flags &
 320                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 321 #else
 322                 cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n");
 323 #endif /* CONFIG_CIFS_POSIX */
 324         } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
 325                                 strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
 326 #ifdef CONFIG_CIFS_ACL
 327                         u32 acllen;
 328                         struct cifs_ntsd *pacl;
 329
 330                         if (pTcon->ses->server->ops->get_acl == NULL)
 331                                 goto get_ea_exit; /* rc already EOPNOTSUPP */
 332
 333                         pacl = pTcon->ses->server->ops->get_acl(cifs_sb,
 334                                         direntry->d_inode, full_path, &acllen);
 335                         if (IS_ERR(pacl)) {
 336                                 rc = PTR_ERR(pacl);
 337                                 cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
 338                                          __func__, rc);
 339                         } else {
 340                                 if (ea_value) {
 341                                         if (acllen > buf_size)
 342                                                 acllen = -ERANGE;
 343                                         else
 344                                                 memcpy(ea_value, pacl, acllen);
 345                                 }
 346                                 rc = acllen;
 347                                 kfree(pacl);
 348                         }
 349 #else
 350                         cifs_dbg(FYI, "Query CIFS ACL not supported yet\n");
 351 #endif /* CONFIG_CIFS_ACL */
 352         } else if (strncmp(ea_name,
 353                   XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
 354                 cifs_dbg(FYI, "Trusted xattr namespace not supported yet\n");
 355         } else if (strncmp(ea_name,
 356                   XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
 357                 cifs_dbg(FYI, "Security xattr namespace not supported yet\n");
 358         } else
 359                 cifs_dbg(FYI,
 360                          "illegal xattr request %s (only user namespace supported)\n",
 361                          ea_name);
 362
 363         /* We could add an additional check for streams ie
 364             if proc/fs/cifs/streamstoxattr is set then
 365                 search server for EAs or streams to
 366                 returns as xattrs */
 367
 368         if (rc == -EINVAL)
 369                 rc = -EOPNOTSUPP;
 370
 371 get_ea_exit:
 372         kfree(full_path);
 373         free_xid(xid);
 374         cifs_put_tlink(tlink);
 375 #endif
 376         return rc;
 377 }
 378
 379 ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 380 {
 381         ssize_t rc = -EOPNOTSUPP;
 382 #ifdef CONFIG_CIFS_XATTR
 383         unsigned int xid;
 384         struct cifs_sb_info *cifs_sb;
 385         struct tcon_link *tlink;
 386         struct cifs_tcon *pTcon;
 387         struct super_block *sb;
 388         char *full_path;
 389
 390         if (direntry == NULL)
 391                 return -EIO;
 392         if (direntry->d_inode == NULL)
 393                 return -EIO;
 394         sb = direntry->d_inode->i_sb;
 395         if (sb == NULL)
 396                 return -EIO;
 397
 398         cifs_sb = CIFS_SB(sb);
 399         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 400                 return -EOPNOTSUPP;
 401
 402         tlink = cifs_sb_tlink(cifs_sb);
 403         if (IS_ERR(tlink))
 404                 return PTR_ERR(tlink);
 405         pTcon = tlink_tcon(tlink);
 406
 407         xid = get_xid();
 408
 409         full_path = build_path_from_dentry(direntry);
 410         if (full_path == NULL) {
 411                 rc = -ENOMEM;
 412                 goto list_ea_exit;
 413         }
 414         /* return dos attributes as pseudo xattr */
 415         /* return alt name if available as pseudo attr */
 416
 417         /* if proc/fs/cifs/streamstoxattr is set then
 418                 search server for EAs or streams to
 419                 returns as xattrs */
 420
 421         if (pTcon->ses->server->ops->query_all_EAs)
 422                 rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 423                                 full_path, NULL, data, buf_size,
 424                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 425                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 426 list_ea_exit:
 427         kfree(full_path);
 428         free_xid(xid);
 429         cifs_put_tlink(tlink);
 430 #endif
 431         return rc;
 432 }