GNU Linux-libre 6.1.86-gnu
[releases.git] / fs / fuse / xattr.c
1 /*
2  * FUSE: Filesystem in Userspace
3  * Copyright (C) 2001-2016  Miklos Szeredi <miklos@szeredi.hu>
4  *
5  * This program can be distributed under the terms of the GNU GPL.
6  * See the file COPYING.
7  */
8
9 #include "fuse_i.h"
10
11 #include <linux/xattr.h>
12 #include <linux/posix_acl_xattr.h>
13
14 int fuse_setxattr(struct inode *inode, const char *name, const void *value,
15                   size_t size, int flags, unsigned int extra_flags)
16 {
17         struct fuse_mount *fm = get_fuse_mount(inode);
18         FUSE_ARGS(args);
19         struct fuse_setxattr_in inarg;
20         int err;
21
22         if (fm->fc->no_setxattr)
23                 return -EOPNOTSUPP;
24
25         memset(&inarg, 0, sizeof(inarg));
26         inarg.size = size;
27         inarg.flags = flags;
28         inarg.setxattr_flags = extra_flags;
29
30         args.opcode = FUSE_SETXATTR;
31         args.nodeid = get_node_id(inode);
32         args.in_numargs = 3;
33         args.in_args[0].size = fm->fc->setxattr_ext ?
34                 sizeof(inarg) : FUSE_COMPAT_SETXATTR_IN_SIZE;
35         args.in_args[0].value = &inarg;
36         args.in_args[1].size = strlen(name) + 1;
37         args.in_args[1].value = name;
38         args.in_args[2].size = size;
39         args.in_args[2].value = value;
40         err = fuse_simple_request(fm, &args);
41         if (err == -ENOSYS) {
42                 fm->fc->no_setxattr = 1;
43                 err = -EOPNOTSUPP;
44         }
45         if (!err)
46                 fuse_update_ctime(inode);
47
48         return err;
49 }
50
51 ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
52                       size_t size)
53 {
54         struct fuse_mount *fm = get_fuse_mount(inode);
55         FUSE_ARGS(args);
56         struct fuse_getxattr_in inarg;
57         struct fuse_getxattr_out outarg;
58         ssize_t ret;
59
60         if (fm->fc->no_getxattr)
61                 return -EOPNOTSUPP;
62
63         memset(&inarg, 0, sizeof(inarg));
64         inarg.size = size;
65         args.opcode = FUSE_GETXATTR;
66         args.nodeid = get_node_id(inode);
67         args.in_numargs = 2;
68         args.in_args[0].size = sizeof(inarg);
69         args.in_args[0].value = &inarg;
70         args.in_args[1].size = strlen(name) + 1;
71         args.in_args[1].value = name;
72         /* This is really two different operations rolled into one */
73         args.out_numargs = 1;
74         if (size) {
75                 args.out_argvar = true;
76                 args.out_args[0].size = size;
77                 args.out_args[0].value = value;
78         } else {
79                 args.out_args[0].size = sizeof(outarg);
80                 args.out_args[0].value = &outarg;
81         }
82         ret = fuse_simple_request(fm, &args);
83         if (!ret && !size)
84                 ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX);
85         if (ret == -ENOSYS) {
86                 fm->fc->no_getxattr = 1;
87                 ret = -EOPNOTSUPP;
88         }
89         return ret;
90 }
91
92 static int fuse_verify_xattr_list(char *list, size_t size)
93 {
94         size_t origsize = size;
95
96         while (size) {
97                 size_t thislen = strnlen(list, size);
98
99                 if (!thislen || thislen == size)
100                         return -EIO;
101
102                 size -= thislen + 1;
103                 list += thislen + 1;
104         }
105
106         return origsize;
107 }
108
109 ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
110 {
111         struct inode *inode = d_inode(entry);
112         struct fuse_mount *fm = get_fuse_mount(inode);
113         FUSE_ARGS(args);
114         struct fuse_getxattr_in inarg;
115         struct fuse_getxattr_out outarg;
116         ssize_t ret;
117
118         if (fuse_is_bad(inode))
119                 return -EIO;
120
121         if (!fuse_allow_current_process(fm->fc))
122                 return -EACCES;
123
124         if (fm->fc->no_listxattr)
125                 return -EOPNOTSUPP;
126
127         memset(&inarg, 0, sizeof(inarg));
128         inarg.size = size;
129         args.opcode = FUSE_LISTXATTR;
130         args.nodeid = get_node_id(inode);
131         args.in_numargs = 1;
132         args.in_args[0].size = sizeof(inarg);
133         args.in_args[0].value = &inarg;
134         /* This is really two different operations rolled into one */
135         args.out_numargs = 1;
136         if (size) {
137                 args.out_argvar = true;
138                 args.out_args[0].size = size;
139                 args.out_args[0].value = list;
140         } else {
141                 args.out_args[0].size = sizeof(outarg);
142                 args.out_args[0].value = &outarg;
143         }
144         ret = fuse_simple_request(fm, &args);
145         if (!ret && !size)
146                 ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX);
147         if (ret > 0 && size)
148                 ret = fuse_verify_xattr_list(list, ret);
149         if (ret == -ENOSYS) {
150                 fm->fc->no_listxattr = 1;
151                 ret = -EOPNOTSUPP;
152         }
153         return ret;
154 }
155
156 int fuse_removexattr(struct inode *inode, const char *name)
157 {
158         struct fuse_mount *fm = get_fuse_mount(inode);
159         FUSE_ARGS(args);
160         int err;
161
162         if (fm->fc->no_removexattr)
163                 return -EOPNOTSUPP;
164
165         args.opcode = FUSE_REMOVEXATTR;
166         args.nodeid = get_node_id(inode);
167         args.in_numargs = 1;
168         args.in_args[0].size = strlen(name) + 1;
169         args.in_args[0].value = name;
170         err = fuse_simple_request(fm, &args);
171         if (err == -ENOSYS) {
172                 fm->fc->no_removexattr = 1;
173                 err = -EOPNOTSUPP;
174         }
175         if (!err)
176                 fuse_update_ctime(inode);
177
178         return err;
179 }
180
181 static int fuse_xattr_get(const struct xattr_handler *handler,
182                          struct dentry *dentry, struct inode *inode,
183                          const char *name, void *value, size_t size)
184 {
185         if (fuse_is_bad(inode))
186                 return -EIO;
187
188         return fuse_getxattr(inode, name, value, size);
189 }
190
191 static int fuse_xattr_set(const struct xattr_handler *handler,
192                           struct user_namespace *mnt_userns,
193                           struct dentry *dentry, struct inode *inode,
194                           const char *name, const void *value, size_t size,
195                           int flags)
196 {
197         if (fuse_is_bad(inode))
198                 return -EIO;
199
200         if (!value)
201                 return fuse_removexattr(inode, name);
202
203         return fuse_setxattr(inode, name, value, size, flags, 0);
204 }
205
206 static bool no_xattr_list(struct dentry *dentry)
207 {
208         return false;
209 }
210
211 static int no_xattr_get(const struct xattr_handler *handler,
212                         struct dentry *dentry, struct inode *inode,
213                         const char *name, void *value, size_t size)
214 {
215         return -EOPNOTSUPP;
216 }
217
218 static int no_xattr_set(const struct xattr_handler *handler,
219                         struct user_namespace *mnt_userns,
220                         struct dentry *dentry, struct inode *nodee,
221                         const char *name, const void *value,
222                         size_t size, int flags)
223 {
224         return -EOPNOTSUPP;
225 }
226
227 static const struct xattr_handler fuse_xattr_handler = {
228         .prefix = "",
229         .get    = fuse_xattr_get,
230         .set    = fuse_xattr_set,
231 };
232
233 const struct xattr_handler *fuse_xattr_handlers[] = {
234         &fuse_xattr_handler,
235         NULL
236 };
237
238 const struct xattr_handler *fuse_acl_xattr_handlers[] = {
239         &posix_acl_access_xattr_handler,
240         &posix_acl_default_xattr_handler,
241         &fuse_xattr_handler,
242         NULL
243 };
244
245 static const struct xattr_handler fuse_no_acl_access_xattr_handler = {
246         .name  = XATTR_NAME_POSIX_ACL_ACCESS,
247         .flags = ACL_TYPE_ACCESS,
248         .list  = no_xattr_list,
249         .get   = no_xattr_get,
250         .set   = no_xattr_set,
251 };
252
253 static const struct xattr_handler fuse_no_acl_default_xattr_handler = {
254         .name  = XATTR_NAME_POSIX_ACL_DEFAULT,
255         .flags = ACL_TYPE_ACCESS,
256         .list  = no_xattr_list,
257         .get   = no_xattr_get,
258         .set   = no_xattr_set,
259 };
260
261 const struct xattr_handler *fuse_no_acl_xattr_handlers[] = {
262         &fuse_no_acl_access_xattr_handler,
263         &fuse_no_acl_default_xattr_handler,
264         &fuse_xattr_handler,
265         NULL
266 };