[PATCH] move xattr permission checks into the VFS
[linux-3.10.git] / fs / xattr.c
1 /*
2   File: fs/xattr.c
3
4   Extended attribute handling.
5
6   Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
7   Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
8   Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
9  */
10 #include <linux/fs.h>
11 #include <linux/slab.h>
12 #include <linux/smp_lock.h>
13 #include <linux/file.h>
14 #include <linux/xattr.h>
15 #include <linux/namei.h>
16 #include <linux/security.h>
17 #include <linux/syscalls.h>
18 #include <linux/module.h>
19 #include <linux/fsnotify.h>
20 #include <asm/uaccess.h>
21
22
23 /*
24  * Check permissions for extended attribute access.  This is a bit complicated
25  * because different namespaces have very different rules.
26  */
27 static int
28 xattr_permission(struct inode *inode, const char *name, int mask)
29 {
30         /*
31          * We can never set or remove an extended attribute on a read-only
32          * filesystem  or on an immutable / append-only inode.
33          */
34         if (mask & MAY_WRITE) {
35                 if (IS_RDONLY(inode))
36                         return -EROFS;
37                 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
38                         return -EPERM;
39         }
40
41         /*
42          * No restriction for security.* and system.* from the VFS.  Decision
43          * on these is left to the underlying filesystem / security module.
44          */
45         if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
46             !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
47                 return 0;
48
49         /*
50          * The trusted.* namespace can only accessed by a privilegued user.
51          */
52         if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
53                 return (capable(CAP_SYS_ADMIN) ? 0 : -EPERM);
54
55         if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
56                 if (!S_ISREG(inode->i_mode) &&
57                     (!S_ISDIR(inode->i_mode) || inode->i_mode & S_ISVTX))
58                         return -EPERM;
59         }
60
61         return permission(inode, mask, NULL);
62 }
63
64 int
65 vfs_setxattr(struct dentry *dentry, char *name, void *value,
66                 size_t size, int flags)
67 {
68         struct inode *inode = dentry->d_inode;
69         int error;
70
71         error = xattr_permission(inode, name, MAY_WRITE);
72         if (error)
73                 return error;
74
75         mutex_lock(&inode->i_mutex);
76         error = security_inode_setxattr(dentry, name, value, size, flags);
77         if (error)
78                 goto out;
79         error = -EOPNOTSUPP;
80         if (inode->i_op->setxattr) {
81                 error = inode->i_op->setxattr(dentry, name, value, size, flags);
82                 if (!error) {
83                         fsnotify_xattr(dentry);
84                         security_inode_post_setxattr(dentry, name, value,
85                                                      size, flags);
86                 }
87         } else if (!strncmp(name, XATTR_SECURITY_PREFIX,
88                                 XATTR_SECURITY_PREFIX_LEN)) {
89                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
90                 error = security_inode_setsecurity(inode, suffix, value,
91                                                    size, flags);
92                 if (!error)
93                         fsnotify_xattr(dentry);
94         }
95 out:
96         mutex_unlock(&inode->i_mutex);
97         return error;
98 }
99 EXPORT_SYMBOL_GPL(vfs_setxattr);
100
101 ssize_t
102 vfs_getxattr(struct dentry *dentry, char *name, void *value, size_t size)
103 {
104         struct inode *inode = dentry->d_inode;
105         int error;
106
107         error = xattr_permission(inode, name, MAY_READ);
108         if (error)
109                 return error;
110
111         error = security_inode_getxattr(dentry, name);
112         if (error)
113                 return error;
114
115         if (inode->i_op->getxattr)
116                 error = inode->i_op->getxattr(dentry, name, value, size);
117         else
118                 error = -EOPNOTSUPP;
119
120         if (!strncmp(name, XATTR_SECURITY_PREFIX,
121                                 XATTR_SECURITY_PREFIX_LEN)) {
122                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
123                 int ret = security_inode_getsecurity(inode, suffix, value,
124                                                      size, error);
125                 /*
126                  * Only overwrite the return value if a security module
127                  * is actually active.
128                  */
129                 if (ret != -EOPNOTSUPP)
130                         error = ret;
131         }
132
133         return error;
134 }
135 EXPORT_SYMBOL_GPL(vfs_getxattr);
136
137 int
138 vfs_removexattr(struct dentry *dentry, char *name)
139 {
140         struct inode *inode = dentry->d_inode;
141         int error;
142
143         if (!inode->i_op->removexattr)
144                 return -EOPNOTSUPP;
145
146         error = xattr_permission(inode, name, MAY_WRITE);
147         if (error)
148                 return error;
149
150         error = security_inode_removexattr(dentry, name);
151         if (error)
152                 return error;
153
154         mutex_lock(&inode->i_mutex);
155         error = inode->i_op->removexattr(dentry, name);
156         mutex_unlock(&inode->i_mutex);
157
158         if (!error)
159                 fsnotify_xattr(dentry);
160         return error;
161 }
162 EXPORT_SYMBOL_GPL(vfs_removexattr);
163
164
165 /*
166  * Extended attribute SET operations
167  */
168 static long
169 setxattr(struct dentry *d, char __user *name, void __user *value,
170          size_t size, int flags)
171 {
172         int error;
173         void *kvalue = NULL;
174         char kname[XATTR_NAME_MAX + 1];
175
176         if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
177                 return -EINVAL;
178
179         error = strncpy_from_user(kname, name, sizeof(kname));
180         if (error == 0 || error == sizeof(kname))
181                 error = -ERANGE;
182         if (error < 0)
183                 return error;
184
185         if (size) {
186                 if (size > XATTR_SIZE_MAX)
187                         return -E2BIG;
188                 kvalue = kmalloc(size, GFP_KERNEL);
189                 if (!kvalue)
190                         return -ENOMEM;
191                 if (copy_from_user(kvalue, value, size)) {
192                         kfree(kvalue);
193                         return -EFAULT;
194                 }
195         }
196
197         error = vfs_setxattr(d, kname, kvalue, size, flags);
198         kfree(kvalue);
199         return error;
200 }
201
202 asmlinkage long
203 sys_setxattr(char __user *path, char __user *name, void __user *value,
204              size_t size, int flags)
205 {
206         struct nameidata nd;
207         int error;
208
209         error = user_path_walk(path, &nd);
210         if (error)
211                 return error;
212         error = setxattr(nd.dentry, name, value, size, flags);
213         path_release(&nd);
214         return error;
215 }
216
217 asmlinkage long
218 sys_lsetxattr(char __user *path, char __user *name, void __user *value,
219               size_t size, int flags)
220 {
221         struct nameidata nd;
222         int error;
223
224         error = user_path_walk_link(path, &nd);
225         if (error)
226                 return error;
227         error = setxattr(nd.dentry, name, value, size, flags);
228         path_release(&nd);
229         return error;
230 }
231
232 asmlinkage long
233 sys_fsetxattr(int fd, char __user *name, void __user *value,
234               size_t size, int flags)
235 {
236         struct file *f;
237         int error = -EBADF;
238
239         f = fget(fd);
240         if (!f)
241                 return error;
242         error = setxattr(f->f_dentry, name, value, size, flags);
243         fput(f);
244         return error;
245 }
246
247 /*
248  * Extended attribute GET operations
249  */
250 static ssize_t
251 getxattr(struct dentry *d, char __user *name, void __user *value, size_t size)
252 {
253         ssize_t error;
254         void *kvalue = NULL;
255         char kname[XATTR_NAME_MAX + 1];
256
257         error = strncpy_from_user(kname, name, sizeof(kname));
258         if (error == 0 || error == sizeof(kname))
259                 error = -ERANGE;
260         if (error < 0)
261                 return error;
262
263         if (size) {
264                 if (size > XATTR_SIZE_MAX)
265                         size = XATTR_SIZE_MAX;
266                 kvalue = kzalloc(size, GFP_KERNEL);
267                 if (!kvalue)
268                         return -ENOMEM;
269         }
270
271         error = vfs_getxattr(d, kname, kvalue, size);
272         if (error > 0) {
273                 if (size && copy_to_user(value, kvalue, error))
274                         error = -EFAULT;
275         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
276                 /* The file system tried to returned a value bigger
277                    than XATTR_SIZE_MAX bytes. Not possible. */
278                 error = -E2BIG;
279         }
280         kfree(kvalue);
281         return error;
282 }
283
284 asmlinkage ssize_t
285 sys_getxattr(char __user *path, char __user *name, void __user *value,
286              size_t size)
287 {
288         struct nameidata nd;
289         ssize_t error;
290
291         error = user_path_walk(path, &nd);
292         if (error)
293                 return error;
294         error = getxattr(nd.dentry, name, value, size);
295         path_release(&nd);
296         return error;
297 }
298
299 asmlinkage ssize_t
300 sys_lgetxattr(char __user *path, char __user *name, void __user *value,
301               size_t size)
302 {
303         struct nameidata nd;
304         ssize_t error;
305
306         error = user_path_walk_link(path, &nd);
307         if (error)
308                 return error;
309         error = getxattr(nd.dentry, name, value, size);
310         path_release(&nd);
311         return error;
312 }
313
314 asmlinkage ssize_t
315 sys_fgetxattr(int fd, char __user *name, void __user *value, size_t size)
316 {
317         struct file *f;
318         ssize_t error = -EBADF;
319
320         f = fget(fd);
321         if (!f)
322                 return error;
323         error = getxattr(f->f_dentry, name, value, size);
324         fput(f);
325         return error;
326 }
327
328 /*
329  * Extended attribute LIST operations
330  */
331 static ssize_t
332 listxattr(struct dentry *d, char __user *list, size_t size)
333 {
334         ssize_t error;
335         char *klist = NULL;
336
337         if (size) {
338                 if (size > XATTR_LIST_MAX)
339                         size = XATTR_LIST_MAX;
340                 klist = kmalloc(size, GFP_KERNEL);
341                 if (!klist)
342                         return -ENOMEM;
343         }
344
345         error = security_inode_listxattr(d);
346         if (error)
347                 goto out;
348         error = -EOPNOTSUPP;
349         if (d->d_inode->i_op && d->d_inode->i_op->listxattr) {
350                 error = d->d_inode->i_op->listxattr(d, klist, size);
351         } else {
352                 error = security_inode_listsecurity(d->d_inode, klist, size);
353                 if (size && error > size)
354                         error = -ERANGE;
355         }
356         if (error > 0) {
357                 if (size && copy_to_user(list, klist, error))
358                         error = -EFAULT;
359         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
360                 /* The file system tried to returned a list bigger
361                    than XATTR_LIST_MAX bytes. Not possible. */
362                 error = -E2BIG;
363         }
364 out:
365         kfree(klist);
366         return error;
367 }
368
369 asmlinkage ssize_t
370 sys_listxattr(char __user *path, char __user *list, size_t size)
371 {
372         struct nameidata nd;
373         ssize_t error;
374
375         error = user_path_walk(path, &nd);
376         if (error)
377                 return error;
378         error = listxattr(nd.dentry, list, size);
379         path_release(&nd);
380         return error;
381 }
382
383 asmlinkage ssize_t
384 sys_llistxattr(char __user *path, char __user *list, size_t size)
385 {
386         struct nameidata nd;
387         ssize_t error;
388
389         error = user_path_walk_link(path, &nd);
390         if (error)
391                 return error;
392         error = listxattr(nd.dentry, list, size);
393         path_release(&nd);
394         return error;
395 }
396
397 asmlinkage ssize_t
398 sys_flistxattr(int fd, char __user *list, size_t size)
399 {
400         struct file *f;
401         ssize_t error = -EBADF;
402
403         f = fget(fd);
404         if (!f)
405                 return error;
406         error = listxattr(f->f_dentry, list, size);
407         fput(f);
408         return error;
409 }
410
411 /*
412  * Extended attribute REMOVE operations
413  */
414 static long
415 removexattr(struct dentry *d, char __user *name)
416 {
417         int error;
418         char kname[XATTR_NAME_MAX + 1];
419
420         error = strncpy_from_user(kname, name, sizeof(kname));
421         if (error == 0 || error == sizeof(kname))
422                 error = -ERANGE;
423         if (error < 0)
424                 return error;
425
426         return vfs_removexattr(d, kname);
427 }
428
429 asmlinkage long
430 sys_removexattr(char __user *path, char __user *name)
431 {
432         struct nameidata nd;
433         int error;
434
435         error = user_path_walk(path, &nd);
436         if (error)
437                 return error;
438         error = removexattr(nd.dentry, name);
439         path_release(&nd);
440         return error;
441 }
442
443 asmlinkage long
444 sys_lremovexattr(char __user *path, char __user *name)
445 {
446         struct nameidata nd;
447         int error;
448
449         error = user_path_walk_link(path, &nd);
450         if (error)
451                 return error;
452         error = removexattr(nd.dentry, name);
453         path_release(&nd);
454         return error;
455 }
456
457 asmlinkage long
458 sys_fremovexattr(int fd, char __user *name)
459 {
460         struct file *f;
461         int error = -EBADF;
462
463         f = fget(fd);
464         if (!f)
465                 return error;
466         error = removexattr(f->f_dentry, name);
467         fput(f);
468         return error;
469 }
470
471
472 static const char *
473 strcmp_prefix(const char *a, const char *a_prefix)
474 {
475         while (*a_prefix && *a == *a_prefix) {
476                 a++;
477                 a_prefix++;
478         }
479         return *a_prefix ? NULL : a;
480 }
481
482 /*
483  * In order to implement different sets of xattr operations for each xattr
484  * prefix with the generic xattr API, a filesystem should create a
485  * null-terminated array of struct xattr_handler (one for each prefix) and
486  * hang a pointer to it off of the s_xattr field of the superblock.
487  *
488  * The generic_fooxattr() functions will use this list to dispatch xattr
489  * operations to the correct xattr_handler.
490  */
491 #define for_each_xattr_handler(handlers, handler)               \
492                 for ((handler) = *(handlers)++;                 \
493                         (handler) != NULL;                      \
494                         (handler) = *(handlers)++)
495
496 /*
497  * Find the xattr_handler with the matching prefix.
498  */
499 static struct xattr_handler *
500 xattr_resolve_name(struct xattr_handler **handlers, const char **name)
501 {
502         struct xattr_handler *handler;
503
504         if (!*name)
505                 return NULL;
506
507         for_each_xattr_handler(handlers, handler) {
508                 const char *n = strcmp_prefix(*name, handler->prefix);
509                 if (n) {
510                         *name = n;
511                         break;
512                 }
513         }
514         return handler;
515 }
516
517 /*
518  * Find the handler for the prefix and dispatch its get() operation.
519  */
520 ssize_t
521 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
522 {
523         struct xattr_handler *handler;
524         struct inode *inode = dentry->d_inode;
525
526         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
527         if (!handler)
528                 return -EOPNOTSUPP;
529         return handler->get(inode, name, buffer, size);
530 }
531
532 /*
533  * Combine the results of the list() operation from every xattr_handler in the
534  * list.
535  */
536 ssize_t
537 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
538 {
539         struct inode *inode = dentry->d_inode;
540         struct xattr_handler *handler, **handlers = inode->i_sb->s_xattr;
541         unsigned int size = 0;
542
543         if (!buffer) {
544                 for_each_xattr_handler(handlers, handler)
545                         size += handler->list(inode, NULL, 0, NULL, 0);
546         } else {
547                 char *buf = buffer;
548
549                 for_each_xattr_handler(handlers, handler) {
550                         size = handler->list(inode, buf, buffer_size, NULL, 0);
551                         if (size > buffer_size)
552                                 return -ERANGE;
553                         buf += size;
554                         buffer_size -= size;
555                 }
556                 size = buf - buffer;
557         }
558         return size;
559 }
560
561 /*
562  * Find the handler for the prefix and dispatch its set() operation.
563  */
564 int
565 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
566 {
567         struct xattr_handler *handler;
568         struct inode *inode = dentry->d_inode;
569
570         if (size == 0)
571                 value = "";  /* empty EA, do not remove */
572         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
573         if (!handler)
574                 return -EOPNOTSUPP;
575         return handler->set(inode, name, value, size, flags);
576 }
577
578 /*
579  * Find the handler for the prefix and dispatch its set() operation to remove
580  * any associated extended attribute.
581  */
582 int
583 generic_removexattr(struct dentry *dentry, const char *name)
584 {
585         struct xattr_handler *handler;
586         struct inode *inode = dentry->d_inode;
587
588         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
589         if (!handler)
590                 return -EOPNOTSUPP;
591         return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
592 }
593
594 EXPORT_SYMBOL(generic_getxattr);
595 EXPORT_SYMBOL(generic_listxattr);
596 EXPORT_SYMBOL(generic_setxattr);
597 EXPORT_SYMBOL(generic_removexattr);