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