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