xattr: use memdup_user()
[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->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 = memdup_user(value, size);
241                 if (IS_ERR(kvalue))
242                         return PTR_ERR(kvalue);
243         }
244
245         error = vfs_setxattr(d, kname, kvalue, size, flags);
246         kfree(kvalue);
247         return error;
248 }
249
250 SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
251                 const char __user *, name, const void __user *, value,
252                 size_t, size, int, flags)
253 {
254         struct path path;
255         int error;
256
257         error = user_path(pathname, &path);
258         if (error)
259                 return error;
260         error = mnt_want_write(path.mnt);
261         if (!error) {
262                 error = setxattr(path.dentry, name, value, size, flags);
263                 mnt_drop_write(path.mnt);
264         }
265         path_put(&path);
266         return error;
267 }
268
269 SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
270                 const char __user *, name, const void __user *, value,
271                 size_t, size, int, flags)
272 {
273         struct path path;
274         int error;
275
276         error = user_lpath(pathname, &path);
277         if (error)
278                 return error;
279         error = mnt_want_write(path.mnt);
280         if (!error) {
281                 error = setxattr(path.dentry, name, value, size, flags);
282                 mnt_drop_write(path.mnt);
283         }
284         path_put(&path);
285         return error;
286 }
287
288 SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
289                 const void __user *,value, size_t, size, int, flags)
290 {
291         struct file *f;
292         struct dentry *dentry;
293         int error = -EBADF;
294
295         f = fget(fd);
296         if (!f)
297                 return error;
298         dentry = f->f_path.dentry;
299         audit_inode(NULL, dentry);
300         error = mnt_want_write(f->f_path.mnt);
301         if (!error) {
302                 error = setxattr(dentry, name, value, size, flags);
303                 mnt_drop_write(f->f_path.mnt);
304         }
305         fput(f);
306         return error;
307 }
308
309 /*
310  * Extended attribute GET operations
311  */
312 static ssize_t
313 getxattr(struct dentry *d, const char __user *name, void __user *value,
314          size_t size)
315 {
316         ssize_t error;
317         void *kvalue = NULL;
318         char kname[XATTR_NAME_MAX + 1];
319
320         error = strncpy_from_user(kname, name, sizeof(kname));
321         if (error == 0 || error == sizeof(kname))
322                 error = -ERANGE;
323         if (error < 0)
324                 return error;
325
326         if (size) {
327                 if (size > XATTR_SIZE_MAX)
328                         size = XATTR_SIZE_MAX;
329                 kvalue = kzalloc(size, GFP_KERNEL);
330                 if (!kvalue)
331                         return -ENOMEM;
332         }
333
334         error = vfs_getxattr(d, kname, kvalue, size);
335         if (error > 0) {
336                 if (size && copy_to_user(value, kvalue, error))
337                         error = -EFAULT;
338         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
339                 /* The file system tried to returned a value bigger
340                    than XATTR_SIZE_MAX bytes. Not possible. */
341                 error = -E2BIG;
342         }
343         kfree(kvalue);
344         return error;
345 }
346
347 SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
348                 const char __user *, name, void __user *, value, size_t, size)
349 {
350         struct path path;
351         ssize_t error;
352
353         error = user_path(pathname, &path);
354         if (error)
355                 return error;
356         error = getxattr(path.dentry, name, value, size);
357         path_put(&path);
358         return error;
359 }
360
361 SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
362                 const char __user *, name, void __user *, value, size_t, size)
363 {
364         struct path path;
365         ssize_t error;
366
367         error = user_lpath(pathname, &path);
368         if (error)
369                 return error;
370         error = getxattr(path.dentry, name, value, size);
371         path_put(&path);
372         return error;
373 }
374
375 SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
376                 void __user *, value, size_t, size)
377 {
378         struct file *f;
379         ssize_t error = -EBADF;
380
381         f = fget(fd);
382         if (!f)
383                 return error;
384         audit_inode(NULL, f->f_path.dentry);
385         error = getxattr(f->f_path.dentry, name, value, size);
386         fput(f);
387         return error;
388 }
389
390 /*
391  * Extended attribute LIST operations
392  */
393 static ssize_t
394 listxattr(struct dentry *d, char __user *list, size_t size)
395 {
396         ssize_t error;
397         char *klist = NULL;
398
399         if (size) {
400                 if (size > XATTR_LIST_MAX)
401                         size = XATTR_LIST_MAX;
402                 klist = kmalloc(size, GFP_KERNEL);
403                 if (!klist)
404                         return -ENOMEM;
405         }
406
407         error = vfs_listxattr(d, klist, size);
408         if (error > 0) {
409                 if (size && copy_to_user(list, klist, error))
410                         error = -EFAULT;
411         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
412                 /* The file system tried to returned a list bigger
413                    than XATTR_LIST_MAX bytes. Not possible. */
414                 error = -E2BIG;
415         }
416         kfree(klist);
417         return error;
418 }
419
420 SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
421                 size_t, size)
422 {
423         struct path path;
424         ssize_t error;
425
426         error = user_path(pathname, &path);
427         if (error)
428                 return error;
429         error = listxattr(path.dentry, list, size);
430         path_put(&path);
431         return error;
432 }
433
434 SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
435                 size_t, size)
436 {
437         struct path path;
438         ssize_t error;
439
440         error = user_lpath(pathname, &path);
441         if (error)
442                 return error;
443         error = listxattr(path.dentry, list, size);
444         path_put(&path);
445         return error;
446 }
447
448 SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
449 {
450         struct file *f;
451         ssize_t error = -EBADF;
452
453         f = fget(fd);
454         if (!f)
455                 return error;
456         audit_inode(NULL, f->f_path.dentry);
457         error = listxattr(f->f_path.dentry, list, size);
458         fput(f);
459         return error;
460 }
461
462 /*
463  * Extended attribute REMOVE operations
464  */
465 static long
466 removexattr(struct dentry *d, const char __user *name)
467 {
468         int error;
469         char kname[XATTR_NAME_MAX + 1];
470
471         error = strncpy_from_user(kname, name, sizeof(kname));
472         if (error == 0 || error == sizeof(kname))
473                 error = -ERANGE;
474         if (error < 0)
475                 return error;
476
477         return vfs_removexattr(d, kname);
478 }
479
480 SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
481                 const char __user *, name)
482 {
483         struct path path;
484         int error;
485
486         error = user_path(pathname, &path);
487         if (error)
488                 return error;
489         error = mnt_want_write(path.mnt);
490         if (!error) {
491                 error = removexattr(path.dentry, name);
492                 mnt_drop_write(path.mnt);
493         }
494         path_put(&path);
495         return error;
496 }
497
498 SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
499                 const char __user *, name)
500 {
501         struct path path;
502         int error;
503
504         error = user_lpath(pathname, &path);
505         if (error)
506                 return error;
507         error = mnt_want_write(path.mnt);
508         if (!error) {
509                 error = removexattr(path.dentry, name);
510                 mnt_drop_write(path.mnt);
511         }
512         path_put(&path);
513         return error;
514 }
515
516 SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
517 {
518         struct file *f;
519         struct dentry *dentry;
520         int error = -EBADF;
521
522         f = fget(fd);
523         if (!f)
524                 return error;
525         dentry = f->f_path.dentry;
526         audit_inode(NULL, dentry);
527         error = mnt_want_write(f->f_path.mnt);
528         if (!error) {
529                 error = removexattr(dentry, name);
530                 mnt_drop_write(f->f_path.mnt);
531         }
532         fput(f);
533         return error;
534 }
535
536
537 static const char *
538 strcmp_prefix(const char *a, const char *a_prefix)
539 {
540         while (*a_prefix && *a == *a_prefix) {
541                 a++;
542                 a_prefix++;
543         }
544         return *a_prefix ? NULL : a;
545 }
546
547 /*
548  * In order to implement different sets of xattr operations for each xattr
549  * prefix with the generic xattr API, a filesystem should create a
550  * null-terminated array of struct xattr_handler (one for each prefix) and
551  * hang a pointer to it off of the s_xattr field of the superblock.
552  *
553  * The generic_fooxattr() functions will use this list to dispatch xattr
554  * operations to the correct xattr_handler.
555  */
556 #define for_each_xattr_handler(handlers, handler)               \
557                 for ((handler) = *(handlers)++;                 \
558                         (handler) != NULL;                      \
559                         (handler) = *(handlers)++)
560
561 /*
562  * Find the xattr_handler with the matching prefix.
563  */
564 static struct xattr_handler *
565 xattr_resolve_name(struct xattr_handler **handlers, const char **name)
566 {
567         struct xattr_handler *handler;
568
569         if (!*name)
570                 return NULL;
571
572         for_each_xattr_handler(handlers, handler) {
573                 const char *n = strcmp_prefix(*name, handler->prefix);
574                 if (n) {
575                         *name = n;
576                         break;
577                 }
578         }
579         return handler;
580 }
581
582 /*
583  * Find the handler for the prefix and dispatch its get() operation.
584  */
585 ssize_t
586 generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size)
587 {
588         struct xattr_handler *handler;
589         struct inode *inode = dentry->d_inode;
590
591         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
592         if (!handler)
593                 return -EOPNOTSUPP;
594         return handler->get(inode, name, buffer, size);
595 }
596
597 /*
598  * Combine the results of the list() operation from every xattr_handler in the
599  * list.
600  */
601 ssize_t
602 generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
603 {
604         struct inode *inode = dentry->d_inode;
605         struct xattr_handler *handler, **handlers = inode->i_sb->s_xattr;
606         unsigned int size = 0;
607
608         if (!buffer) {
609                 for_each_xattr_handler(handlers, handler)
610                         size += handler->list(inode, NULL, 0, NULL, 0);
611         } else {
612                 char *buf = buffer;
613
614                 for_each_xattr_handler(handlers, handler) {
615                         size = handler->list(inode, buf, buffer_size, NULL, 0);
616                         if (size > buffer_size)
617                                 return -ERANGE;
618                         buf += size;
619                         buffer_size -= size;
620                 }
621                 size = buf - buffer;
622         }
623         return size;
624 }
625
626 /*
627  * Find the handler for the prefix and dispatch its set() operation.
628  */
629 int
630 generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags)
631 {
632         struct xattr_handler *handler;
633         struct inode *inode = dentry->d_inode;
634
635         if (size == 0)
636                 value = "";  /* empty EA, do not remove */
637         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
638         if (!handler)
639                 return -EOPNOTSUPP;
640         return handler->set(inode, name, value, size, flags);
641 }
642
643 /*
644  * Find the handler for the prefix and dispatch its set() operation to remove
645  * any associated extended attribute.
646  */
647 int
648 generic_removexattr(struct dentry *dentry, const char *name)
649 {
650         struct xattr_handler *handler;
651         struct inode *inode = dentry->d_inode;
652
653         handler = xattr_resolve_name(inode->i_sb->s_xattr, &name);
654         if (!handler)
655                 return -EOPNOTSUPP;
656         return handler->set(inode, name, NULL, 0, XATTR_REPLACE);
657 }
658
659 EXPORT_SYMBOL(generic_getxattr);
660 EXPORT_SYMBOL(generic_listxattr);
661 EXPORT_SYMBOL(generic_setxattr);
662 EXPORT_SYMBOL(generic_removexattr);