Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * fs/nfs/idmap.c | |
3 | * | |
4 | * UID and GID to name mapping for clients. | |
5 | * | |
6 | * Copyright (c) 2002 The Regents of the University of Michigan. | |
7 | * All rights reserved. | |
8 | * | |
9 | * Marius Aamodt Eriksen <marius@umich.edu> | |
10 | * | |
11 | * Redistribution and use in source and binary forms, with or without | |
12 | * modification, are permitted provided that the following conditions | |
13 | * are met: | |
14 | * | |
15 | * 1. Redistributions of source code must retain the above copyright | |
16 | * notice, this list of conditions and the following disclaimer. | |
17 | * 2. Redistributions in binary form must reproduce the above copyright | |
18 | * notice, this list of conditions and the following disclaimer in the | |
19 | * documentation and/or other materials provided with the distribution. | |
20 | * 3. Neither the name of the University nor the names of its | |
21 | * contributors may be used to endorse or promote products derived | |
22 | * from this software without specific prior written permission. | |
23 | * | |
24 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
25 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
26 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
27 | * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
29 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
30 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR | |
31 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | |
32 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
33 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
34 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
35 | */ | |
5cf36cfd | 36 | #include <linux/types.h> |
57e62324 BS |
37 | #include <linux/parser.h> |
38 | #include <linux/fs.h> | |
57e62324 BS |
39 | #include <net/net_namespace.h> |
40 | #include <linux/sunrpc/rpc_pipe_fs.h> | |
6926afd1 | 41 | #include <linux/nfs_fs.h> |
3cd0f37a | 42 | #include <linux/nfs_fs_sb.h> |
57e62324 | 43 | #include <linux/key.h> |
3cd0f37a BS |
44 | #include <linux/keyctl.h> |
45 | #include <linux/key-type.h> | |
3cd0f37a | 46 | #include <keys/user-type.h> |
822ad64d | 47 | #include <keys/request_key_auth-type.h> |
3cd0f37a | 48 | #include <linux/module.h> |
61ca2c4a | 49 | #include <linux/user_namespace.h> |
57e62324 | 50 | |
3cd0f37a | 51 | #include "internal.h" |
17347d03 | 52 | #include "netns.h" |
40c64c26 | 53 | #include "nfs4idmap.h" |
1f2d30b5 | 54 | #include "nfs4trace.h" |
3cd0f37a BS |
55 | |
56 | #define NFS_UINT_MAXLEN 11 | |
3cd0f37a | 57 | |
17280175 TM |
58 | static const struct cred *id_resolver_cache; |
59 | static struct key_type key_type_id_resolver_legacy; | |
3cd0f37a | 60 | |
c5066945 BS |
61 | struct idmap_legacy_upcalldata { |
62 | struct rpc_pipe_msg pipe_msg; | |
63 | struct idmap_msg idmap_msg; | |
822ad64d | 64 | struct key *authkey; |
c5066945 BS |
65 | struct idmap *idmap; |
66 | }; | |
67 | ||
0cac1202 | 68 | struct idmap { |
2127d82a | 69 | struct rpc_pipe_dir_object idmap_pdo; |
0cac1202 TM |
70 | struct rpc_pipe *idmap_pipe; |
71 | struct idmap_legacy_upcalldata *idmap_upcall_data; | |
72 | struct mutex idmap_mutex; | |
61ca2c4a | 73 | struct user_namespace *user_ns; |
0cac1202 TM |
74 | }; |
75 | ||
58002399 TM |
76 | static struct user_namespace *idmap_userns(const struct idmap *idmap) |
77 | { | |
61ca2c4a SD |
78 | if (idmap && idmap->user_ns) |
79 | return idmap->user_ns; | |
58002399 TM |
80 | return &init_user_ns; |
81 | } | |
82 | ||
6926afd1 TM |
83 | /** |
84 | * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields | |
85 | * @fattr: fully initialised struct nfs_fattr | |
86 | * @owner_name: owner name string cache | |
87 | * @group_name: group name string cache | |
88 | */ | |
89 | void nfs_fattr_init_names(struct nfs_fattr *fattr, | |
90 | struct nfs4_string *owner_name, | |
91 | struct nfs4_string *group_name) | |
92 | { | |
93 | fattr->owner_name = owner_name; | |
94 | fattr->group_name = group_name; | |
95 | } | |
96 | ||
97 | static void nfs_fattr_free_owner_name(struct nfs_fattr *fattr) | |
98 | { | |
99 | fattr->valid &= ~NFS_ATTR_FATTR_OWNER_NAME; | |
100 | kfree(fattr->owner_name->data); | |
101 | } | |
102 | ||
103 | static void nfs_fattr_free_group_name(struct nfs_fattr *fattr) | |
104 | { | |
105 | fattr->valid &= ~NFS_ATTR_FATTR_GROUP_NAME; | |
106 | kfree(fattr->group_name->data); | |
107 | } | |
108 | ||
109 | static bool nfs_fattr_map_owner_name(struct nfs_server *server, struct nfs_fattr *fattr) | |
110 | { | |
111 | struct nfs4_string *owner = fattr->owner_name; | |
9f309c86 | 112 | kuid_t uid; |
6926afd1 TM |
113 | |
114 | if (!(fattr->valid & NFS_ATTR_FATTR_OWNER_NAME)) | |
115 | return false; | |
116 | if (nfs_map_name_to_uid(server, owner->data, owner->len, &uid) == 0) { | |
117 | fattr->uid = uid; | |
118 | fattr->valid |= NFS_ATTR_FATTR_OWNER; | |
119 | } | |
120 | return true; | |
121 | } | |
122 | ||
123 | static bool nfs_fattr_map_group_name(struct nfs_server *server, struct nfs_fattr *fattr) | |
124 | { | |
125 | struct nfs4_string *group = fattr->group_name; | |
9f309c86 | 126 | kgid_t gid; |
6926afd1 TM |
127 | |
128 | if (!(fattr->valid & NFS_ATTR_FATTR_GROUP_NAME)) | |
129 | return false; | |
130 | if (nfs_map_group_to_gid(server, group->data, group->len, &gid) == 0) { | |
131 | fattr->gid = gid; | |
132 | fattr->valid |= NFS_ATTR_FATTR_GROUP; | |
133 | } | |
134 | return true; | |
135 | } | |
136 | ||
137 | /** | |
138 | * nfs_fattr_free_names - free up the NFSv4 owner and group strings | |
139 | * @fattr: a fully initialised nfs_fattr structure | |
140 | */ | |
141 | void nfs_fattr_free_names(struct nfs_fattr *fattr) | |
142 | { | |
143 | if (fattr->valid & NFS_ATTR_FATTR_OWNER_NAME) | |
144 | nfs_fattr_free_owner_name(fattr); | |
145 | if (fattr->valid & NFS_ATTR_FATTR_GROUP_NAME) | |
146 | nfs_fattr_free_group_name(fattr); | |
147 | } | |
148 | ||
149 | /** | |
150 | * nfs_fattr_map_and_free_names - map owner/group strings into uid/gid and free | |
151 | * @server: pointer to the filesystem nfs_server structure | |
152 | * @fattr: a fully initialised nfs_fattr structure | |
153 | * | |
154 | * This helper maps the cached NFSv4 owner/group strings in fattr into | |
155 | * their numeric uid/gid equivalents, and then frees the cached strings. | |
156 | */ | |
157 | void nfs_fattr_map_and_free_names(struct nfs_server *server, struct nfs_fattr *fattr) | |
158 | { | |
159 | if (nfs_fattr_map_owner_name(server, fattr)) | |
160 | nfs_fattr_free_owner_name(fattr); | |
161 | if (nfs_fattr_map_group_name(server, fattr)) | |
162 | nfs_fattr_free_group_name(fattr); | |
163 | } | |
5cf36cfd | 164 | |
d67ae825 | 165 | int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res) |
5cf36cfd TM |
166 | { |
167 | unsigned long val; | |
168 | char buf[16]; | |
169 | ||
170 | if (memchr(name, '@', namelen) != NULL || namelen >= sizeof(buf)) | |
171 | return 0; | |
172 | memcpy(buf, name, namelen); | |
173 | buf[namelen] = '\0'; | |
7297cb68 | 174 | if (kstrtoul(buf, 0, &val) != 0) |
5cf36cfd TM |
175 | return 0; |
176 | *res = val; | |
177 | return 1; | |
178 | } | |
d67ae825 | 179 | EXPORT_SYMBOL_GPL(nfs_map_string_to_numeric); |
1da177e4 | 180 | |
f0b85168 TM |
181 | static int nfs_map_numeric_to_string(__u32 id, char *buf, size_t buflen) |
182 | { | |
183 | return snprintf(buf, buflen, "%u", id); | |
184 | } | |
185 | ||
17280175 | 186 | static struct key_type key_type_id_resolver = { |
955a857e | 187 | .name = "id_resolver", |
f9167789 DH |
188 | .preparse = user_preparse, |
189 | .free_preparse = user_free_preparse, | |
190 | .instantiate = generic_key_instantiate, | |
955a857e BS |
191 | .revoke = user_revoke, |
192 | .destroy = user_destroy, | |
193 | .describe = user_describe, | |
194 | .read = user_read, | |
195 | }; | |
196 | ||
fb2a525c | 197 | int nfs_idmap_init(void) |
955a857e BS |
198 | { |
199 | struct cred *cred; | |
200 | struct key *keyring; | |
201 | int ret = 0; | |
202 | ||
f9fd2d9c WAA |
203 | printk(KERN_NOTICE "NFS: Registering the %s key type\n", |
204 | key_type_id_resolver.name); | |
955a857e BS |
205 | |
206 | cred = prepare_kernel_cred(NULL); | |
207 | if (!cred) | |
208 | return -ENOMEM; | |
209 | ||
4e963d4f EB |
210 | keyring = keyring_alloc(".id_resolver", |
211 | GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, | |
028db3e2 LT |
212 | (KEY_POS_ALL & ~KEY_POS_SETATTR) | |
213 | KEY_USR_VIEW | KEY_USR_READ, | |
5ac7eace | 214 | KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL); |
955a857e BS |
215 | if (IS_ERR(keyring)) { |
216 | ret = PTR_ERR(keyring); | |
217 | goto failed_put_cred; | |
218 | } | |
219 | ||
955a857e BS |
220 | ret = register_key_type(&key_type_id_resolver); |
221 | if (ret < 0) | |
222 | goto failed_put_key; | |
223 | ||
a427b9ec DH |
224 | ret = register_key_type(&key_type_id_resolver_legacy); |
225 | if (ret < 0) | |
226 | goto failed_reg_legacy; | |
227 | ||
700920eb | 228 | set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags); |
955a857e BS |
229 | cred->thread_keyring = keyring; |
230 | cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING; | |
231 | id_resolver_cache = cred; | |
232 | return 0; | |
233 | ||
a427b9ec DH |
234 | failed_reg_legacy: |
235 | unregister_key_type(&key_type_id_resolver); | |
955a857e BS |
236 | failed_put_key: |
237 | key_put(keyring); | |
238 | failed_put_cred: | |
239 | put_cred(cred); | |
240 | return ret; | |
241 | } | |
242 | ||
fb2a525c | 243 | void nfs_idmap_quit(void) |
955a857e BS |
244 | { |
245 | key_revoke(id_resolver_cache->thread_keyring); | |
246 | unregister_key_type(&key_type_id_resolver); | |
a427b9ec | 247 | unregister_key_type(&key_type_id_resolver_legacy); |
955a857e BS |
248 | put_cred(id_resolver_cache); |
249 | } | |
250 | ||
251 | /* | |
252 | * Assemble the description to pass to request_key() | |
253 | * This function will allocate a new string and update dest to point | |
254 | * at it. The caller is responsible for freeing dest. | |
255 | * | |
256 | * On error 0 is returned. Otherwise, the length of dest is returned. | |
257 | */ | |
258 | static ssize_t nfs_idmap_get_desc(const char *name, size_t namelen, | |
259 | const char *type, size_t typelen, char **desc) | |
260 | { | |
261 | char *cp; | |
262 | size_t desclen = typelen + namelen + 2; | |
263 | ||
264 | *desc = kmalloc(desclen, GFP_KERNEL); | |
8f0d97b4 | 265 | if (!*desc) |
955a857e BS |
266 | return -ENOMEM; |
267 | ||
268 | cp = *desc; | |
269 | memcpy(cp, type, typelen); | |
270 | cp += typelen; | |
271 | *cp++ = ':'; | |
272 | ||
273 | memcpy(cp, name, namelen); | |
274 | cp += namelen; | |
275 | *cp = '\0'; | |
276 | return desclen; | |
277 | } | |
278 | ||
ffa57b9e BS |
279 | static struct key *nfs_idmap_request_key(const char *name, size_t namelen, |
280 | const char *type, struct idmap *idmap) | |
955a857e | 281 | { |
955a857e | 282 | char *desc; |
58002399 | 283 | struct key *rkey = ERR_PTR(-EAGAIN); |
955a857e BS |
284 | ssize_t ret; |
285 | ||
286 | ret = nfs_idmap_get_desc(name, namelen, type, strlen(type), &desc); | |
cdb2e53f | 287 | if (ret < 0) |
ffa57b9e BS |
288 | return ERR_PTR(ret); |
289 | ||
61ca2c4a | 290 | if (!idmap->user_ns || idmap->user_ns == &init_user_ns) |
028db3e2 | 291 | rkey = request_key(&key_type_id_resolver, desc, ""); |
ffa57b9e BS |
292 | if (IS_ERR(rkey)) { |
293 | mutex_lock(&idmap->idmap_mutex); | |
294 | rkey = request_key_with_auxdata(&key_type_id_resolver_legacy, | |
028db3e2 | 295 | desc, NULL, "", 0, idmap); |
ffa57b9e BS |
296 | mutex_unlock(&idmap->idmap_mutex); |
297 | } | |
0c7774ab DH |
298 | if (!IS_ERR(rkey)) |
299 | set_bit(KEY_FLAG_ROOT_CAN_INVAL, &rkey->flags); | |
ffa57b9e BS |
300 | |
301 | kfree(desc); | |
302 | return rkey; | |
303 | } | |
304 | ||
305 | static ssize_t nfs_idmap_get_key(const char *name, size_t namelen, | |
306 | const char *type, void *data, | |
307 | size_t data_size, struct idmap *idmap) | |
308 | { | |
309 | const struct cred *saved_cred; | |
310 | struct key *rkey; | |
146aa8b1 | 311 | const struct user_key_payload *payload; |
ffa57b9e | 312 | ssize_t ret; |
955a857e BS |
313 | |
314 | saved_cred = override_creds(id_resolver_cache); | |
ffa57b9e | 315 | rkey = nfs_idmap_request_key(name, namelen, type, idmap); |
955a857e | 316 | revert_creds(saved_cred); |
57e62324 | 317 | |
955a857e BS |
318 | if (IS_ERR(rkey)) { |
319 | ret = PTR_ERR(rkey); | |
320 | goto out; | |
321 | } | |
322 | ||
323 | rcu_read_lock(); | |
028db3e2 LT |
324 | rkey->perm |= KEY_USR_VIEW; |
325 | ||
955a857e BS |
326 | ret = key_validate(rkey); |
327 | if (ret < 0) | |
328 | goto out_up; | |
329 | ||
0837e49a | 330 | payload = user_key_payload_rcu(rkey); |
955a857e BS |
331 | if (IS_ERR_OR_NULL(payload)) { |
332 | ret = PTR_ERR(payload); | |
333 | goto out_up; | |
334 | } | |
335 | ||
336 | ret = payload->datalen; | |
337 | if (ret > 0 && ret <= data_size) | |
338 | memcpy(data, payload->data, ret); | |
339 | else | |
340 | ret = -EINVAL; | |
341 | ||
342 | out_up: | |
343 | rcu_read_unlock(); | |
344 | key_put(rkey); | |
345 | out: | |
346 | return ret; | |
347 | } | |
348 | ||
955a857e | 349 | /* ID -> Name */ |
57e62324 BS |
350 | static ssize_t nfs_idmap_lookup_name(__u32 id, const char *type, char *buf, |
351 | size_t buflen, struct idmap *idmap) | |
955a857e BS |
352 | { |
353 | char id_str[NFS_UINT_MAXLEN]; | |
354 | int id_len; | |
355 | ssize_t ret; | |
356 | ||
d6889480 | 357 | id_len = nfs_map_numeric_to_string(id, id_str, sizeof(id_str)); |
57e62324 | 358 | ret = nfs_idmap_get_key(id_str, id_len, type, buf, buflen, idmap); |
955a857e BS |
359 | if (ret < 0) |
360 | return -EINVAL; | |
361 | return ret; | |
362 | } | |
363 | ||
364 | /* Name -> ID */ | |
57e62324 BS |
365 | static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *type, |
366 | __u32 *id, struct idmap *idmap) | |
955a857e BS |
367 | { |
368 | char id_str[NFS_UINT_MAXLEN]; | |
369 | long id_long; | |
370 | ssize_t data_size; | |
371 | int ret = 0; | |
372 | ||
57e62324 | 373 | data_size = nfs_idmap_get_key(name, namelen, type, id_str, NFS_UINT_MAXLEN, idmap); |
955a857e BS |
374 | if (data_size <= 0) { |
375 | ret = -EINVAL; | |
376 | } else { | |
7297cb68 | 377 | ret = kstrtol(id_str, 10, &id_long); |
4cd1ec95 DC |
378 | if (!ret) |
379 | *id = (__u32)id_long; | |
955a857e BS |
380 | } |
381 | return ret; | |
382 | } | |
383 | ||
e6499c6f | 384 | /* idmap classic begins here */ |
f0b85168 | 385 | |
57e62324 BS |
386 | enum { |
387 | Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err | |
1da177e4 LT |
388 | }; |
389 | ||
57e62324 BS |
390 | static const match_table_t nfs_idmap_tokens = { |
391 | { Opt_find_uid, "uid:%s" }, | |
392 | { Opt_find_gid, "gid:%s" }, | |
393 | { Opt_find_user, "user:%s" }, | |
394 | { Opt_find_group, "group:%s" }, | |
395 | { Opt_find_err, NULL } | |
1da177e4 LT |
396 | }; |
397 | ||
822ad64d | 398 | static int nfs_idmap_legacy_upcall(struct key *, void *); |
369af0f1 CL |
399 | static ssize_t idmap_pipe_downcall(struct file *, const char __user *, |
400 | size_t); | |
c5066945 | 401 | static void idmap_release_pipe(struct inode *); |
369af0f1 | 402 | static void idmap_pipe_destroy_msg(struct rpc_pipe_msg *); |
1da177e4 | 403 | |
b693ba4a | 404 | static const struct rpc_pipe_ops idmap_upcall_ops = { |
c1225158 | 405 | .upcall = rpc_pipe_generic_upcall, |
369af0f1 | 406 | .downcall = idmap_pipe_downcall, |
c5066945 | 407 | .release_pipe = idmap_release_pipe, |
369af0f1 | 408 | .destroy_msg = idmap_pipe_destroy_msg, |
1da177e4 LT |
409 | }; |
410 | ||
17280175 | 411 | static struct key_type key_type_id_resolver_legacy = { |
a427b9ec | 412 | .name = "id_legacy", |
f9167789 DH |
413 | .preparse = user_preparse, |
414 | .free_preparse = user_free_preparse, | |
415 | .instantiate = generic_key_instantiate, | |
57e62324 BS |
416 | .revoke = user_revoke, |
417 | .destroy = user_destroy, | |
418 | .describe = user_describe, | |
419 | .read = user_read, | |
420 | .request_key = nfs_idmap_legacy_upcall, | |
421 | }; | |
422 | ||
2127d82a TM |
423 | static void nfs_idmap_pipe_destroy(struct dentry *dir, |
424 | struct rpc_pipe_dir_object *pdo) | |
4929d1d3 | 425 | { |
2127d82a TM |
426 | struct idmap *idmap = pdo->pdo_data; |
427 | struct rpc_pipe *pipe = idmap->idmap_pipe; | |
428 | ||
d7631250 | 429 | if (pipe->dentry) { |
4929d1d3 | 430 | rpc_unlink(pipe->dentry); |
d7631250 TM |
431 | pipe->dentry = NULL; |
432 | } | |
4929d1d3 SK |
433 | } |
434 | ||
2127d82a TM |
435 | static int nfs_idmap_pipe_create(struct dentry *dir, |
436 | struct rpc_pipe_dir_object *pdo) | |
4929d1d3 | 437 | { |
2127d82a TM |
438 | struct idmap *idmap = pdo->pdo_data; |
439 | struct rpc_pipe *pipe = idmap->idmap_pipe; | |
4929d1d3 SK |
440 | struct dentry *dentry; |
441 | ||
442 | dentry = rpc_mkpipe_dentry(dir, "idmap", idmap, pipe); | |
443 | if (IS_ERR(dentry)) | |
444 | return PTR_ERR(dentry); | |
445 | pipe->dentry = dentry; | |
446 | return 0; | |
447 | } | |
448 | ||
2127d82a TM |
449 | static const struct rpc_pipe_dir_object_ops nfs_idmap_pipe_dir_object_ops = { |
450 | .create = nfs_idmap_pipe_create, | |
451 | .destroy = nfs_idmap_pipe_destroy, | |
452 | }; | |
4929d1d3 | 453 | |
b7162792 | 454 | int |
adfa6f98 | 455 | nfs_idmap_new(struct nfs_client *clp) |
1da177e4 LT |
456 | { |
457 | struct idmap *idmap; | |
c239d83b | 458 | struct rpc_pipe *pipe; |
b7162792 | 459 | int error; |
1da177e4 | 460 | |
369af0f1 CL |
461 | idmap = kzalloc(sizeof(*idmap), GFP_KERNEL); |
462 | if (idmap == NULL) | |
463 | return -ENOMEM; | |
1da177e4 | 464 | |
58002399 | 465 | mutex_init(&idmap->idmap_mutex); |
61ca2c4a | 466 | idmap->user_ns = get_user_ns(clp->cl_rpcclient->cl_cred->user_ns); |
58002399 | 467 | |
2127d82a TM |
468 | rpc_init_pipe_dir_object(&idmap->idmap_pdo, |
469 | &nfs_idmap_pipe_dir_object_ops, | |
470 | idmap); | |
471 | ||
c239d83b SK |
472 | pipe = rpc_mkpipe_data(&idmap_upcall_ops, 0); |
473 | if (IS_ERR(pipe)) { | |
474 | error = PTR_ERR(pipe); | |
2127d82a | 475 | goto err; |
c239d83b SK |
476 | } |
477 | idmap->idmap_pipe = pipe; | |
1da177e4 | 478 | |
2127d82a TM |
479 | error = rpc_add_pipe_dir_object(clp->cl_net, |
480 | &clp->cl_rpcclient->cl_pipedir_objects, | |
481 | &idmap->idmap_pdo); | |
482 | if (error) | |
483 | goto err_destroy_pipe; | |
484 | ||
1da177e4 | 485 | clp->cl_idmap = idmap; |
b7162792 | 486 | return 0; |
2127d82a TM |
487 | err_destroy_pipe: |
488 | rpc_destroy_pipe_data(idmap->idmap_pipe); | |
489 | err: | |
d5f458a9 | 490 | put_user_ns(idmap->user_ns); |
2127d82a TM |
491 | kfree(idmap); |
492 | return error; | |
1da177e4 LT |
493 | } |
494 | ||
495 | void | |
adfa6f98 | 496 | nfs_idmap_delete(struct nfs_client *clp) |
1da177e4 LT |
497 | { |
498 | struct idmap *idmap = clp->cl_idmap; | |
499 | ||
500 | if (!idmap) | |
501 | return; | |
1da177e4 | 502 | clp->cl_idmap = NULL; |
2127d82a TM |
503 | rpc_remove_pipe_dir_object(clp->cl_net, |
504 | &clp->cl_rpcclient->cl_pipedir_objects, | |
505 | &idmap->idmap_pdo); | |
506 | rpc_destroy_pipe_data(idmap->idmap_pipe); | |
61ca2c4a | 507 | put_user_ns(idmap->user_ns); |
1da177e4 LT |
508 | kfree(idmap); |
509 | } | |
510 | ||
c5066945 BS |
511 | static int nfs_idmap_prepare_message(char *desc, struct idmap *idmap, |
512 | struct idmap_msg *im, | |
57e62324 | 513 | struct rpc_pipe_msg *msg) |
1da177e4 | 514 | { |
57e62324 BS |
515 | substring_t substr; |
516 | int token, ret; | |
1da177e4 | 517 | |
57e62324 BS |
518 | im->im_type = IDMAP_TYPE_GROUP; |
519 | token = match_token(desc, nfs_idmap_tokens, &substr); | |
1da177e4 | 520 | |
57e62324 BS |
521 | switch (token) { |
522 | case Opt_find_uid: | |
523 | im->im_type = IDMAP_TYPE_USER; | |
df561f66 | 524 | fallthrough; |
57e62324 BS |
525 | case Opt_find_gid: |
526 | im->im_conv = IDMAP_CONV_NAMETOID; | |
527 | ret = match_strlcpy(im->im_name, &substr, IDMAP_NAMESZ); | |
528 | break; | |
1da177e4 | 529 | |
57e62324 BS |
530 | case Opt_find_user: |
531 | im->im_type = IDMAP_TYPE_USER; | |
df561f66 | 532 | fallthrough; |
57e62324 BS |
533 | case Opt_find_group: |
534 | im->im_conv = IDMAP_CONV_IDTONAME; | |
535 | ret = match_int(&substr, &im->im_id); | |
12b289cf CX |
536 | if (ret) |
537 | goto out; | |
57e62324 | 538 | break; |
1da177e4 | 539 | |
57e62324 BS |
540 | default: |
541 | ret = -EINVAL; | |
1da177e4 LT |
542 | goto out; |
543 | } | |
544 | ||
57e62324 BS |
545 | msg->data = im; |
546 | msg->len = sizeof(struct idmap_msg); | |
1da177e4 | 547 | |
57e62324 | 548 | out: |
369af0f1 | 549 | return ret; |
1da177e4 LT |
550 | } |
551 | ||
e9ab41b6 TM |
552 | static bool |
553 | nfs_idmap_prepare_pipe_upcall(struct idmap *idmap, | |
0cac1202 | 554 | struct idmap_legacy_upcalldata *data) |
e9ab41b6 | 555 | { |
0cac1202 | 556 | if (idmap->idmap_upcall_data != NULL) { |
e9ab41b6 TM |
557 | WARN_ON_ONCE(1); |
558 | return false; | |
559 | } | |
0cac1202 | 560 | idmap->idmap_upcall_data = data; |
e9ab41b6 TM |
561 | return true; |
562 | } | |
563 | ||
564 | static void | |
565 | nfs_idmap_complete_pipe_upcall_locked(struct idmap *idmap, int ret) | |
566 | { | |
822ad64d | 567 | struct key *authkey = idmap->idmap_upcall_data->authkey; |
e9ab41b6 | 568 | |
0cac1202 TM |
569 | kfree(idmap->idmap_upcall_data); |
570 | idmap->idmap_upcall_data = NULL; | |
822ad64d DH |
571 | complete_request_key(authkey, ret); |
572 | key_put(authkey); | |
e9ab41b6 TM |
573 | } |
574 | ||
575 | static void | |
576 | nfs_idmap_abort_pipe_upcall(struct idmap *idmap, int ret) | |
577 | { | |
0cac1202 | 578 | if (idmap->idmap_upcall_data != NULL) |
e9ab41b6 TM |
579 | nfs_idmap_complete_pipe_upcall_locked(idmap, ret); |
580 | } | |
581 | ||
822ad64d | 582 | static int nfs_idmap_legacy_upcall(struct key *authkey, void *aux) |
1da177e4 | 583 | { |
c5066945 | 584 | struct idmap_legacy_upcalldata *data; |
822ad64d | 585 | struct request_key_auth *rka = get_request_key_auth(authkey); |
57e62324 | 586 | struct rpc_pipe_msg *msg; |
1da177e4 | 587 | struct idmap_msg *im; |
57e62324 | 588 | struct idmap *idmap = (struct idmap *)aux; |
822ad64d | 589 | struct key *key = rka->target_key; |
49686cbb EB |
590 | int ret = -ENOKEY; |
591 | ||
592 | if (!aux) | |
593 | goto out1; | |
1da177e4 | 594 | |
57e62324 | 595 | /* msg and im are freed in idmap_pipe_destroy_msg */ |
49686cbb | 596 | ret = -ENOMEM; |
57a51048 | 597 | data = kzalloc(sizeof(*data), GFP_KERNEL); |
c5066945 | 598 | if (!data) |
57e62324 | 599 | goto out1; |
1da177e4 | 600 | |
c5066945 BS |
601 | msg = &data->pipe_msg; |
602 | im = &data->idmap_msg; | |
603 | data->idmap = idmap; | |
822ad64d | 604 | data->authkey = key_get(authkey); |
c5066945 BS |
605 | |
606 | ret = nfs_idmap_prepare_message(key->description, idmap, im, msg); | |
57e62324 BS |
607 | if (ret < 0) |
608 | goto out2; | |
1da177e4 | 609 | |
e9ab41b6 | 610 | ret = -EAGAIN; |
0cac1202 | 611 | if (!nfs_idmap_prepare_pipe_upcall(idmap, data)) |
0e24d849 | 612 | goto out2; |
1da177e4 | 613 | |
11588f49 BS |
614 | ret = rpc_queue_upcall(idmap->idmap_pipe, msg); |
615 | if (ret < 0) | |
e9ab41b6 | 616 | nfs_idmap_abort_pipe_upcall(idmap, ret); |
1da177e4 | 617 | |
11588f49 | 618 | return ret; |
57e62324 | 619 | out2: |
c5066945 | 620 | kfree(data); |
57e62324 | 621 | out1: |
822ad64d | 622 | complete_request_key(authkey, ret); |
369af0f1 | 623 | return ret; |
1da177e4 LT |
624 | } |
625 | ||
cf4ab538 | 626 | static int nfs_idmap_instantiate(struct key *key, struct key *authkey, char *data, size_t datalen) |
1da177e4 | 627 | { |
cf4ab538 | 628 | return key_instantiate_and_link(key, data, datalen, |
57e62324 BS |
629 | id_resolver_cache->thread_keyring, |
630 | authkey); | |
631 | } | |
1da177e4 | 632 | |
0cac1202 TM |
633 | static int nfs_idmap_read_and_verify_message(struct idmap_msg *im, |
634 | struct idmap_msg *upcall, | |
635 | struct key *key, struct key *authkey) | |
57e62324 BS |
636 | { |
637 | char id_str[NFS_UINT_MAXLEN]; | |
cf4ab538 | 638 | size_t len; |
0cac1202 | 639 | int ret = -ENOKEY; |
1da177e4 | 640 | |
0cac1202 TM |
641 | /* ret = -ENOKEY */ |
642 | if (upcall->im_type != im->im_type || upcall->im_conv != im->im_conv) | |
643 | goto out; | |
57e62324 BS |
644 | switch (im->im_conv) { |
645 | case IDMAP_CONV_NAMETOID: | |
0cac1202 TM |
646 | if (strcmp(upcall->im_name, im->im_name) != 0) |
647 | break; | |
cf4ab538 | 648 | /* Note: here we store the NUL terminator too */ |
d6889480 DW |
649 | len = 1 + nfs_map_numeric_to_string(im->im_id, id_str, |
650 | sizeof(id_str)); | |
cf4ab538 | 651 | ret = nfs_idmap_instantiate(key, authkey, id_str, len); |
57e62324 BS |
652 | break; |
653 | case IDMAP_CONV_IDTONAME: | |
0cac1202 TM |
654 | if (upcall->im_id != im->im_id) |
655 | break; | |
cf4ab538 TM |
656 | len = strlen(im->im_name); |
657 | ret = nfs_idmap_instantiate(key, authkey, im->im_name, len); | |
57e62324 | 658 | break; |
0cac1202 TM |
659 | default: |
660 | ret = -EINVAL; | |
1da177e4 | 661 | } |
0cac1202 | 662 | out: |
1da177e4 LT |
663 | return ret; |
664 | } | |
665 | ||
1da177e4 LT |
666 | static ssize_t |
667 | idmap_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) | |
668 | { | |
822ad64d | 669 | struct request_key_auth *rka; |
496ad9aa | 670 | struct rpc_inode *rpci = RPC_I(file_inode(filp)); |
1da177e4 | 671 | struct idmap *idmap = (struct idmap *)rpci->private; |
822ad64d | 672 | struct key *authkey; |
57e62324 | 673 | struct idmap_msg im; |
d24aae41 | 674 | size_t namelen_in; |
e9ab41b6 | 675 | int ret = -ENOKEY; |
1da177e4 | 676 | |
a427b9ec DH |
677 | /* If instantiation is successful, anyone waiting for key construction |
678 | * will have been woken up and someone else may now have used | |
679 | * idmap_key_cons - so after this point we may no longer touch it. | |
680 | */ | |
0cac1202 | 681 | if (idmap->idmap_upcall_data == NULL) |
e9ab41b6 | 682 | goto out_noupcall; |
a427b9ec | 683 | |
822ad64d DH |
684 | authkey = idmap->idmap_upcall_data->authkey; |
685 | rka = get_request_key_auth(authkey); | |
a427b9ec | 686 | |
57e62324 BS |
687 | if (mlen != sizeof(im)) { |
688 | ret = -ENOSPC; | |
1da177e4 LT |
689 | goto out; |
690 | } | |
691 | ||
57e62324 BS |
692 | if (copy_from_user(&im, src, mlen) != 0) { |
693 | ret = -EFAULT; | |
1da177e4 | 694 | goto out; |
57e62324 | 695 | } |
1da177e4 | 696 | |
57e62324 | 697 | if (!(im.im_status & IDMAP_STATUS_SUCCESS)) { |
12dfd080 BS |
698 | ret = -ENOKEY; |
699 | goto out; | |
1da177e4 LT |
700 | } |
701 | ||
57e62324 BS |
702 | namelen_in = strnlen(im.im_name, IDMAP_NAMESZ); |
703 | if (namelen_in == 0 || namelen_in == IDMAP_NAMESZ) { | |
704 | ret = -EINVAL; | |
1da177e4 | 705 | goto out; |
0cac1202 | 706 | } |
1da177e4 | 707 | |
0cac1202 TM |
708 | ret = nfs_idmap_read_and_verify_message(&im, |
709 | &idmap->idmap_upcall_data->idmap_msg, | |
822ad64d | 710 | rka->target_key, authkey); |
57e62324 | 711 | if (ret >= 0) { |
822ad64d | 712 | key_set_timeout(rka->target_key, nfs_idmap_cache_timeout); |
57e62324 BS |
713 | ret = mlen; |
714 | } | |
715 | ||
1da177e4 | 716 | out: |
e9ab41b6 TM |
717 | nfs_idmap_complete_pipe_upcall_locked(idmap, ret); |
718 | out_noupcall: | |
1da177e4 LT |
719 | return ret; |
720 | } | |
721 | ||
75c96f85 | 722 | static void |
1da177e4 LT |
723 | idmap_pipe_destroy_msg(struct rpc_pipe_msg *msg) |
724 | { | |
c5066945 BS |
725 | struct idmap_legacy_upcalldata *data = container_of(msg, |
726 | struct idmap_legacy_upcalldata, | |
727 | pipe_msg); | |
728 | struct idmap *idmap = data->idmap; | |
e9ab41b6 TM |
729 | |
730 | if (msg->errno) | |
731 | nfs_idmap_abort_pipe_upcall(idmap, msg->errno); | |
c5066945 BS |
732 | } |
733 | ||
734 | static void | |
735 | idmap_release_pipe(struct inode *inode) | |
736 | { | |
737 | struct rpc_inode *rpci = RPC_I(inode); | |
738 | struct idmap *idmap = (struct idmap *)rpci->private; | |
e9ab41b6 TM |
739 | |
740 | nfs_idmap_abort_pipe_upcall(idmap, -EPIPE); | |
1da177e4 LT |
741 | } |
742 | ||
9f309c86 | 743 | int nfs_map_name_to_uid(const struct nfs_server *server, const char *name, size_t namelen, kuid_t *uid) |
1da177e4 | 744 | { |
e4fd72a1 | 745 | struct idmap *idmap = server->nfs_client->cl_idmap; |
9f309c86 EB |
746 | __u32 id = -1; |
747 | int ret = 0; | |
1da177e4 | 748 | |
9f309c86 EB |
749 | if (!nfs_map_string_to_numeric(name, namelen, &id)) |
750 | ret = nfs_idmap_lookup_id(name, namelen, "uid", &id, idmap); | |
751 | if (ret == 0) { | |
58002399 | 752 | *uid = make_kuid(idmap_userns(idmap), id); |
9f309c86 EB |
753 | if (!uid_valid(*uid)) |
754 | ret = -ERANGE; | |
755 | } | |
1f2d30b5 | 756 | trace_nfs4_map_name_to_uid(name, namelen, id, ret); |
9f309c86 | 757 | return ret; |
1da177e4 LT |
758 | } |
759 | ||
9f309c86 | 760 | int nfs_map_group_to_gid(const struct nfs_server *server, const char *name, size_t namelen, kgid_t *gid) |
1da177e4 | 761 | { |
e4fd72a1 | 762 | struct idmap *idmap = server->nfs_client->cl_idmap; |
9f309c86 EB |
763 | __u32 id = -1; |
764 | int ret = 0; | |
1da177e4 | 765 | |
9f309c86 EB |
766 | if (!nfs_map_string_to_numeric(name, namelen, &id)) |
767 | ret = nfs_idmap_lookup_id(name, namelen, "gid", &id, idmap); | |
768 | if (ret == 0) { | |
58002399 | 769 | *gid = make_kgid(idmap_userns(idmap), id); |
9f309c86 EB |
770 | if (!gid_valid(*gid)) |
771 | ret = -ERANGE; | |
772 | } | |
1f2d30b5 | 773 | trace_nfs4_map_group_to_gid(name, namelen, id, ret); |
9f309c86 | 774 | return ret; |
1da177e4 LT |
775 | } |
776 | ||
9f309c86 | 777 | int nfs_map_uid_to_name(const struct nfs_server *server, kuid_t uid, char *buf, size_t buflen) |
1da177e4 | 778 | { |
e4fd72a1 | 779 | struct idmap *idmap = server->nfs_client->cl_idmap; |
b064eca2 | 780 | int ret = -EINVAL; |
9f309c86 | 781 | __u32 id; |
1da177e4 | 782 | |
58002399 | 783 | id = from_kuid_munged(idmap_userns(idmap), uid); |
b064eca2 | 784 | if (!(server->caps & NFS_CAP_UIDGID_NOMAP)) |
9f309c86 | 785 | ret = nfs_idmap_lookup_name(id, "user", buf, buflen, idmap); |
f0b85168 | 786 | if (ret < 0) |
9f309c86 | 787 | ret = nfs_map_numeric_to_string(id, buf, buflen); |
1f2d30b5 | 788 | trace_nfs4_map_uid_to_name(buf, ret, id, ret); |
f0b85168 | 789 | return ret; |
1da177e4 | 790 | } |
9f309c86 | 791 | int nfs_map_gid_to_group(const struct nfs_server *server, kgid_t gid, char *buf, size_t buflen) |
1da177e4 | 792 | { |
e4fd72a1 | 793 | struct idmap *idmap = server->nfs_client->cl_idmap; |
b064eca2 | 794 | int ret = -EINVAL; |
9f309c86 | 795 | __u32 id; |
1da177e4 | 796 | |
58002399 | 797 | id = from_kgid_munged(idmap_userns(idmap), gid); |
b064eca2 | 798 | if (!(server->caps & NFS_CAP_UIDGID_NOMAP)) |
9f309c86 | 799 | ret = nfs_idmap_lookup_name(id, "group", buf, buflen, idmap); |
f0b85168 | 800 | if (ret < 0) |
9f309c86 | 801 | ret = nfs_map_numeric_to_string(id, buf, buflen); |
1f2d30b5 | 802 | trace_nfs4_map_gid_to_group(buf, ret, id, ret); |
f0b85168 | 803 | return ret; |
1da177e4 | 804 | } |