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 "cifsfs.h"
  25 #include "cifspdu.h"
  26 #include "cifsglob.h"
  27 #include "cifsproto.h"
  28 #include "cifs_debug.h"
  29
  30 #define MAX_EA_VALUE_SIZE 65535
  31 #define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib"
  32 #define CIFS_XATTR_USER_PREFIX "user."
  33 #define CIFS_XATTR_SYSTEM_PREFIX "system."
  34 #define CIFS_XATTR_OS2_PREFIX "os2."
  35 #define CIFS_XATTR_SECURITY_PREFIX ".security"
  36 #define CIFS_XATTR_TRUSTED_PREFIX "trusted."
  37 #define XATTR_TRUSTED_PREFIX_LEN  8
  38 #define XATTR_SECURITY_PREFIX_LEN 9
  39 /* BB need to add server (Samba e.g) support for security and trusted prefix */
  40
  41
  42
  43 int cifs_removexattr(struct dentry *direntry, const char *ea_name)
  44 {
  45         int rc = -EOPNOTSUPP;
  46 #ifdef CONFIG_CIFS_XATTR
  47         int xid;
  48         struct cifs_sb_info *cifs_sb;
  49         struct cifsTconInfo *pTcon;
  50         struct super_block *sb;
  51         char *full_path;
  52
  53         if (direntry == NULL)
  54                 return -EIO;
  55         if (direntry->d_inode == NULL)
  56                 return -EIO;
  57         sb = direntry->d_inode->i_sb;
  58         if (sb == NULL)
  59                 return -EIO;
  60         xid = GetXid();
  61
  62         cifs_sb = CIFS_SB(sb);
  63         pTcon = cifs_sb->tcon;
  64
  65         full_path = build_path_from_dentry(direntry);
  66         if (full_path == NULL) {
  67                 rc = -ENOMEM;
  68                 FreeXid(xid);
  69                 return rc;
  70         }
  71         if (ea_name == NULL) {
  72                 cFYI(1, ("Null xattr names not supported"));
  73         } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5)
  74                 && (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4))) {
  75                 cFYI(1,
  76                     ("illegal xattr request %s (only user namespace supported)",
  77                         ea_name));
  78                 /* BB what if no namespace prefix? */
  79                 /* Should we just pass them to server, except for
  80                 system and perhaps security prefixes? */
  81         } else {
  82                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
  83                         goto remove_ea_exit;
  84
  85                 ea_name += 5; /* skip past user. prefix */
  86                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, NULL,
  87                         (__u16)0, cifs_sb->local_nls,
  88                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
  89         }
  90 remove_ea_exit:
  91         kfree(full_path);
  92         FreeXid(xid);
  93 #endif
  94         return rc;
  95 }
  96
  97 int cifs_setxattr(struct dentry *direntry, const char *ea_name,
  98                   const void *ea_value, size_t value_size, int flags)
  99 {
 100         int rc = -EOPNOTSUPP;
 101 #ifdef CONFIG_CIFS_XATTR
 102         int xid;
 103         struct cifs_sb_info *cifs_sb;
 104         struct cifsTconInfo *pTcon;
 105         struct super_block *sb;
 106         char *full_path;
 107
 108         if (direntry == NULL)
 109                 return -EIO;
 110         if (direntry->d_inode == NULL)
 111                 return -EIO;
 112         sb = direntry->d_inode->i_sb;
 113         if (sb == NULL)
 114                 return -EIO;
 115         xid = GetXid();
 116
 117         cifs_sb = CIFS_SB(sb);
 118         pTcon = cifs_sb->tcon;
 119
 120         full_path = build_path_from_dentry(direntry);
 121         if (full_path == NULL) {
 122                 rc = -ENOMEM;
 123                 FreeXid(xid);
 124                 return rc;
 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 (value_size > MAX_EA_VALUE_SIZE) {
 133                 cFYI(1, ("size of EA value too large"));
 134                 kfree(full_path);
 135                 FreeXid(xid);
 136                 return -EOPNOTSUPP;
 137         }
 138
 139         if (ea_name == NULL) {
 140                 cFYI(1, ("Null xattr names not supported"));
 141         } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
 142                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 143                         goto set_ea_exit;
 144                 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
 145                         cFYI(1, ("attempt to set cifs inode metadata"));
 146
 147                 ea_name += 5; /* skip past user. prefix */
 148                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
 149                         (__u16)value_size, cifs_sb->local_nls,
 150                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 151         } else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {
 152                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 153                         goto set_ea_exit;
 154
 155                 ea_name += 4; /* skip past os2. prefix */
 156                 rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
 157                         (__u16)value_size, cifs_sb->local_nls,
 158                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 159         } else {
 160                 int temp;
 161                 temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
 162                         strlen(POSIX_ACL_XATTR_ACCESS));
 163                 if (temp == 0) {
 164 #ifdef CONFIG_CIFS_POSIX
 165                         if (sb->s_flags & MS_POSIXACL)
 166                                 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 167                                         ea_value, (const int)value_size,
 168                                         ACL_TYPE_ACCESS, cifs_sb->local_nls,
 169                                         cifs_sb->mnt_cifs_flags &
 170                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 171                         cFYI(1, ("set POSIX ACL rc %d", rc));
 172 #else
 173                         cFYI(1, ("set POSIX ACL not supported"));
 174 #endif
 175                 } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
 176                                    strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 177 #ifdef CONFIG_CIFS_POSIX
 178                         if (sb->s_flags & MS_POSIXACL)
 179                                 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path,
 180                                         ea_value, (const int)value_size,
 181                                         ACL_TYPE_DEFAULT, cifs_sb->local_nls,
 182                                         cifs_sb->mnt_cifs_flags &
 183                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 184                         cFYI(1, ("set POSIX default ACL rc %d", rc));
 185 #else
 186                         cFYI(1, ("set default POSIX ACL not supported"));
 187 #endif
 188                 } else {
 189                         cFYI(1, ("illegal xattr request %s (only user namespace"
 190                                  " supported)", ea_name));
 191                   /* BB what if no namespace prefix? */
 192                   /* Should we just pass them to server, except for
 193                   system and perhaps security prefixes? */
 194                 }
 195         }
 196
 197 set_ea_exit:
 198         kfree(full_path);
 199         FreeXid(xid);
 200 #endif
 201         return rc;
 202 }
 203
 204 ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
 205         void *ea_value, size_t buf_size)
 206 {
 207         ssize_t rc = -EOPNOTSUPP;
 208 #ifdef CONFIG_CIFS_XATTR
 209         int xid;
 210         struct cifs_sb_info *cifs_sb;
 211         struct cifsTconInfo *pTcon;
 212         struct super_block *sb;
 213         char *full_path;
 214
 215         if (direntry == NULL)
 216                 return -EIO;
 217         if (direntry->d_inode == NULL)
 218                 return -EIO;
 219         sb = direntry->d_inode->i_sb;
 220         if (sb == NULL)
 221                 return -EIO;
 222
 223         xid = GetXid();
 224
 225         cifs_sb = CIFS_SB(sb);
 226         pTcon = cifs_sb->tcon;
 227
 228         full_path = build_path_from_dentry(direntry);
 229         if (full_path == NULL) {
 230                 rc = -ENOMEM;
 231                 FreeXid(xid);
 232                 return rc;
 233         }
 234         /* return dos attributes as pseudo xattr */
 235         /* return alt name if available as pseudo attr */
 236         if (ea_name == NULL) {
 237                 cFYI(1, ("Null xattr names not supported"));
 238         } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
 239                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 240                         goto get_ea_exit;
 241
 242                 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
 243                         cFYI(1, ("attempt to query cifs inode metadata"));
 244                         /* revalidate/getattr then populate from inode */
 245                 } /* BB add else when above is implemented */
 246                 ea_name += 5; /* skip past user. prefix */
 247                 rc = CIFSSMBQueryEA(xid, pTcon, full_path, ea_name, ea_value,
 248                         buf_size, cifs_sb->local_nls,
 249                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 250         } else if (strncmp(ea_name, CIFS_XATTR_OS2_PREFIX, 4) == 0) {
 251                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 252                         goto get_ea_exit;
 253
 254                 ea_name += 4; /* skip past os2. prefix */
 255                 rc = CIFSSMBQueryEA(xid, pTcon, full_path, ea_name, ea_value,
 256                         buf_size, cifs_sb->local_nls,
 257                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 258         } else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS,
 259                           strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
 260 #ifdef CONFIG_CIFS_POSIX
 261                 if (sb->s_flags & MS_POSIXACL)
 262                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 263                                 ea_value, buf_size, ACL_TYPE_ACCESS,
 264                                 cifs_sb->local_nls,
 265                                 cifs_sb->mnt_cifs_flags &
 266                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 267 #ifdef CONFIG_CIFS_EXPERIMENTAL
 268                 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 269                         __u16 fid;
 270                         int oplock = 0;
 271                         struct cifs_ntsd *pacl = NULL;
 272                         __u32 buflen = 0;
 273                         if (experimEnabled)
 274                                 rc = CIFSSMBOpen(xid, pTcon, full_path,
 275                                         FILE_OPEN, GENERIC_READ, 0, &fid,
 276                                         &oplock, NULL, cifs_sb->local_nls,
 277                                         cifs_sb->mnt_cifs_flags &
 278                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 279                         /* else rc is EOPNOTSUPP from above */
 280
 281                         if (rc == 0) {
 282                                 rc = CIFSSMBGetCIFSACL(xid, pTcon, fid, &pacl,
 283                                                       &buflen);
 284                                 CIFSSMBClose(xid, pTcon, fid);
 285                         }
 286                 }
 287 #endif /* EXPERIMENTAL */
 288 #else
 289                 cFYI(1, ("query POSIX ACL not supported yet"));
 290 #endif /* CONFIG_CIFS_POSIX */
 291         } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT,
 292                           strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 293 #ifdef CONFIG_CIFS_POSIX
 294                 if (sb->s_flags & MS_POSIXACL)
 295                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 296                                 ea_value, buf_size, ACL_TYPE_DEFAULT,
 297                                 cifs_sb->local_nls,
 298                                 cifs_sb->mnt_cifs_flags &
 299                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 300 #else
 301                 cFYI(1, ("query POSIX default ACL not supported yet"));
 302 #endif
 303         } else if (strncmp(ea_name,
 304                   CIFS_XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) {
 305                 cFYI(1, ("Trusted xattr namespace not supported yet"));
 306         } else if (strncmp(ea_name,
 307                   CIFS_XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
 308                 cFYI(1, ("Security xattr namespace not supported yet"));
 309         } else
 310                 cFYI(1,
 311                     ("illegal xattr request %s (only user namespace supported)",
 312                         ea_name));
 313
 314         /* We could add an additional check for streams ie
 315             if proc/fs/cifs/streamstoxattr is set then
 316                 search server for EAs or streams to
 317                 returns as xattrs */
 318
 319         if (rc == -EINVAL)
 320                 rc = -EOPNOTSUPP;
 321
 322 get_ea_exit:
 323         kfree(full_path);
 324         FreeXid(xid);
 325 #endif
 326         return rc;
 327 }
 328
 329 ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size)
 330 {
 331         ssize_t rc = -EOPNOTSUPP;
 332 #ifdef CONFIG_CIFS_XATTR
 333         int xid;
 334         struct cifs_sb_info *cifs_sb;
 335         struct cifsTconInfo *pTcon;
 336         struct super_block *sb;
 337         char *full_path;
 338
 339         if (direntry == NULL)
 340                 return -EIO;
 341         if (direntry->d_inode == NULL)
 342                 return -EIO;
 343         sb = direntry->d_inode->i_sb;
 344         if (sb == NULL)
 345                 return -EIO;
 346
 347         cifs_sb = CIFS_SB(sb);
 348         pTcon = cifs_sb->tcon;
 349
 350         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 351                 return -EOPNOTSUPP;
 352
 353         xid = GetXid();
 354
 355         full_path = build_path_from_dentry(direntry);
 356         if (full_path == NULL) {
 357                 rc = -ENOMEM;
 358                 FreeXid(xid);
 359                 return rc;
 360         }
 361         /* return dos attributes as pseudo xattr */
 362         /* return alt name if available as pseudo attr */
 363
 364         /* if proc/fs/cifs/streamstoxattr is set then
 365                 search server for EAs or streams to
 366                 returns as xattrs */
 367         rc = CIFSSMBQAllEAs(xid, pTcon, full_path, data, buf_size,
 368                                 cifs_sb->local_nls,
 369                                 cifs_sb->mnt_cifs_flags &
 370                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 371
 372         kfree(full_path);
 373         FreeXid(xid);
 374 #endif
 375         return rc;
 376 }