sanitize xattr handler prototypes
[linux-2.6.git] / fs / xfs / linux-2.6 / xfs_xattr.c
1 /*
2  * Copyright (C) 2008 Christoph Hellwig.
3  * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18
19 #include "xfs.h"
20 #include "xfs_da_btree.h"
21 #include "xfs_bmap_btree.h"
22 #include "xfs_inode.h"
23 #include "xfs_attr.h"
24 #include "xfs_attr_leaf.h"
25 #include "xfs_acl.h"
26 #include "xfs_vnodeops.h"
27
28 #include <linux/posix_acl_xattr.h>
29 #include <linux/xattr.h>
30
31
32 static int
33 xfs_xattr_get(struct dentry *dentry, const char *name,
34                 void *value, size_t size, int xflags)
35 {
36         struct xfs_inode *ip = XFS_I(dentry->d_inode);
37         int error, asize = size;
38
39         if (strcmp(name, "") == 0)
40                 return -EINVAL;
41
42         /* Convert Linux syscall to XFS internal ATTR flags */
43         if (!size) {
44                 xflags |= ATTR_KERNOVAL;
45                 value = NULL;
46         }
47
48         error = -xfs_attr_get(ip, name, value, &asize, xflags);
49         if (error)
50                 return error;
51         return asize;
52 }
53
54 static int
55 xfs_xattr_set(struct dentry *dentry, const char *name, const void *value,
56                 size_t size, int flags, int xflags)
57 {
58         struct xfs_inode *ip = XFS_I(dentry->d_inode);
59
60         if (strcmp(name, "") == 0)
61                 return -EINVAL;
62
63         /* Convert Linux syscall to XFS internal ATTR flags */
64         if (flags & XATTR_CREATE)
65                 xflags |= ATTR_CREATE;
66         if (flags & XATTR_REPLACE)
67                 xflags |= ATTR_REPLACE;
68
69         if (!value)
70                 return -xfs_attr_remove(ip, name, xflags);
71         return -xfs_attr_set(ip, name, (void *)value, size, xflags);
72 }
73
74 static struct xattr_handler xfs_xattr_user_handler = {
75         .prefix = XATTR_USER_PREFIX,
76         .flags  = 0, /* no flags implies user namespace */
77         .get    = xfs_xattr_get,
78         .set    = xfs_xattr_set,
79 };
80
81 static struct xattr_handler xfs_xattr_trusted_handler = {
82         .prefix = XATTR_TRUSTED_PREFIX,
83         .flags  = ATTR_ROOT,
84         .get    = xfs_xattr_get,
85         .set    = xfs_xattr_set,
86 };
87
88 static struct xattr_handler xfs_xattr_security_handler = {
89         .prefix = XATTR_SECURITY_PREFIX,
90         .flags  = ATTR_SECURE,
91         .get    = xfs_xattr_get,
92         .set    = xfs_xattr_set,
93 };
94
95 struct xattr_handler *xfs_xattr_handlers[] = {
96         &xfs_xattr_user_handler,
97         &xfs_xattr_trusted_handler,
98         &xfs_xattr_security_handler,
99 #ifdef CONFIG_XFS_POSIX_ACL
100         &xfs_xattr_acl_access_handler,
101         &xfs_xattr_acl_default_handler,
102 #endif
103         NULL
104 };
105
106 static unsigned int xfs_xattr_prefix_len(int flags)
107 {
108         if (flags & XFS_ATTR_SECURE)
109                 return sizeof("security");
110         else if (flags & XFS_ATTR_ROOT)
111                 return sizeof("trusted");
112         else
113                 return sizeof("user");
114 }
115
116 static const char *xfs_xattr_prefix(int flags)
117 {
118         if (flags & XFS_ATTR_SECURE)
119                 return xfs_xattr_security_handler.prefix;
120         else if (flags & XFS_ATTR_ROOT)
121                 return xfs_xattr_trusted_handler.prefix;
122         else
123                 return xfs_xattr_user_handler.prefix;
124 }
125
126 static int
127 xfs_xattr_put_listent(struct xfs_attr_list_context *context, int flags,
128                 char *name, int namelen, int valuelen, char *value)
129 {
130         unsigned int prefix_len = xfs_xattr_prefix_len(flags);
131         char *offset;
132         int arraytop;
133
134         ASSERT(context->count >= 0);
135
136         /*
137          * Only show root namespace entries if we are actually allowed to
138          * see them.
139          */
140         if ((flags & XFS_ATTR_ROOT) && !capable(CAP_SYS_ADMIN))
141                 return 0;
142
143         arraytop = context->count + prefix_len + namelen + 1;
144         if (arraytop > context->firstu) {
145                 context->count = -1;    /* insufficient space */
146                 return 1;
147         }
148         offset = (char *)context->alist + context->count;
149         strncpy(offset, xfs_xattr_prefix(flags), prefix_len);
150         offset += prefix_len;
151         strncpy(offset, name, namelen);                 /* real name */
152         offset += namelen;
153         *offset = '\0';
154         context->count += prefix_len + namelen + 1;
155         return 0;
156 }
157
158 static int
159 xfs_xattr_put_listent_sizes(struct xfs_attr_list_context *context, int flags,
160                 char *name, int namelen, int valuelen, char *value)
161 {
162         context->count += xfs_xattr_prefix_len(flags) + namelen + 1;
163         return 0;
164 }
165
166 static int
167 list_one_attr(const char *name, const size_t len, void *data,
168                 size_t size, ssize_t *result)
169 {
170         char *p = data + *result;
171
172         *result += len;
173         if (!size)
174                 return 0;
175         if (*result > size)
176                 return -ERANGE;
177
178         strcpy(p, name);
179         return 0;
180 }
181
182 ssize_t
183 xfs_vn_listxattr(struct dentry *dentry, char *data, size_t size)
184 {
185         struct xfs_attr_list_context context;
186         struct attrlist_cursor_kern cursor = { 0 };
187         struct inode            *inode = dentry->d_inode;
188         int                     error;
189
190         /*
191          * First read the regular on-disk attributes.
192          */
193         memset(&context, 0, sizeof(context));
194         context.dp = XFS_I(inode);
195         context.cursor = &cursor;
196         context.resynch = 1;
197         context.alist = data;
198         context.bufsize = size;
199         context.firstu = context.bufsize;
200
201         if (size)
202                 context.put_listent = xfs_xattr_put_listent;
203         else
204                 context.put_listent = xfs_xattr_put_listent_sizes;
205
206         xfs_attr_list_int(&context);
207         if (context.count < 0)
208                 return -ERANGE;
209
210         /*
211          * Then add the two synthetic ACL attributes.
212          */
213         if (posix_acl_access_exists(inode)) {
214                 error = list_one_attr(POSIX_ACL_XATTR_ACCESS,
215                                 strlen(POSIX_ACL_XATTR_ACCESS) + 1,
216                                 data, size, &context.count);
217                 if (error)
218                         return error;
219         }
220
221         if (posix_acl_default_exists(inode)) {
222                 error = list_one_attr(POSIX_ACL_XATTR_DEFAULT,
223                                 strlen(POSIX_ACL_XATTR_DEFAULT) + 1,
224                                 data, size, &context.count);
225                 if (error)
226                         return error;
227         }
228
229         return context.count;
230 }