Al Viro | f466c6f | 2012-03-17 01:16:43 -0400 | [diff] [blame] | 1 | #include "reiserfs.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | #include <linux/errno.h> |
| 3 | #include <linux/fs.h> |
| 4 | #include <linux/pagemap.h> |
| 5 | #include <linux/xattr.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 6 | #include <linux/slab.h> |
Al Viro | c45ac88 | 2012-03-17 00:59:06 -0400 | [diff] [blame] | 7 | #include "xattr.h" |
Jeff Mahoney | 57fe60d | 2009-03-30 14:02:41 -0400 | [diff] [blame] | 8 | #include <linux/security.h> |
Fabian Frederick | 1709399 | 2014-08-08 14:21:12 -0700 | [diff] [blame] | 9 | #include <linux/uaccess.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | static int |
Andreas Gruenbacher | d9a82a0 | 2015-10-04 19:18:51 +0200 | [diff] [blame] | 12 | security_get(const struct xattr_handler *handler, struct dentry *dentry, |
| 13 | const char *name, void *buffer, size_t size) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | { |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 15 | if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) |
| 16 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 18 | if (IS_PRIVATE(d_inode(dentry))) |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 19 | return -EPERM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 21 | return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | } |
| 23 | |
| 24 | static int |
Andreas Gruenbacher | d9a82a0 | 2015-10-04 19:18:51 +0200 | [diff] [blame] | 25 | security_set(const struct xattr_handler *handler, struct dentry *dentry, |
| 26 | const char *name, const void *buffer, size_t size, int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | { |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 28 | if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) |
| 29 | return -EINVAL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 31 | if (IS_PRIVATE(d_inode(dentry))) |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 32 | return -EPERM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 34 | return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 35 | } |
| 36 | |
Andreas Gruenbacher | d9a82a0 | 2015-10-04 19:18:51 +0200 | [diff] [blame] | 37 | static size_t security_list(const struct xattr_handler *handler, |
| 38 | struct dentry *dentry, char *list, size_t list_len, |
| 39 | const char *name, size_t namelen) |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 40 | { |
Jeff Mahoney | 48b32a3 | 2009-03-30 14:02:38 -0400 | [diff] [blame] | 41 | const size_t len = namelen + 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | |
David Howells | 2b0143b | 2015-03-17 22:25:59 +0000 | [diff] [blame] | 43 | if (IS_PRIVATE(d_inode(dentry))) |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 44 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | |
Jeff Mahoney | 48b32a3 | 2009-03-30 14:02:38 -0400 | [diff] [blame] | 46 | if (list && len <= list_len) { |
| 47 | memcpy(list, name, namelen); |
| 48 | list[namelen] = '\0'; |
| 49 | } |
Linus Torvalds | bd4c625 | 2005-07-12 20:21:28 -0700 | [diff] [blame] | 50 | |
| 51 | return len; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | } |
| 53 | |
Jeff Mahoney | 57fe60d | 2009-03-30 14:02:41 -0400 | [diff] [blame] | 54 | /* Initializes the security context for a new inode and returns the number |
| 55 | * of blocks needed for the transaction. If successful, reiserfs_security |
| 56 | * must be released using reiserfs_security_free when the caller is done. */ |
| 57 | int reiserfs_security_init(struct inode *dir, struct inode *inode, |
Eric Paris | 2a7dba3 | 2011-02-01 11:05:39 -0500 | [diff] [blame] | 58 | const struct qstr *qstr, |
Jeff Mahoney | 57fe60d | 2009-03-30 14:02:41 -0400 | [diff] [blame] | 59 | struct reiserfs_security_handle *sec) |
| 60 | { |
| 61 | int blocks = 0; |
Jeff Mahoney | b82bb72 | 2009-05-05 15:30:16 -0400 | [diff] [blame] | 62 | int error; |
| 63 | |
| 64 | sec->name = NULL; |
| 65 | |
| 66 | /* Don't add selinux attributes on xattrs - they'll never get used */ |
| 67 | if (IS_PRIVATE(dir)) |
| 68 | return 0; |
| 69 | |
Mimi Zohar | 9d8f13b | 2011-06-06 15:29:25 -0400 | [diff] [blame] | 70 | error = security_old_inode_init_security(inode, dir, qstr, &sec->name, |
| 71 | &sec->value, &sec->length); |
Jeff Mahoney | 57fe60d | 2009-03-30 14:02:41 -0400 | [diff] [blame] | 72 | if (error) { |
| 73 | if (error == -EOPNOTSUPP) |
| 74 | error = 0; |
| 75 | |
| 76 | sec->name = NULL; |
| 77 | sec->value = NULL; |
| 78 | sec->length = 0; |
| 79 | return error; |
| 80 | } |
| 81 | |
Jeff Mahoney | 6cb4aff | 2010-03-23 13:35:38 -0700 | [diff] [blame] | 82 | if (sec->length && reiserfs_xattrs_initialized(inode->i_sb)) { |
Jeff Mahoney | 57fe60d | 2009-03-30 14:02:41 -0400 | [diff] [blame] | 83 | blocks = reiserfs_xattr_jcreate_nblocks(inode) + |
| 84 | reiserfs_xattr_nblocks(inode, sec->length); |
| 85 | /* We don't want to count the directories twice if we have |
| 86 | * a default ACL. */ |
| 87 | REISERFS_I(inode)->i_flags |= i_has_xattr_dir; |
| 88 | } |
| 89 | return blocks; |
| 90 | } |
| 91 | |
| 92 | int reiserfs_security_write(struct reiserfs_transaction_handle *th, |
| 93 | struct inode *inode, |
| 94 | struct reiserfs_security_handle *sec) |
| 95 | { |
| 96 | int error; |
| 97 | if (strlen(sec->name) < sizeof(XATTR_SECURITY_PREFIX)) |
| 98 | return -EINVAL; |
| 99 | |
| 100 | error = reiserfs_xattr_set_handle(th, inode, sec->name, sec->value, |
| 101 | sec->length, XATTR_CREATE); |
| 102 | if (error == -ENODATA || error == -EOPNOTSUPP) |
| 103 | error = 0; |
| 104 | |
| 105 | return error; |
| 106 | } |
| 107 | |
| 108 | void reiserfs_security_free(struct reiserfs_security_handle *sec) |
| 109 | { |
| 110 | kfree(sec->name); |
| 111 | kfree(sec->value); |
| 112 | sec->name = NULL; |
| 113 | sec->value = NULL; |
| 114 | } |
| 115 | |
Stephen Hemminger | 94d09a9 | 2010-05-13 17:53:19 -0700 | [diff] [blame] | 116 | const struct xattr_handler reiserfs_xattr_security_handler = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | .prefix = XATTR_SECURITY_PREFIX, |
| 118 | .get = security_get, |
| 119 | .set = security_set, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | .list = security_list, |
| 121 | }; |