Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * fs/cifs/xattr.c |
| 3 | * |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 4 | * Copyright (c) International Business Machines Corp., 2003, 2007 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 24 | #include <linux/slab.h> |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 25 | #include <linux/xattr.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | #include "cifsfs.h" |
| 27 | #include "cifspdu.h" |
| 28 | #include "cifsglob.h" |
| 29 | #include "cifsproto.h" |
| 30 | #include "cifs_debug.h" |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 31 | #include "cifs_fs_sb.h" |
| 32 | #include "cifs_unicode.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
| 34 | #define MAX_EA_VALUE_SIZE 65535 |
| 35 | #define CIFS_XATTR_DOS_ATTRIB "user.DosAttrib" |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 36 | #define CIFS_XATTR_CIFS_ACL "system.cifs_acl" |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 37 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | /* BB need to add server (Samba e.g) support for security and trusted prefix */ |
Steve French | 50c2f75 | 2007-07-13 00:33:32 +0000 | [diff] [blame] | 39 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 40 | int cifs_removexattr(struct dentry *direntry, const char *ea_name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | { |
| 42 | int rc = -EOPNOTSUPP; |
| 43 | #ifdef CONFIG_CIFS_XATTR |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 44 | unsigned int xid; |
Al Viro | 5fdccfe | 2016-04-10 17:07:33 -0400 | [diff] [blame] | 45 | struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 46 | struct tcon_link *tlink; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 47 | struct cifs_tcon *pTcon; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 48 | char *full_path = NULL; |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 49 | |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 50 | tlink = cifs_sb_tlink(cifs_sb); |
| 51 | if (IS_ERR(tlink)) |
| 52 | return PTR_ERR(tlink); |
| 53 | pTcon = tlink_tcon(tlink); |
| 54 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 55 | xid = get_xid(); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 56 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | full_path = build_path_from_dentry(direntry); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 58 | if (full_path == NULL) { |
Suresh Jayaraman | 0f3bc09 | 2009-06-25 18:12:34 +0530 | [diff] [blame] | 59 | rc = -ENOMEM; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 60 | goto remove_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | } |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 62 | if (ea_name == NULL) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 63 | cifs_dbg(FYI, "Null xattr names not supported\n"); |
Andreas Gruenbacher | 534bb0c | 2016-04-14 00:30:15 +0200 | [diff] [blame^] | 64 | } else if (!strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 65 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | goto remove_ea_exit; |
| 67 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 68 | ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 69 | if (pTcon->ses->server->ops->set_EA) |
| 70 | rc = pTcon->ses->server->ops->set_EA(xid, pTcon, |
| 71 | full_path, ea_name, NULL, (__u16)0, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 72 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Andreas Gruenbacher | 534bb0c | 2016-04-14 00:30:15 +0200 | [diff] [blame^] | 73 | } else if (!strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN)) { |
| 74 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
| 75 | goto remove_ea_exit; |
| 76 | |
| 77 | ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */ |
| 78 | if (pTcon->ses->server->ops->set_EA) |
| 79 | rc = pTcon->ses->server->ops->set_EA(xid, pTcon, |
| 80 | full_path, ea_name, NULL, (__u16)0, |
| 81 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
| 82 | } else { |
| 83 | cifs_dbg(FYI, |
| 84 | "illegal xattr request %s (only user namespace supported)\n", |
| 85 | ea_name); |
| 86 | /* BB what if no namespace prefix? */ |
| 87 | /* Should we just pass them to server, except for |
| 88 | system and perhaps security prefixes? */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | } |
| 90 | remove_ea_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 91 | kfree(full_path); |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 92 | free_xid(xid); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 93 | cifs_put_tlink(tlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 94 | #endif |
| 95 | return rc; |
| 96 | } |
| 97 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 98 | int cifs_setxattr(struct dentry *direntry, const char *ea_name, |
| 99 | const void *ea_value, size_t value_size, int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | { |
| 101 | int rc = -EOPNOTSUPP; |
| 102 | #ifdef CONFIG_CIFS_XATTR |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 103 | unsigned int xid; |
Al Viro | 5fdccfe | 2016-04-10 17:07:33 -0400 | [diff] [blame] | 104 | struct super_block *sb = direntry->d_sb; |
| 105 | struct cifs_sb_info *cifs_sb = CIFS_SB(sb); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 106 | struct tcon_link *tlink; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 107 | struct cifs_tcon *pTcon; |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 108 | char *full_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 110 | tlink = cifs_sb_tlink(cifs_sb); |
| 111 | if (IS_ERR(tlink)) |
| 112 | return PTR_ERR(tlink); |
| 113 | pTcon = tlink_tcon(tlink); |
| 114 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 115 | xid = get_xid(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | full_path = build_path_from_dentry(direntry); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 118 | if (full_path == NULL) { |
Suresh Jayaraman | 0f3bc09 | 2009-06-25 18:12:34 +0530 | [diff] [blame] | 119 | rc = -ENOMEM; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 120 | goto set_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | } |
| 122 | /* return dos attributes as pseudo xattr */ |
| 123 | /* return alt name if available as pseudo attr */ |
| 124 | |
| 125 | /* if proc/fs/cifs/streamstoxattr is set then |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 126 | search server for EAs or streams to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | returns as xattrs */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 128 | if (value_size > MAX_EA_VALUE_SIZE) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 129 | cifs_dbg(FYI, "size of EA value too large\n"); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 130 | rc = -EOPNOTSUPP; |
| 131 | goto set_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | } |
| 133 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 134 | if (ea_name == NULL) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 135 | cifs_dbg(FYI, "Null xattr names not supported\n"); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 136 | } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) |
| 137 | == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 138 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | goto set_ea_exit; |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 140 | if (strcmp(ea_name, CIFS_XATTR_DOS_ATTRIB) == 0) |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 141 | cifs_dbg(FYI, "attempt to set cifs inode metadata\n"); |
Steve French | ad7a292 | 2008-02-07 23:25:02 +0000 | [diff] [blame] | 142 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 143 | ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 144 | if (pTcon->ses->server->ops->set_EA) |
| 145 | rc = pTcon->ses->server->ops->set_EA(xid, pTcon, |
| 146 | full_path, ea_name, ea_value, (__u16)value_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 147 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 148 | } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) |
| 149 | == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 150 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | goto set_ea_exit; |
| 152 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 153 | ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 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, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 157 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 158 | } else if (strcmp(ea_name, CIFS_XATTR_CIFS_ACL) == 0) { |
Santosh Nayak | b0f8ef2 | 2012-03-02 11:47:26 +0530 | [diff] [blame] | 159 | #ifdef CONFIG_CIFS_ACL |
| 160 | struct cifs_ntsd *pacl; |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 161 | pacl = kmalloc(value_size, GFP_KERNEL); |
| 162 | if (!pacl) { |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 163 | rc = -ENOMEM; |
| 164 | } else { |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 165 | memcpy(pacl, ea_value, value_size); |
Steve French | 83e3bc2 | 2014-02-02 23:31:47 -0600 | [diff] [blame] | 166 | if (pTcon->ses->server->ops->set_acl) |
| 167 | rc = pTcon->ses->server->ops->set_acl(pacl, |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 168 | value_size, d_inode(direntry), |
Steve French | 83e3bc2 | 2014-02-02 23:31:47 -0600 | [diff] [blame] | 169 | full_path, CIFS_ACL_DACL); |
| 170 | else |
| 171 | rc = -EOPNOTSUPP; |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 172 | if (rc == 0) /* force revalidate of the inode */ |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 173 | CIFS_I(d_inode(direntry))->time = 0; |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 174 | kfree(pacl); |
Santosh Nayak | b0f8ef2 | 2012-03-02 11:47:26 +0530 | [diff] [blame] | 175 | } |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 176 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 177 | cifs_dbg(FYI, "Set CIFS ACL not supported yet\n"); |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 178 | #endif /* CONFIG_CIFS_ACL */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | } else { |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 180 | if (strcmp(ea_name, XATTR_NAME_POSIX_ACL_ACCESS) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 182 | if (sb->s_flags & MS_POSIXACL) |
| 183 | rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, |
| 184 | ea_value, (const int)value_size, |
| 185 | ACL_TYPE_ACCESS, cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 186 | cifs_remap(cifs_sb)); |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 187 | cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 189 | cifs_dbg(FYI, "set POSIX ACL not supported\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | #endif |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 191 | } else if (strcmp(ea_name, XATTR_NAME_POSIX_ACL_DEFAULT) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 193 | if (sb->s_flags & MS_POSIXACL) |
| 194 | rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, |
| 195 | ea_value, (const int)value_size, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 196 | ACL_TYPE_DEFAULT, cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 197 | cifs_remap(cifs_sb)); |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 198 | cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 200 | cifs_dbg(FYI, "set default POSIX ACL not supported\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | #endif |
| 202 | } else { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 203 | cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n", |
| 204 | ea_name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | /* BB what if no namespace prefix? */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 206 | /* Should we just pass them to server, except for |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | system and perhaps security prefixes? */ |
| 208 | } |
| 209 | } |
| 210 | |
| 211 | set_ea_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 212 | kfree(full_path); |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 213 | free_xid(xid); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 214 | cifs_put_tlink(tlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | #endif |
| 216 | return rc; |
| 217 | } |
| 218 | |
Al Viro | ce23e64 | 2016-04-11 00:48:00 -0400 | [diff] [blame] | 219 | ssize_t cifs_getxattr(struct dentry *direntry, struct inode *inode, |
| 220 | const char *ea_name, void *ea_value, size_t buf_size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | { |
| 222 | ssize_t rc = -EOPNOTSUPP; |
| 223 | #ifdef CONFIG_CIFS_XATTR |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 224 | unsigned int xid; |
Al Viro | 5fdccfe | 2016-04-10 17:07:33 -0400 | [diff] [blame] | 225 | struct super_block *sb = direntry->d_sb; |
| 226 | struct cifs_sb_info *cifs_sb = CIFS_SB(sb); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 227 | struct tcon_link *tlink; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 228 | struct cifs_tcon *pTcon; |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 229 | char *full_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 231 | tlink = cifs_sb_tlink(cifs_sb); |
| 232 | if (IS_ERR(tlink)) |
| 233 | return PTR_ERR(tlink); |
| 234 | pTcon = tlink_tcon(tlink); |
| 235 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 236 | xid = get_xid(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | full_path = build_path_from_dentry(direntry); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 239 | if (full_path == NULL) { |
Suresh Jayaraman | 0f3bc09 | 2009-06-25 18:12:34 +0530 | [diff] [blame] | 240 | rc = -ENOMEM; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 241 | goto get_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | } |
| 243 | /* return dos attributes as pseudo xattr */ |
| 244 | /* return alt name if available as pseudo attr */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 245 | if (ea_name == NULL) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 246 | cifs_dbg(FYI, "Null xattr names not supported\n"); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 247 | } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) |
| 248 | == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 249 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 250 | goto get_ea_exit; |
| 251 | |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 252 | if (strcmp(ea_name, CIFS_XATTR_DOS_ATTRIB) == 0) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 253 | cifs_dbg(FYI, "attempt to query cifs inode metadata\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 254 | /* revalidate/getattr then populate from inode */ |
| 255 | } /* BB add else when above is implemented */ |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 256 | ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 257 | if (pTcon->ses->server->ops->query_all_EAs) |
| 258 | rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, |
| 259 | full_path, ea_name, ea_value, buf_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 260 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 261 | } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 262 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 263 | goto get_ea_exit; |
| 264 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 265 | ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 266 | if (pTcon->ses->server->ops->query_all_EAs) |
| 267 | rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, |
| 268 | full_path, ea_name, ea_value, buf_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 269 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 270 | } else if (strcmp(ea_name, XATTR_NAME_POSIX_ACL_ACCESS) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 272 | if (sb->s_flags & MS_POSIXACL) |
Steve French | 1da0c78 | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 273 | rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 274 | ea_value, buf_size, ACL_TYPE_ACCESS, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 275 | cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 276 | cifs_remap(cifs_sb)); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 277 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 278 | cifs_dbg(FYI, "Query POSIX ACL not supported yet\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | #endif /* CONFIG_CIFS_POSIX */ |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 280 | } else if (strcmp(ea_name, XATTR_NAME_POSIX_ACL_DEFAULT) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 282 | if (sb->s_flags & MS_POSIXACL) |
Steve French | 1da0c78 | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 283 | rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 284 | ea_value, buf_size, ACL_TYPE_DEFAULT, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 285 | cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 286 | cifs_remap(cifs_sb)); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 287 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 288 | cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n"); |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 289 | #endif /* CONFIG_CIFS_POSIX */ |
Andreas Gruenbacher | d9a1548 | 2016-04-14 00:30:13 +0200 | [diff] [blame] | 290 | } else if (strcmp(ea_name, CIFS_XATTR_CIFS_ACL) == 0) { |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 291 | #ifdef CONFIG_CIFS_ACL |
| 292 | u32 acllen; |
| 293 | struct cifs_ntsd *pacl; |
| 294 | |
Steve French | 83e3bc2 | 2014-02-02 23:31:47 -0600 | [diff] [blame] | 295 | if (pTcon->ses->server->ops->get_acl == NULL) |
| 296 | goto get_ea_exit; /* rc already EOPNOTSUPP */ |
| 297 | |
| 298 | pacl = pTcon->ses->server->ops->get_acl(cifs_sb, |
Al Viro | ce23e64 | 2016-04-11 00:48:00 -0400 | [diff] [blame] | 299 | inode, full_path, &acllen); |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 300 | if (IS_ERR(pacl)) { |
| 301 | rc = PTR_ERR(pacl); |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 302 | cifs_dbg(VFS, "%s: error %zd getting sec desc\n", |
| 303 | __func__, rc); |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 304 | } else { |
| 305 | if (ea_value) { |
| 306 | if (acllen > buf_size) |
| 307 | acllen = -ERANGE; |
| 308 | else |
| 309 | memcpy(ea_value, pacl, acllen); |
| 310 | } |
| 311 | rc = acllen; |
| 312 | kfree(pacl); |
| 313 | } |
| 314 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 315 | cifs_dbg(FYI, "Query CIFS ACL not supported yet\n"); |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 316 | #endif /* CONFIG_CIFS_ACL */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 317 | } else if (strncmp(ea_name, |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 318 | XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 319 | cifs_dbg(FYI, "Trusted xattr namespace not supported yet\n"); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 320 | } else if (strncmp(ea_name, |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 321 | XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 322 | cifs_dbg(FYI, "Security xattr namespace not supported yet\n"); |
Steve French | ad7a292 | 2008-02-07 23:25:02 +0000 | [diff] [blame] | 323 | } else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 324 | cifs_dbg(FYI, |
| 325 | "illegal xattr request %s (only user namespace supported)\n", |
| 326 | ea_name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 328 | /* We could add an additional check for streams ie |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | if proc/fs/cifs/streamstoxattr is set then |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 330 | search server for EAs or streams to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | returns as xattrs */ |
| 332 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 333 | if (rc == -EINVAL) |
| 334 | rc = -EOPNOTSUPP; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | |
| 336 | get_ea_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 337 | kfree(full_path); |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 338 | free_xid(xid); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 339 | cifs_put_tlink(tlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | #endif |
| 341 | return rc; |
| 342 | } |
| 343 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 344 | ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | { |
| 346 | ssize_t rc = -EOPNOTSUPP; |
| 347 | #ifdef CONFIG_CIFS_XATTR |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 348 | unsigned int xid; |
Al Viro | 5fdccfe | 2016-04-10 17:07:33 -0400 | [diff] [blame] | 349 | struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 350 | struct tcon_link *tlink; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 351 | struct cifs_tcon *pTcon; |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 352 | char *full_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 354 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Steve French | ea4c07d | 2006-08-16 19:44:25 +0000 | [diff] [blame] | 355 | return -EOPNOTSUPP; |
| 356 | |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 357 | tlink = cifs_sb_tlink(cifs_sb); |
| 358 | if (IS_ERR(tlink)) |
| 359 | return PTR_ERR(tlink); |
| 360 | pTcon = tlink_tcon(tlink); |
| 361 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 362 | xid = get_xid(); |
Steve French | ea4c07d | 2006-08-16 19:44:25 +0000 | [diff] [blame] | 363 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 364 | full_path = build_path_from_dentry(direntry); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 365 | if (full_path == NULL) { |
Suresh Jayaraman | 0f3bc09 | 2009-06-25 18:12:34 +0530 | [diff] [blame] | 366 | rc = -ENOMEM; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 367 | goto list_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | } |
| 369 | /* return dos attributes as pseudo xattr */ |
| 370 | /* return alt name if available as pseudo attr */ |
| 371 | |
| 372 | /* if proc/fs/cifs/streamstoxattr is set then |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 373 | search server for EAs or streams to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 374 | returns as xattrs */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 376 | if (pTcon->ses->server->ops->query_all_EAs) |
| 377 | rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, |
| 378 | full_path, NULL, data, buf_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 379 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 380 | list_ea_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 381 | kfree(full_path); |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 382 | free_xid(xid); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 383 | cifs_put_tlink(tlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | #endif |
| 385 | return rc; |
| 386 | } |