[PATCH] cifs: Only send POSIX ACL calls to server if server claims to support that...
[safe/jmp/linux-2.6] / 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         }
88 remove_ea_exit:
89         if (full_path)
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                 if(full_path)
135                         kfree(full_path);
136                 FreeXid(xid);
137                 return -EOPNOTSUPP;
138         }
139
140         if(ea_name == NULL) {
141                 cFYI(1,("Null xattr names not supported"));
142         } else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5) == 0) {
143                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
144                         goto set_ea_exit;
145                 if(strncmp(ea_name,CIFS_XATTR_DOS_ATTRIB,14) == 0) {
146                         cFYI(1,("attempt to set cifs inode metadata"));
147                 }
148                 ea_name += 5; /* skip past user. prefix */
149                 rc = CIFSSMBSetEA(xid,pTcon,full_path,ea_name,ea_value,
150                         (__u16)value_size, cifs_sb->local_nls);
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         } else {
159                 int temp; 
160                 temp = strncmp(ea_name,POSIX_ACL_XATTR_ACCESS,
161                         strlen(POSIX_ACL_XATTR_ACCESS));
162                 if (temp == 0) {
163 #ifdef CONFIG_CIFS_POSIX
164                         if(sb->s_flags & MS_POSIXACL)
165                                 rc = CIFSSMBSetPosixACL(xid, pTcon,full_path,
166                                         ea_value, (const int)value_size, 
167                                         ACL_TYPE_ACCESS,cifs_sb->local_nls);
168                         cFYI(1,("set POSIX ACL rc %d",rc));
169 #else
170                         cFYI(1,("set POSIX ACL not supported"));
171 #endif
172                 } else if(strncmp(ea_name,POSIX_ACL_XATTR_DEFAULT,strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
173 #ifdef CONFIG_CIFS_POSIX
174                         if(sb->s_flags & MS_POSIXACL)
175                                 rc = CIFSSMBSetPosixACL(xid, pTcon,full_path,
176                                         ea_value, (const int)value_size, 
177                                         ACL_TYPE_DEFAULT, cifs_sb->local_nls);
178                         cFYI(1,("set POSIX default ACL rc %d",rc));
179 #else
180                         cFYI(1,("set default POSIX ACL not supported"));
181 #endif
182                 } else {
183                         cFYI(1,("illegal xattr request %s (only user namespace supported)",ea_name));
184                   /* BB what if no namespace prefix? */
185                   /* Should we just pass them to server, except for 
186                   system and perhaps security prefixes? */
187                 }
188         }
189
190 set_ea_exit:
191         if (full_path)
192                 kfree(full_path);
193         FreeXid(xid);
194 #endif
195         return rc;
196 }
197
198 ssize_t cifs_getxattr(struct dentry * direntry, const char * ea_name,
199          void * ea_value, size_t buf_size)
200 {
201         ssize_t rc = -EOPNOTSUPP;
202 #ifdef CONFIG_CIFS_XATTR
203         int xid;
204         struct cifs_sb_info *cifs_sb;
205         struct cifsTconInfo *pTcon;
206         struct super_block * sb;
207         char * full_path;
208
209         if(direntry == NULL)
210                 return -EIO;
211         if(direntry->d_inode == NULL)
212                 return -EIO;
213         sb = direntry->d_inode->i_sb;
214         if(sb == NULL)
215                 return -EIO;
216
217         xid = GetXid();
218
219         cifs_sb = CIFS_SB(sb);
220         pTcon = cifs_sb->tcon;
221
222         down(&sb->s_vfs_rename_sem);
223         full_path = build_path_from_dentry(direntry);
224         up(&sb->s_vfs_rename_sem);
225         if(full_path == NULL) {
226                 FreeXid(xid);
227                 return -ENOMEM;
228         }
229         /* return dos attributes as pseudo xattr */
230         /* return alt name if available as pseudo attr */
231         if(ea_name == NULL) {
232                 cFYI(1,("Null xattr names not supported"));
233         } else if(strncmp(ea_name,CIFS_XATTR_USER_PREFIX,5) == 0) {
234                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
235                         goto get_ea_exit;
236
237                 if(strncmp(ea_name,CIFS_XATTR_DOS_ATTRIB,14) == 0) {
238                         cFYI(1,("attempt to query cifs inode metadata"));
239                         /* revalidate/getattr then populate from inode */
240                 } /* BB add else when above is implemented */
241                 ea_name += 5; /* skip past user. prefix */
242                 rc = CIFSSMBQueryEA(xid,pTcon,full_path,ea_name,ea_value,
243                         buf_size, cifs_sb->local_nls);
244         } else if(strncmp(ea_name, CIFS_XATTR_OS2_PREFIX,4) == 0) {
245                 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
246                         goto get_ea_exit;
247
248                 ea_name += 4; /* skip past os2. prefix */
249                 rc = CIFSSMBQueryEA(xid,pTcon,full_path,ea_name,ea_value,
250                         buf_size, cifs_sb->local_nls);
251         } else if(strncmp(ea_name,POSIX_ACL_XATTR_ACCESS,strlen(POSIX_ACL_XATTR_ACCESS)) == 0) {
252 #ifdef CONFIG_CIFS_POSIX
253                 if(sb->s_flags & MS_POSIXACL)
254                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
255                                 ea_value, buf_size, ACL_TYPE_ACCESS, 
256                                 cifs_sb->local_nls);
257 #else 
258                 cFYI(1,("query POSIX ACL not supported yet"));
259 #endif /* CONFIG_CIFS_POSIX */
260         } else if(strncmp(ea_name,POSIX_ACL_XATTR_DEFAULT,strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) {
261 #ifdef CONFIG_CIFS_POSIX
262                 if(sb->s_flags & MS_POSIXACL)
263                         rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
264                                 ea_value, buf_size, ACL_TYPE_DEFAULT, 
265                                 cifs_sb->local_nls);
266 #else 
267                 cFYI(1,("query POSIX default ACL not supported yet"));
268 #endif
269         } else if(strncmp(ea_name,
270                   CIFS_XATTR_TRUSTED_PREFIX,XATTR_TRUSTED_PREFIX_LEN) == 0) {
271                 cFYI(1,("Trusted xattr namespace not supported yet"));
272         } else if(strncmp(ea_name,
273                   CIFS_XATTR_SECURITY_PREFIX,XATTR_SECURITY_PREFIX_LEN) == 0) {
274                 cFYI(1,("Security xattr namespace not supported yet"));
275         } else {
276                 cFYI(1,("illegal xattr name request %s (only user namespace supported)",ea_name));
277         }
278
279         /* We could add an additional check for streams ie 
280             if proc/fs/cifs/streamstoxattr is set then
281                 search server for EAs or streams to 
282                 returns as xattrs */
283
284         if(rc == -EINVAL)
285                 rc = -EOPNOTSUPP; 
286
287 get_ea_exit:
288         if (full_path)
289                 kfree(full_path);
290         FreeXid(xid);
291 #endif
292         return rc;
293 }
294
295 ssize_t cifs_listxattr(struct dentry * direntry, char * data, size_t buf_size)
296 {
297         ssize_t rc = -EOPNOTSUPP;
298 #ifdef CONFIG_CIFS_XATTR
299         int xid;
300         struct cifs_sb_info *cifs_sb;
301         struct cifsTconInfo *pTcon;
302         struct super_block * sb;
303         char * full_path;
304
305         if(direntry == NULL)
306                 return -EIO;
307         if(direntry->d_inode == NULL)
308                 return -EIO;
309         sb = direntry->d_inode->i_sb;
310         if(sb == NULL)
311                 return -EIO;
312         xid = GetXid();
313
314         cifs_sb = CIFS_SB(sb);
315         pTcon = cifs_sb->tcon;
316
317         down(&sb->s_vfs_rename_sem);
318         full_path = build_path_from_dentry(direntry);
319         up(&sb->s_vfs_rename_sem);
320         if(full_path == NULL) {
321                 FreeXid(xid);
322                 return -ENOMEM;
323         }
324         /* return dos attributes as pseudo xattr */
325         /* return alt name if available as pseudo attr */
326
327         /* if proc/fs/cifs/streamstoxattr is set then
328                 search server for EAs or streams to 
329                 returns as xattrs */
330         rc = CIFSSMBQAllEAs(xid,pTcon,full_path,data,buf_size,
331                                 cifs_sb->local_nls);
332
333         if (full_path)
334                 kfree(full_path);
335         FreeXid(xid);
336 #endif
337         return rc;
338 }