Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[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                         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 }