fs/cifs/xattr.c

   1 /*
   2  *   fs/cifs/xattr.c
   3  *
   4  *   Copyright (c) International Business Machines  Corp., 2003
   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         down(&sb->s_vfs_rename_sem);
  66         full_path = build_path_from_dentry(direntry);
  67         up(&sb->s_vfs_rename_sem);
  68         if(full_path == NULL) {
  69                 FreeXid(xid);
  70                 return -ENOMEM;
  71         }
  72         if(ea_name == NULL) {
  73                 cFYI(1,("Null xattr names not supported"));
  74         } else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5)
  75                 && (strncmp(ea_name,CIFS_XATTR_OS2_PREFIX,4))) {
  76                 cFYI(1,("illegal xattr namespace %s (only user namespace supported)",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+=5; /* skip past user. prefix */
  85                 rc = CIFSSMBSetEA(xid,pTcon,full_path,ea_name,NULL,
  86                         (__u16)0, cifs_sb->local_nls,
  87                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
  88         }
  89 remove_ea_exit:
  90         kfree(full_path);
  91         FreeXid(xid);
  92 #endif
  93         return rc;
  94 }
  95
  96 int cifs_setxattr(struct dentry * direntry, const char * ea_name,
  97         const void * ea_value, size_t value_size, int flags)
  98 {
  99         int rc = -EOPNOTSUPP;
 100 #ifdef CONFIG_CIFS_XATTR
 101         int xid;
 102         struct cifs_sb_info *cifs_sb;
 103         struct cifsTconInfo *pTcon;
 104         struct super_block * sb;
 105         char * full_path;
 106
 107         if(direntry == NULL)
 108                 return -EIO;
 109         if(direntry->d_inode == NULL)
 110                 return -EIO;
 111         sb = direntry->d_inode->i_sb;
 112         if(sb == NULL)
 113                 return -EIO;
 114         xid = GetXid();
 115
 116         cifs_sb = CIFS_SB(sb);
 117         pTcon = cifs_sb->tcon;
 118
 119         down(&sb->s_vfs_rename_sem);
 120         full_path = build_path_from_dentry(direntry);
 121         up(&sb->s_vfs_rename_sem);
 122         if(full_path == NULL) {
 123                 FreeXid(xid);
 124                 return -ENOMEM;
 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,strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 176 #ifdef CONFIG_CIFS_POSIX
 177                         if(sb->s_flags & MS_POSIXACL)
 178                                 rc = CIFSSMBSetPosixACL(xid, pTcon,full_path,
 179                                         ea_value, (const int)value_size,
 180                                         ACL_TYPE_DEFAULT, cifs_sb->local_nls,
 181                                         cifs_sb->mnt_cifs_flags &
 182                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 183                         cFYI(1,("set POSIX default ACL rc %d",rc));
 184 #else
 185                         cFYI(1,("set default POSIX ACL not supported"));
 186 #endif
 187                 } else {
 188                         cFYI(1,("illegal xattr request %s (only user namespace supported)",ea_name));
 189                   /* BB what if no namespace prefix? */
 190                   /* Should we just pass them to server, except for
 191                   system and perhaps security prefixes? */
 192                 }
 193         }
 194
 195 set_ea_exit:
 196         kfree(full_path);
 197         FreeXid(xid);
 198 #endif
 199         return rc;
 200 }
 201
 202 ssize_t cifs_getxattr(struct dentry * direntry, const char * ea_name,
 203          void * ea_value, size_t buf_size)
 204 {
 205         ssize_t rc = -EOPNOTSUPP;
 206 #ifdef CONFIG_CIFS_XATTR
 207         int xid;
 208         struct cifs_sb_info *cifs_sb;
 209         struct cifsTconInfo *pTcon;
 210         struct super_block * sb;
 211         char * full_path;
 212
 213         if(direntry == NULL)
 214                 return -EIO;
 215         if(direntry->d_inode == NULL)
 216                 return -EIO;
 217         sb = direntry->d_inode->i_sb;
 218         if(sb == NULL)
 219                 return -EIO;
 220
 221         xid = GetXid();
 222
 223         cifs_sb = CIFS_SB(sb);
 224         pTcon = cifs_sb->tcon;
 225
 226         down(&sb->s_vfs_rename_sem);
 227         full_path = build_path_from_dentry(direntry);
 228         up(&sb->s_vfs_rename_sem);
 229         if(full_path == NULL) {
 230                 FreeXid(xid);
 231                 return -ENOMEM;
 232         }
 233         /* return dos attributes as pseudo xattr */
 234         /* return alt name if available as pseudo attr */
 235         if(ea_name == NULL) {
 236                 cFYI(1,("Null xattr names not supported"));
 237         } else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5) == 0) {
 238                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 239                         goto get_ea_exit;
 240
 241                 if(strncmp(ea_name,CIFS_XATTR_DOS_ATTRIB,14) == 0) {
 242                         cFYI(1,("attempt to query cifs inode metadata"));
 243                         /* revalidate/getattr then populate from inode */
 244                 } /* BB add else when above is implemented */
 245                 ea_name += 5; /* skip past user. prefix */
 246                 rc = CIFSSMBQueryEA(xid,pTcon,full_path,ea_name,ea_value,
 247                         buf_size, cifs_sb->local_nls,
 248                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 249         } else if(strncmp(ea_name, CIFS_XATTR_OS2_PREFIX,4) == 0) {
 250                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
 251                         goto get_ea_exit;
 252
 253                 ea_name += 4; /* skip past os2. prefix */
 254                 rc = CIFSSMBQueryEA(xid,pTcon,full_path,ea_name,ea_value,
 255                         buf_size, cifs_sb->local_nls,
 256                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 257         } else if(strncmp(ea_name,POSIX_ACL_XATTR_ACCESS,
 258                           strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
 259 #ifdef CONFIG_CIFS_POSIX
 260                 if(sb->s_flags & MS_POSIXACL)
 261                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 262                                 ea_value, buf_size, ACL_TYPE_ACCESS,
 263                                 cifs_sb->local_nls,
 264                                 cifs_sb->mnt_cifs_flags &
 265                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 266 /*              else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 267                         __u16 fid;
 268                         int oplock = FALSE;
 269                         rc = CIFSSMBOpen(xid, pTcon, full_path,
 270                                          FILE_OPEN, GENERIC_READ, 0, &fid,
 271                                          &oplock, NULL, cifs_sb->local_nls,
 272                                          cifs_sb->mnt_cifs_flags &
 273                                          CIFS_MOUNT_MAP_SPECIAL_CHR);
 274                         if(rc == 0) {
 275                                 rc = CIFSSMBGetCIFSACL(xid, pTcon, fid,
 276                                         ea_value, buf_size,
 277                                         ACL_TYPE_ACCESS);
 278                                 CIFSSMBClose(xid, pTcon, fid)
 279                         }
 280                 } */  /* BB enable after fixing up return data */
 281
 282 #else
 283                 cFYI(1,("query POSIX ACL not supported yet"));
 284 #endif /* CONFIG_CIFS_POSIX */
 285         } else if(strncmp(ea_name,POSIX_ACL_XATTR_DEFAULT,
 286                           strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
 287 #ifdef CONFIG_CIFS_POSIX
 288                 if(sb->s_flags & MS_POSIXACL)
 289                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
 290                                 ea_value, buf_size, ACL_TYPE_DEFAULT,
 291                                 cifs_sb->local_nls,
 292                                 cifs_sb->mnt_cifs_flags &
 293                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 294 #else
 295                 cFYI(1,("query POSIX default ACL not supported yet"));
 296 #endif
 297         } else if(strncmp(ea_name,
 298                   CIFS_XATTR_TRUSTED_PREFIX,XATTR_TRUSTED_PREFIX_LEN) == 0) {
 299                 cFYI(1,("Trusted xattr namespace not supported yet"));
 300         } else if(strncmp(ea_name,
 301                   CIFS_XATTR_SECURITY_PREFIX,XATTR_SECURITY_PREFIX_LEN) == 0) {
 302                 cFYI(1,("Security xattr namespace not supported yet"));
 303         } else {
 304                 cFYI(1,("illegal xattr name request %s (only user namespace supported)",ea_name));
 305         }
 306
 307         /* We could add an additional check for streams ie
 308             if proc/fs/cifs/streamstoxattr is set then
 309                 search server for EAs or streams to
 310                 returns as xattrs */
 311
 312         if(rc == -EINVAL)
 313                 rc = -EOPNOTSUPP;
 314
 315 get_ea_exit:
 316         kfree(full_path);
 317         FreeXid(xid);
 318 #endif
 319         return rc;
 320 }
 321
 322 ssize_t cifs_listxattr(struct dentry * direntry, char * data, size_t buf_size)
 323 {
 324         ssize_t rc = -EOPNOTSUPP;
 325 #ifdef CONFIG_CIFS_XATTR
 326         int xid;
 327         struct cifs_sb_info *cifs_sb;
 328         struct cifsTconInfo *pTcon;
 329         struct super_block * sb;
 330         char * full_path;
 331
 332         if(direntry == NULL)
 333                 return -EIO;
 334         if(direntry->d_inode == NULL)
 335                 return -EIO;
 336         sb = direntry->d_inode->i_sb;
 337         if(sb == NULL)
 338                 return -EIO;
 339         xid = GetXid();
 340
 341         cifs_sb = CIFS_SB(sb);
 342         pTcon = cifs_sb->tcon;
 343
 344         down(&sb->s_vfs_rename_sem);
 345         full_path = build_path_from_dentry(direntry);
 346         up(&sb->s_vfs_rename_sem);
 347         if(full_path == NULL) {
 348                 FreeXid(xid);
 349                 return -ENOMEM;
 350         }
 351         /* return dos attributes as pseudo xattr */
 352         /* return alt name if available as pseudo attr */
 353
 354         /* if proc/fs/cifs/streamstoxattr is set then
 355                 search server for EAs or streams to
 356                 returns as xattrs */
 357         rc = CIFSSMBQAllEAs(xid,pTcon,full_path,data,buf_size,
 358                                 cifs_sb->local_nls,
 359                                 cifs_sb->mnt_cifs_flags &
 360                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 361
 362         kfree(full_path);
 363         FreeXid(xid);
 364 #endif
 365         return rc;
 366 }