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 65535 35#define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib" 36#define CIFS_XATTR_CIFS_ACL "system.cifs_acl" 37 38/* BB need to add server (Samba e.g) support for security and trusted prefix */ 39 40int cifs_removexattr(struct dentry *direntry, const char *ea_name) 41{ 42 int rc = -EOPNOTSUPP; 43#ifdef CONFIG_CIFS_XATTR 44 unsigned int xid; 45 struct cifs_sb_info *cifs_sb; 46 struct tcon_link *tlink; 47 struct cifs_tcon *pTcon; 48 struct super_block *sb; 49 char *full_path = NULL; 50 51 if (direntry == NULL) 52 return -EIO; 53 if (d_really_is_negative(direntry)) 54 return -EIO; 55 sb = d_inode(direntry)->i_sb; 56 if (sb == NULL) 57 return -EIO; 58 59 cifs_sb = CIFS_SB(sb); 60 tlink = cifs_sb_tlink(cifs_sb); 61 if (IS_ERR(tlink)) 62 return PTR_ERR(tlink); 63 pTcon = tlink_tcon(tlink); 64 65 xid = get_xid(); 66 67 full_path = build_path_from_dentry(direntry); 68 if (full_path == NULL) { 69 rc = -ENOMEM; 70 goto remove_ea_exit; 71 } 72 if (ea_name == NULL) { 73 cifs_dbg(FYI, "Null xattr names not supported\n"); 74 } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) 75 && (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))) { 76 cifs_dbg(FYI, 77 "illegal xattr request %s (only user namespace supported)\n", 78 ea_name); 79 /* BB what if no namespace prefix? */ 80 /* Should we just pass them to server, except for 81 system and perhaps security prefixes? */ 82 } else { 83 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 84 goto remove_ea_exit; 85 86 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ 87 if (pTcon->ses->server->ops->set_EA) 88 rc = pTcon->ses->server->ops->set_EA(xid, pTcon, 89 full_path, ea_name, NULL, (__u16)0, 90 cifs_sb->local_nls, cifs_remap(cifs_sb)); 91 } 92remove_ea_exit: 93 kfree(full_path); 94 free_xid(xid); 95 cifs_put_tlink(tlink); 96#endif 97 return rc; 98} 99 100int cifs_setxattr(struct dentry *direntry, const char *ea_name, 101 const void *ea_value, size_t value_size, int flags) 102{ 103 int rc = -EOPNOTSUPP; 104#ifdef CONFIG_CIFS_XATTR 105 unsigned int xid; 106 struct cifs_sb_info *cifs_sb; 107 struct tcon_link *tlink; 108 struct cifs_tcon *pTcon; 109 struct super_block *sb; 110 char *full_path; 111 112 if (direntry == NULL) 113 return -EIO; 114 if (d_really_is_negative(direntry)) 115 return -EIO; 116 sb = d_inode(direntry)->i_sb; 117 if (sb == NULL) 118 return -EIO; 119 120 cifs_sb = CIFS_SB(sb); 121 tlink = cifs_sb_tlink(cifs_sb); 122 if (IS_ERR(tlink)) 123 return PTR_ERR(tlink); 124 pTcon = tlink_tcon(tlink); 125 126 xid = get_xid(); 127 128 full_path = build_path_from_dentry(direntry); 129 if (full_path == NULL) { 130 rc = -ENOMEM; 131 goto set_ea_exit; 132 } 133 /* return dos attributes as pseudo xattr */ 134 /* return alt name if available as pseudo attr */ 135 136 /* if proc/fs/cifs/streamstoxattr is set then 137 search server for EAs or streams to 138 returns as xattrs */ 139 if (value_size > MAX_EA_VALUE_SIZE) { 140 cifs_dbg(FYI, "size of EA value too large\n"); 141 rc = -EOPNOTSUPP; 142 goto set_ea_exit; 143 } 144 145 if (ea_name == NULL) { 146 cifs_dbg(FYI, "Null xattr names not supported\n"); 147 } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) 148 == 0) { 149 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 150 goto set_ea_exit; 151 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) 152 cifs_dbg(FYI, "attempt to set cifs inode metadata\n"); 153 154 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ 155 if (pTcon->ses->server->ops->set_EA) 156 rc = pTcon->ses->server->ops->set_EA(xid, pTcon, 157 full_path, ea_name, ea_value, (__u16)value_size, 158 cifs_sb->local_nls, cifs_remap(cifs_sb)); 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_remap(cifs_sb)); 169 } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL, 170 strlen(CIFS_XATTR_CIFS_ACL)) == 0) { 171#ifdef CONFIG_CIFS_ACL 172 struct cifs_ntsd *pacl; 173 pacl = kmalloc(value_size, GFP_KERNEL); 174 if (!pacl) { 175 rc = -ENOMEM; 176 } else { 177 memcpy(pacl, ea_value, value_size); 178 if (pTcon->ses->server->ops->set_acl) 179 rc = pTcon->ses->server->ops->set_acl(pacl, 180 value_size, d_inode(direntry), 181 full_path, CIFS_ACL_DACL); 182 else 183 rc = -EOPNOTSUPP; 184 if (rc == 0) /* force revalidate of the inode */ 185 CIFS_I(d_inode(direntry))->time = 0; 186 kfree(pacl); 187 } 188#else 189 cifs_dbg(FYI, "Set CIFS ACL not supported yet\n"); 190#endif /* CONFIG_CIFS_ACL */ 191 } else { 192 int temp; 193 temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS, 194 strlen(POSIX_ACL_XATTR_ACCESS)); 195 if (temp == 0) { 196#ifdef CONFIG_CIFS_POSIX 197 if (sb->s_flags & MS_POSIXACL) 198 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, 199 ea_value, (const int)value_size, 200 ACL_TYPE_ACCESS, cifs_sb->local_nls, 201 cifs_remap(cifs_sb)); 202 cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc); 203#else 204 cifs_dbg(FYI, "set POSIX ACL not supported\n"); 205#endif 206 } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT, 207 strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) { 208#ifdef CONFIG_CIFS_POSIX 209 if (sb->s_flags & MS_POSIXACL) 210 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, 211 ea_value, (const int)value_size, 212 ACL_TYPE_DEFAULT, cifs_sb->local_nls, 213 cifs_remap(cifs_sb)); 214 cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc); 215#else 216 cifs_dbg(FYI, "set default POSIX ACL not supported\n"); 217#endif 218 } else { 219 cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n", 220 ea_name); 221 /* BB what if no namespace prefix? */ 222 /* Should we just pass them to server, except for 223 system and perhaps security prefixes? */ 224 } 225 } 226 227set_ea_exit: 228 kfree(full_path); 229 free_xid(xid); 230 cifs_put_tlink(tlink); 231#endif 232 return rc; 233} 234 235ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name, 236 void *ea_value, size_t buf_size) 237{ 238 ssize_t rc = -EOPNOTSUPP; 239#ifdef CONFIG_CIFS_XATTR 240 unsigned int xid; 241 struct cifs_sb_info *cifs_sb; 242 struct tcon_link *tlink; 243 struct cifs_tcon *pTcon; 244 struct super_block *sb; 245 char *full_path; 246 247 if (direntry == NULL) 248 return -EIO; 249 if (d_really_is_negative(direntry)) 250 return -EIO; 251 sb = d_inode(direntry)->i_sb; 252 if (sb == NULL) 253 return -EIO; 254 255 cifs_sb = CIFS_SB(sb); 256 tlink = cifs_sb_tlink(cifs_sb); 257 if (IS_ERR(tlink)) 258 return PTR_ERR(tlink); 259 pTcon = tlink_tcon(tlink); 260 261 xid = get_xid(); 262 263 full_path = build_path_from_dentry(direntry); 264 if (full_path == NULL) { 265 rc = -ENOMEM; 266 goto get_ea_exit; 267 } 268 /* return dos attributes as pseudo xattr */ 269 /* return alt name if available as pseudo attr */ 270 if (ea_name == NULL) { 271 cifs_dbg(FYI, "Null xattr names not supported\n"); 272 } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) 273 == 0) { 274 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 275 goto get_ea_exit; 276 277 if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) { 278 cifs_dbg(FYI, "attempt to query cifs inode metadata\n"); 279 /* revalidate/getattr then populate from inode */ 280 } /* BB add else when above is implemented */ 281 ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ 282 if (pTcon->ses->server->ops->query_all_EAs) 283 rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, 284 full_path, ea_name, ea_value, buf_size, 285 cifs_sb->local_nls, cifs_remap(cifs_sb)); 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_remap(cifs_sb)); 295 } else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS, 296 strlen(POSIX_ACL_XATTR_ACCESS)) == 0) { 297#ifdef CONFIG_CIFS_POSIX 298 if (sb->s_flags & MS_POSIXACL) 299 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, 300 ea_value, buf_size, ACL_TYPE_ACCESS, 301 cifs_sb->local_nls, 302 cifs_remap(cifs_sb)); 303#else 304 cifs_dbg(FYI, "Query POSIX ACL not supported yet\n"); 305#endif /* CONFIG_CIFS_POSIX */ 306 } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT, 307 strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) { 308#ifdef CONFIG_CIFS_POSIX 309 if (sb->s_flags & MS_POSIXACL) 310 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, 311 ea_value, buf_size, ACL_TYPE_DEFAULT, 312 cifs_sb->local_nls, 313 cifs_remap(cifs_sb)); 314#else 315 cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n"); 316#endif /* CONFIG_CIFS_POSIX */ 317 } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL, 318 strlen(CIFS_XATTR_CIFS_ACL)) == 0) { 319#ifdef CONFIG_CIFS_ACL 320 u32 acllen; 321 struct cifs_ntsd *pacl; 322 323 if (pTcon->ses->server->ops->get_acl == NULL) 324 goto get_ea_exit; /* rc already EOPNOTSUPP */ 325 326 pacl = pTcon->ses->server->ops->get_acl(cifs_sb, 327 d_inode(direntry), 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 364get_ea_exit: 365 kfree(full_path); 366 free_xid(xid); 367 cifs_put_tlink(tlink); 368#endif 369 return rc; 370} 371 372ssize_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 (d_really_is_negative(direntry)) 386 return -EIO; 387 sb = d_inode(direntry)->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_remap(cifs_sb)); 418list_ea_exit: 419 kfree(full_path); 420 free_xid(xid); 421 cifs_put_tlink(tlink); 422#endif 423 return rc; 424} 425