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                         rc = set_cifs_acl(pacl, value_size,
 180                                 direntry->d_inode, full_path, CIFS_ACL_DACL);
 181                         if (rc == 0) /* force revalidate of the inode */
 182                                 CIFS_I(direntry->d_inode)->time = 0;
 183                         kfree(pacl);
 184                 }
 185 #else
 186                 cifs_dbg(FYI, "Set CIFS ACL not supported yet\n");
 187 #endif /* CONFIG_CIFS_ACL */
 188         } else {
 189                 int temp;
 190                 temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
 191                         strlen(POSIX_ACL_XATTR_ACCESS));
 192                 if (temp == 0) {
 193 #ifdef CONFIG_CIFS_POSIX
 194                         if (sb->s_flags & MS_POSIXACL)
 195                                 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 196                                         ea_value, (const int)value_size,
 197                                         ACL_TYPE_ACCESS, cifs_sb->local_nls,
 198                                         cifs_sb->mnt_cifs_flags &
 199                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 200                         cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc);
 201 #else
 202                         cifs_dbg(FYI, "set POSIX ACL not supported\n");
 203 #endif
 204                 } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
 205                                    strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 206 #ifdef CONFIG_CIFS_POSIX
 207                         if (sb->s_flags & MS_POSIXACL)
 208                                 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 209                                         ea_value, (const int)value_size,
 210                                         ACL_TYPE_DEFAULT, cifs_sb->local_nls,
 211                                         cifs_sb->mnt_cifs_flags &
 212                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 213                         cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc);
 214 #else
 215                         cifs_dbg(FYI, "set default POSIX ACL not supported\n");
 216 #endif
 217                 } else {
 218                         cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n",
 219                                  ea_name);
 220                   /* BB what if no namespace prefix? */
 221                   /* Should we just pass them to server, except for
 222                   system and perhaps security prefixes? */
 223                 }
 224         }
 225
 226 set_ea_exit:
 227         kfree(full_path);
 228         free_xid(xid);
 229         cifs_put_tlink(tlink);
 230 #endif
 231         return rc;
 232 }
 233
 234 ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 235         void *ea_value, size_t buf_size)
 236 {
 237         ssize_t rc = -EOPNOTSUPP;
 238 #ifdef CONFIG_CIFS_XATTR
 239         unsigned int xid;
 240         struct cifs_sb_info *cifs_sb;
 241         struct tcon_link *tlink;
 242         struct cifs_tcon *pTcon;
 243         struct super_block *sb;
 244         char *full_path;
 245
 246         if (direntry == NULL)
 247                 return -EIO;
 248         if (direntry->d_inode == NULL)
 249                 return -EIO;
 250         sb = direntry->d_inode->i_sb;
 251         if (sb == NULL)
 252                 return -EIO;
 253
 254         cifs_sb = CIFS_SB(sb);
 255         tlink = cifs_sb_tlink(cifs_sb);
 256         if (IS_ERR(tlink))
 257                 return PTR_ERR(tlink);
 258         pTcon = tlink_tcon(tlink);
 259
 260         xid = get_xid();
 261
 262         full_path = build_path_from_dentry(direntry);
 263         if (full_path == NULL) {
 264                 rc = -ENOMEM;
 265                 goto get_ea_exit;
 266         }
 267         /* return dos attributes as pseudo xattr */
 268         /* return alt name if available as pseudo attr */
 269         if (ea_name == NULL) {
 270                 cifs_dbg(FYI, "Null xattr names not supported\n");
 271         } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)
 272                    == 0) {
 273                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 274                         goto get_ea_exit;
 275
 276                 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
 277                         cifs_dbg(FYI, "attempt to query cifs inode metadata\n");
 278                         /* revalidate/getattr then populate from inode */
 279                 } /* BB add else when above is implemented */
 280                 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */
 281                 if (pTcon->ses->server->ops->query_all_EAs)
 282                         rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 283                                 full_path, ea_name, ea_value, buf_size,
 284                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 285                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 286         } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
 287                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 288                         goto get_ea_exit;
 289
 290                 ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */
 291                 if (pTcon->ses->server->ops->query_all_EAs)
 292                         rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 293                                 full_path, ea_name, ea_value, buf_size,
 294                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 295                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 296         } else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
 297                           strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
 298 #ifdef CONFIG_CIFS_POSIX
 299                 if (sb->s_flags & MS_POSIXACL)
 300                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 301                                 ea_value, buf_size, ACL_TYPE_ACCESS,
 302                                 cifs_sb->local_nls,
 303                                 cifs_sb->mnt_cifs_flags &
 304                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 305 #else
 306                 cifs_dbg(FYI, "Query POSIX ACL not supported yet\n");
 307 #endif /* CONFIG_CIFS_POSIX */
 308         } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
 309                           strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 310 #ifdef CONFIG_CIFS_POSIX
 311                 if (sb->s_flags & MS_POSIXACL)
 312                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 313                                 ea_value, buf_size, ACL_TYPE_DEFAULT,
 314                                 cifs_sb->local_nls,
 315                                 cifs_sb->mnt_cifs_flags &
 316                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 317 #else
 318                 cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n");
 319 #endif /* CONFIG_CIFS_POSIX */
 320         } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL,
 321                                 strlen(CIFS_XATTR_CIFS_ACL)) == 0) {
 322 #ifdef CONFIG_CIFS_ACL
 323                         u32 acllen;
 324                         struct cifs_ntsd *pacl;
 325
 326                         pacl = get_cifs_acl(cifs_sb, direntry->d_inode,
 327                                                 full_path, &acllen);
 328                         if (IS_ERR(pacl)) {
 329                                 rc = PTR_ERR(pacl);
 330                                 cifs_dbg(VFS, "%s: error %zd getting sec desc\n",
 331                                          __func__, rc);
 332                         } else {
 333                                 if (ea_value) {
 334                                         if (acllen > buf_size)
 335                                                 acllen = -ERANGE;
 336                                         else
 337                                                 memcpy(ea_value, pacl, acllen);
 338                                 }
 339                                 rc = acllen;
 340                                 kfree(pacl);
 341                         }
 342 #else
 343                         cifs_dbg(FYI, "Query CIFS ACL not supported yet\n");
 344 #endif /* CONFIG_CIFS_ACL */
 345         } else if (strncmp(ea_name,
 346                   XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
 347                 cifs_dbg(FYI, "Trusted xattr namespace not supported yet\n");
 348         } else if (strncmp(ea_name,
 349                   XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
 350                 cifs_dbg(FYI, "Security xattr namespace not supported yet\n");
 351         } else
 352                 cifs_dbg(FYI,
 353                          "illegal xattr request %s (only user namespace supported)\n",
 354                          ea_name);
 355
 356         /* We could add an additional check for streams ie
 357             if proc/fs/cifs/streamstoxattr is set then
 358                 search server for EAs or streams to
 359                 returns as xattrs */
 360
 361         if (rc == -EINVAL)
 362                 rc = -EOPNOTSUPP;
 363
 364 get_ea_exit:
 365         kfree(full_path);
 366         free_xid(xid);
 367         cifs_put_tlink(tlink);
 368 #endif
 369         return rc;
 370 }
 371
 372 ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 373 {
 374         ssize_t rc = -EOPNOTSUPP;
 375 #ifdef CONFIG_CIFS_XATTR
 376         unsigned int xid;
 377         struct cifs_sb_info *cifs_sb;
 378         struct tcon_link *tlink;
 379         struct cifs_tcon *pTcon;
 380         struct super_block *sb;
 381         char *full_path;
 382
 383         if (direntry == NULL)
 384                 return -EIO;
 385         if (direntry->d_inode == NULL)
 386                 return -EIO;
 387         sb = direntry->d_inode->i_sb;
 388         if (sb == NULL)
 389                 return -EIO;
 390
 391         cifs_sb = CIFS_SB(sb);
 392         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 393                 return -EOPNOTSUPP;
 394
 395         tlink = cifs_sb_tlink(cifs_sb);
 396         if (IS_ERR(tlink))
 397                 return PTR_ERR(tlink);
 398         pTcon = tlink_tcon(tlink);
 399
 400         xid = get_xid();
 401
 402         full_path = build_path_from_dentry(direntry);
 403         if (full_path == NULL) {
 404                 rc = -ENOMEM;
 405                 goto list_ea_exit;
 406         }
 407         /* return dos attributes as pseudo xattr */
 408         /* return alt name if available as pseudo attr */
 409
 410         /* if proc/fs/cifs/streamstoxattr is set then
 411                 search server for EAs or streams to
 412                 returns as xattrs */
 413
 414         if (pTcon->ses->server->ops->query_all_EAs)
 415                 rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon,
 416                                 full_path, NULL, data, buf_size,
 417                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 418                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 419 list_ea_exit:
 420         kfree(full_path);
 421         free_xid(xid);
 422         cifs_put_tlink(tlink);
 423 #endif
 424         return rc;
 425 }