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"); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 64 | } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) |
| 65 | && (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 66 | cifs_dbg(FYI, |
| 67 | "illegal xattr request %s (only user namespace supported)\n", |
| 68 | ea_name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | /* BB what if no namespace prefix? */ |
| 70 | /* Should we just pass them to server, except for |
| 71 | system and perhaps security prefixes? */ |
| 72 | } else { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 73 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | goto remove_ea_exit; |
| 75 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 76 | ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 77 | if (pTcon->ses->server->ops->set_EA) |
| 78 | rc = pTcon->ses->server->ops->set_EA(xid, pTcon, |
| 79 | full_path, ea_name, NULL, (__u16)0, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 80 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | } |
| 82 | remove_ea_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 83 | kfree(full_path); |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 84 | free_xid(xid); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 85 | cifs_put_tlink(tlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 86 | #endif |
| 87 | return rc; |
| 88 | } |
| 89 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 90 | int cifs_setxattr(struct dentry *direntry, const char *ea_name, |
| 91 | const void *ea_value, size_t value_size, int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | { |
| 93 | int rc = -EOPNOTSUPP; |
| 94 | #ifdef CONFIG_CIFS_XATTR |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 95 | unsigned int xid; |
Al Viro | 5fdccfe | 2016-04-10 17:07:33 -0400 | [diff] [blame^] | 96 | struct super_block *sb = direntry->d_sb; |
| 97 | struct cifs_sb_info *cifs_sb = CIFS_SB(sb); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 98 | struct tcon_link *tlink; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 99 | struct cifs_tcon *pTcon; |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 100 | char *full_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 102 | tlink = cifs_sb_tlink(cifs_sb); |
| 103 | if (IS_ERR(tlink)) |
| 104 | return PTR_ERR(tlink); |
| 105 | pTcon = tlink_tcon(tlink); |
| 106 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 107 | xid = get_xid(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | full_path = build_path_from_dentry(direntry); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 110 | if (full_path == NULL) { |
Suresh Jayaraman | 0f3bc09 | 2009-06-25 18:12:34 +0530 | [diff] [blame] | 111 | rc = -ENOMEM; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 112 | goto set_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | } |
| 114 | /* return dos attributes as pseudo xattr */ |
| 115 | /* return alt name if available as pseudo attr */ |
| 116 | |
| 117 | /* if proc/fs/cifs/streamstoxattr is set then |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 118 | search server for EAs or streams to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | returns as xattrs */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 120 | if (value_size > MAX_EA_VALUE_SIZE) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 121 | cifs_dbg(FYI, "size of EA value too large\n"); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 122 | rc = -EOPNOTSUPP; |
| 123 | goto set_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 126 | if (ea_name == NULL) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 127 | cifs_dbg(FYI, "Null xattr names not supported\n"); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 128 | } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) |
| 129 | == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 130 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | goto set_ea_exit; |
Steve French | ad7a292 | 2008-02-07 23:25:02 +0000 | [diff] [blame] | 132 | if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 133 | cifs_dbg(FYI, "attempt to set cifs inode metadata\n"); |
Steve French | ad7a292 | 2008-02-07 23:25:02 +0000 | [diff] [blame] | 134 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 135 | ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 136 | if (pTcon->ses->server->ops->set_EA) |
| 137 | rc = pTcon->ses->server->ops->set_EA(xid, pTcon, |
| 138 | full_path, ea_name, ea_value, (__u16)value_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 139 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 140 | } else if (strncmp(ea_name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) |
| 141 | == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 142 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | goto set_ea_exit; |
| 144 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 145 | ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 146 | if (pTcon->ses->server->ops->set_EA) |
| 147 | rc = pTcon->ses->server->ops->set_EA(xid, pTcon, |
| 148 | full_path, ea_name, ea_value, (__u16)value_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 149 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 150 | } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL, |
| 151 | strlen(CIFS_XATTR_CIFS_ACL)) == 0) { |
Santosh Nayak | b0f8ef2 | 2012-03-02 11:47:26 +0530 | [diff] [blame] | 152 | #ifdef CONFIG_CIFS_ACL |
| 153 | struct cifs_ntsd *pacl; |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 154 | pacl = kmalloc(value_size, GFP_KERNEL); |
| 155 | if (!pacl) { |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 156 | rc = -ENOMEM; |
| 157 | } else { |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 158 | memcpy(pacl, ea_value, value_size); |
Steve French | 83e3bc2 | 2014-02-02 23:31:47 -0600 | [diff] [blame] | 159 | if (pTcon->ses->server->ops->set_acl) |
| 160 | rc = pTcon->ses->server->ops->set_acl(pacl, |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 161 | value_size, d_inode(direntry), |
Steve French | 83e3bc2 | 2014-02-02 23:31:47 -0600 | [diff] [blame] | 162 | full_path, CIFS_ACL_DACL); |
| 163 | else |
| 164 | rc = -EOPNOTSUPP; |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 165 | if (rc == 0) /* force revalidate of the inode */ |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 166 | CIFS_I(d_inode(direntry))->time = 0; |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 167 | kfree(pacl); |
Santosh Nayak | b0f8ef2 | 2012-03-02 11:47:26 +0530 | [diff] [blame] | 168 | } |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 169 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 170 | cifs_dbg(FYI, "Set CIFS ACL not supported yet\n"); |
Steve French | b73b9a4 | 2011-04-19 18:27:10 +0000 | [diff] [blame] | 171 | #endif /* CONFIG_CIFS_ACL */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | } else { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 173 | int temp; |
Andreas Gruenbacher | 97d7929 | 2015-12-02 14:44:35 +0100 | [diff] [blame] | 174 | temp = strncmp(ea_name, XATTR_NAME_POSIX_ACL_ACCESS, |
| 175 | strlen(XATTR_NAME_POSIX_ACL_ACCESS)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | if (temp == 0) { |
| 177 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 178 | if (sb->s_flags & MS_POSIXACL) |
| 179 | rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, |
| 180 | ea_value, (const int)value_size, |
| 181 | ACL_TYPE_ACCESS, cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 182 | cifs_remap(cifs_sb)); |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 183 | cifs_dbg(FYI, "set POSIX ACL rc %d\n", rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 185 | cifs_dbg(FYI, "set POSIX ACL not supported\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | #endif |
Andreas Gruenbacher | 97d7929 | 2015-12-02 14:44:35 +0100 | [diff] [blame] | 187 | } else if (strncmp(ea_name, XATTR_NAME_POSIX_ACL_DEFAULT, |
| 188 | strlen(XATTR_NAME_POSIX_ACL_DEFAULT)) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 190 | if (sb->s_flags & MS_POSIXACL) |
| 191 | rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, |
| 192 | ea_value, (const int)value_size, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 193 | ACL_TYPE_DEFAULT, cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 194 | cifs_remap(cifs_sb)); |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 195 | cifs_dbg(FYI, "set POSIX default ACL rc %d\n", rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 197 | cifs_dbg(FYI, "set default POSIX ACL not supported\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | #endif |
| 199 | } else { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 200 | cifs_dbg(FYI, "illegal xattr request %s (only user namespace supported)\n", |
| 201 | ea_name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | /* BB what if no namespace prefix? */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 203 | /* Should we just pass them to server, except for |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | system and perhaps security prefixes? */ |
| 205 | } |
| 206 | } |
| 207 | |
| 208 | set_ea_exit: |
Jesper Juhl | f99d49a | 2005-11-07 01:01:34 -0800 | [diff] [blame] | 209 | kfree(full_path); |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 210 | free_xid(xid); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 211 | cifs_put_tlink(tlink); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | #endif |
| 213 | return rc; |
| 214 | } |
| 215 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 216 | ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name, |
| 217 | void *ea_value, size_t buf_size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | { |
| 219 | ssize_t rc = -EOPNOTSUPP; |
| 220 | #ifdef CONFIG_CIFS_XATTR |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 221 | unsigned int xid; |
Al Viro | 5fdccfe | 2016-04-10 17:07:33 -0400 | [diff] [blame^] | 222 | struct super_block *sb = direntry->d_sb; |
| 223 | struct cifs_sb_info *cifs_sb = CIFS_SB(sb); |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 224 | struct tcon_link *tlink; |
Steve French | 96daf2b | 2011-05-27 04:34:02 +0000 | [diff] [blame] | 225 | struct cifs_tcon *pTcon; |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 226 | char *full_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 228 | tlink = cifs_sb_tlink(cifs_sb); |
| 229 | if (IS_ERR(tlink)) |
| 230 | return PTR_ERR(tlink); |
| 231 | pTcon = tlink_tcon(tlink); |
| 232 | |
Pavel Shilovsky | 6d5786a | 2012-06-20 11:21:16 +0400 | [diff] [blame] | 233 | xid = get_xid(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 235 | full_path = build_path_from_dentry(direntry); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 236 | if (full_path == NULL) { |
Suresh Jayaraman | 0f3bc09 | 2009-06-25 18:12:34 +0530 | [diff] [blame] | 237 | rc = -ENOMEM; |
Jeff Layton | 7ffec37 | 2010-09-29 19:51:11 -0400 | [diff] [blame] | 238 | goto get_ea_exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | } |
| 240 | /* return dos attributes as pseudo xattr */ |
| 241 | /* return alt name if available as pseudo attr */ |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 242 | if (ea_name == NULL) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 243 | cifs_dbg(FYI, "Null xattr names not supported\n"); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 244 | } else if (strncmp(ea_name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) |
| 245 | == 0) { |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 246 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | goto get_ea_exit; |
| 248 | |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 249 | if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) { |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 250 | cifs_dbg(FYI, "attempt to query cifs inode metadata\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | /* revalidate/getattr then populate from inode */ |
| 252 | } /* BB add else when above is implemented */ |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 253 | ea_name += XATTR_USER_PREFIX_LEN; /* skip past user. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 254 | if (pTcon->ses->server->ops->query_all_EAs) |
| 255 | rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, |
| 256 | full_path, ea_name, ea_value, buf_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 257 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 258 | } 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] | 259 | if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | goto get_ea_exit; |
| 261 | |
Mimi Zohar | f995e74 | 2011-08-11 16:00:47 -0400 | [diff] [blame] | 262 | ea_name += XATTR_OS2_PREFIX_LEN; /* skip past os2. prefix */ |
Steve French | 666753c | 2014-01-26 23:53:43 -0600 | [diff] [blame] | 263 | if (pTcon->ses->server->ops->query_all_EAs) |
| 264 | rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, |
| 265 | full_path, ea_name, ea_value, buf_size, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 266 | cifs_sb->local_nls, cifs_remap(cifs_sb)); |
Andreas Gruenbacher | 97d7929 | 2015-12-02 14:44:35 +0100 | [diff] [blame] | 267 | } else if (strncmp(ea_name, XATTR_NAME_POSIX_ACL_ACCESS, |
| 268 | strlen(XATTR_NAME_POSIX_ACL_ACCESS)) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 270 | if (sb->s_flags & MS_POSIXACL) |
Steve French | 1da0c78 | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 271 | rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 272 | ea_value, buf_size, ACL_TYPE_ACCESS, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 273 | cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 274 | cifs_remap(cifs_sb)); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 275 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 276 | cifs_dbg(FYI, "Query POSIX ACL not supported yet\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | #endif /* CONFIG_CIFS_POSIX */ |
Andreas Gruenbacher | 97d7929 | 2015-12-02 14:44:35 +0100 | [diff] [blame] | 278 | } else if (strncmp(ea_name, XATTR_NAME_POSIX_ACL_DEFAULT, |
| 279 | strlen(XATTR_NAME_POSIX_ACL_DEFAULT)) == 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | #ifdef CONFIG_CIFS_POSIX |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 281 | if (sb->s_flags & MS_POSIXACL) |
Steve French | 1da0c78 | 2005-04-28 22:41:04 -0700 | [diff] [blame] | 282 | rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 283 | ea_value, buf_size, ACL_TYPE_DEFAULT, |
Steve French | 737b758 | 2005-04-28 22:41:06 -0700 | [diff] [blame] | 284 | cifs_sb->local_nls, |
Steve French | 2baa268 | 2014-09-27 02:19:01 -0500 | [diff] [blame] | 285 | cifs_remap(cifs_sb)); |
Steve French | 79a58d1 | 2007-07-06 22:44:50 +0000 | [diff] [blame] | 286 | #else |
Joe Perches | f96637b | 2013-05-04 22:12:25 -0500 | [diff] [blame] | 287 | cifs_dbg(FYI, "Query POSIX default ACL not supported yet\n"); |
Shirish Pargaonkar | fbeba8b | 2010-11-27 11:37:54 -0600 | [diff] [blame] | 288 | #endif /* CONFIG_CIFS_POSIX */ |
| 289 | } else if (strncmp(ea_name, CIFS_XATTR_CIFS_ACL, |
| 290 | strlen(CIFS_XATTR_CIFS_ACL)) == 0) { |
| 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, |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 299 | d_inode(direntry), 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 | } |