[net-next-2.6.git] / fs / nfsd / nfs4idmap.c

/*
 *  Mapping of UID/GIDs to name and vice versa.
 *
 *  Copyright (c) 2002, 2003 The Regents of the University of
 *  Michigan.  All rights reserved.
 *
 *  Marius Aamodt Eriksen <marius@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/module.h>
#include <linux/nfsd_idmap.h>
#include <linux/seq_file.h>
#include <linux/sched.h>
#include <linux/slab.h>

/*
 * Cache entry
 */

/*
 * XXX we know that IDMAP_NAMESZ < PAGE_SIZE, but it's ugly to rely on
 * that.
 */

#define IDMAP_TYPE_USER  0
#define IDMAP_TYPE_GROUP 1

struct ent {
	struct cache_head h;
	int               type;		       /* User / Group */
	uid_t             id;
	char              name[IDMAP_NAMESZ];
	char              authname[IDMAP_NAMESZ];
};

/* Common entry handling */

#define ENT_HASHBITS          8
#define ENT_HASHMAX           (1 << ENT_HASHBITS)
#define ENT_HASHMASK          (ENT_HASHMAX - 1)

static void
ent_init(struct cache_head *cnew, struct cache_head *citm)
{
	struct ent *new = container_of(cnew, struct ent, h);
	struct ent *itm = container_of(citm, struct ent, h);

	new->id = itm->id;
	new->type = itm->type;

	strlcpy(new->name, itm->name, sizeof(new->name));
	strlcpy(new->authname, itm->authname, sizeof(new->name));
}

static void
ent_put(struct kref *ref)
{
	struct ent *map = container_of(ref, struct ent, h.ref);
	kfree(map);
}

static struct cache_head *
ent_alloc(void)
{
	struct ent *e = kmalloc(sizeof(*e), GFP_KERNEL);
	if (e)
		return &e->h;
	else
		return NULL;
}

/*
 * ID -> Name cache
 */

static struct cache_head *idtoname_table[ENT_HASHMAX];

static uint32_t
idtoname_hash(struct ent *ent)
{
	uint32_t hash;

	hash = hash_str(ent->authname, ENT_HASHBITS);
	hash = hash_long(hash ^ ent->id, ENT_HASHBITS);

	/* Flip LSB for user/group */
	if (ent->type == IDMAP_TYPE_GROUP)
		hash ^= 1;

	return hash;
}

static void
idtoname_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
    int *blen)
{
 	struct ent *ent = container_of(ch, struct ent, h);
	char idstr[11];

	qword_add(bpp, blen, ent->authname);
	snprintf(idstr, sizeof(idstr), "%u", ent->id);
	qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
	qword_add(bpp, blen, idstr);

	(*bpp)[-1] = '\n';
}

static int
idtoname_upcall(struct cache_detail *cd, struct cache_head *ch)
{
	return sunrpc_cache_pipe_upcall(cd, ch, idtoname_request);
}

static int
idtoname_match(struct cache_head *ca, struct cache_head *cb)
{
	struct ent *a = container_of(ca, struct ent, h);
	struct ent *b = container_of(cb, struct ent, h);

	return (a->id == b->id && a->type == b->type &&
	    strcmp(a->authname, b->authname) == 0);
}

static int
idtoname_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
{
	struct ent *ent;

	if (h == NULL) {
		seq_puts(m, "#domain type id [name]\n");
		return 0;
	}
	ent = container_of(h, struct ent, h);
	seq_printf(m, "%s %s %u", ent->authname,
			ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
			ent->id);
	if (test_bit(CACHE_VALID, &h->flags))
		seq_printf(m, " %s", ent->name);
	seq_printf(m, "\n");
	return 0;
}

static void
warn_no_idmapd(struct cache_detail *detail, int has_died)
{
	printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",
			has_died ? "died" : "not been started");
}


static int         idtoname_parse(struct cache_detail *, char *, int);
static struct ent *idtoname_lookup(struct ent *);
static struct ent *idtoname_update(struct ent *, struct ent *);

static struct cache_detail idtoname_cache = {
	.owner		= THIS_MODULE,
	.hash_size	= ENT_HASHMAX,
	.hash_table	= idtoname_table,
	.name		= "nfs4.idtoname",
	.cache_put	= ent_put,
	.cache_upcall	= idtoname_upcall,
	.cache_parse	= idtoname_parse,
	.cache_show	= idtoname_show,
	.warn_no_listener = warn_no_idmapd,
	.match		= idtoname_match,
	.init		= ent_init,
	.update		= ent_init,
	.alloc		= ent_alloc,
};

static int
idtoname_parse(struct cache_detail *cd, char *buf, int buflen)
{
	struct ent ent, *res;
	char *buf1, *bp;
	int len;
	int error = -EINVAL;

	if (buf[buflen - 1] != '\n')
		return (-EINVAL);
	buf[buflen - 1]= '\0';

	buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (buf1 == NULL)
		return (-ENOMEM);

	memset(&ent, 0, sizeof(ent));

	/* Authentication name */
	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
		goto out;
	memcpy(ent.authname, buf1, sizeof(ent.authname));

	/* Type */
	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
		goto out;
	ent.type = strcmp(buf1, "user") == 0 ?
		IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;

	/* ID */
	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
		goto out;
	ent.id = simple_strtoul(buf1, &bp, 10);
	if (bp == buf1)
		goto out;

	/* expiry */
	ent.h.expiry_time = get_expiry(&buf);
	if (ent.h.expiry_time == 0)
		goto out;

	error = -ENOMEM;
	res = idtoname_lookup(&ent);
	if (!res)
		goto out;

	/* Name */
	error = -EINVAL;
	len = qword_get(&buf, buf1, PAGE_SIZE);
	if (len < 0)
		goto out;
	if (len == 0)
		set_bit(CACHE_NEGATIVE, &ent.h.flags);
	else if (len >= IDMAP_NAMESZ)
		goto out;
	else
		memcpy(ent.name, buf1, sizeof(ent.name));
	error = -ENOMEM;
	res = idtoname_update(&ent, res);
	if (res == NULL)
		goto out;

	cache_put(&res->h, &idtoname_cache);

	error = 0;
out:
	kfree(buf1);

	return error;
}


static struct ent *
idtoname_lookup(struct ent *item)
{
	struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,
						    &item->h,
						    idtoname_hash(item));
	if (ch)
		return container_of(ch, struct ent, h);
	else
		return NULL;
}

static struct ent *
idtoname_update(struct ent *new, struct ent *old)
{
	struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,
						    &new->h, &old->h,
						    idtoname_hash(new));
	if (ch)
		return container_of(ch, struct ent, h);
	else
		return NULL;
}


/*
 * Name -> ID cache
 */

static struct cache_head *nametoid_table[ENT_HASHMAX];

static inline int
nametoid_hash(struct ent *ent)
{
	return hash_str(ent->name, ENT_HASHBITS);
}

static void
nametoid_request(struct cache_detail *cd, struct cache_head *ch, char **bpp,
    int *blen)
{
 	struct ent *ent = container_of(ch, struct ent, h);

	qword_add(bpp, blen, ent->authname);
	qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
	qword_add(bpp, blen, ent->name);

	(*bpp)[-1] = '\n';
}

static int
nametoid_upcall(struct cache_detail *cd, struct cache_head *ch)
{
	return sunrpc_cache_pipe_upcall(cd, ch, nametoid_request);
}

static int
nametoid_match(struct cache_head *ca, struct cache_head *cb)
{
	struct ent *a = container_of(ca, struct ent, h);
	struct ent *b = container_of(cb, struct ent, h);

	return (a->type == b->type && strcmp(a->name, b->name) == 0 &&
	    strcmp(a->authname, b->authname) == 0);
}

static int
nametoid_show(struct seq_file *m, struct cache_detail *cd, struct cache_head *h)
{
	struct ent *ent;

	if (h == NULL) {
		seq_puts(m, "#domain type name [id]\n");
		return 0;
	}
	ent = container_of(h, struct ent, h);
	seq_printf(m, "%s %s %s", ent->authname,
			ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
			ent->name);
	if (test_bit(CACHE_VALID, &h->flags))
		seq_printf(m, " %u", ent->id);
	seq_printf(m, "\n");
	return 0;
}

static struct ent *nametoid_lookup(struct ent *);
static struct ent *nametoid_update(struct ent *, struct ent *);
static int         nametoid_parse(struct cache_detail *, char *, int);

static struct cache_detail nametoid_cache = {
	.owner		= THIS_MODULE,
	.hash_size	= ENT_HASHMAX,
	.hash_table	= nametoid_table,
	.name		= "nfs4.nametoid",
	.cache_put	= ent_put,
	.cache_upcall	= nametoid_upcall,
	.cache_parse	= nametoid_parse,
	.cache_show	= nametoid_show,
	.warn_no_listener = warn_no_idmapd,
	.match		= nametoid_match,
	.init		= ent_init,
	.update		= ent_init,
	.alloc		= ent_alloc,
};

static int
nametoid_parse(struct cache_detail *cd, char *buf, int buflen)
{
	struct ent ent, *res;
	char *buf1;
	int error = -EINVAL;

	if (buf[buflen - 1] != '\n')
		return (-EINVAL);
	buf[buflen - 1]= '\0';

	buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (buf1 == NULL)
		return (-ENOMEM);

	memset(&ent, 0, sizeof(ent));

	/* Authentication name */
	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
		goto out;
	memcpy(ent.authname, buf1, sizeof(ent.authname));

	/* Type */
	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
		goto out;
	ent.type = strcmp(buf1, "user") == 0 ?
		IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;

	/* Name */
	error = qword_get(&buf, buf1, PAGE_SIZE);
	if (error <= 0 || error >= IDMAP_NAMESZ)
		goto out;
	memcpy(ent.name, buf1, sizeof(ent.name));

	/* expiry */
	ent.h.expiry_time = get_expiry(&buf);
	if (ent.h.expiry_time == 0)
		goto out;

	/* ID */
	error = get_int(&buf, &ent.id);
	if (error == -EINVAL)
		goto out;
	if (error == -ENOENT)
		set_bit(CACHE_NEGATIVE, &ent.h.flags);

	error = -ENOMEM;
	res = nametoid_lookup(&ent);
	if (res == NULL)
		goto out;
	res = nametoid_update(&ent, res);
	if (res == NULL)
		goto out;

	cache_put(&res->h, &nametoid_cache);
	error = 0;
out:
	kfree(buf1);

	return (error);
}


static struct ent *
nametoid_lookup(struct ent *item)
{
	struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,
						    &item->h,
						    nametoid_hash(item));
	if (ch)
		return container_of(ch, struct ent, h);
	else
		return NULL;
}

static struct ent *
nametoid_update(struct ent *new, struct ent *old)
{
	struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,
						    &new->h, &old->h,
						    nametoid_hash(new));
	if (ch)
		return container_of(ch, struct ent, h);
	else
		return NULL;
}

/*
 * Exported API
 */

int
nfsd_idmap_init(void)
{
	int rv;

	rv = cache_register(&idtoname_cache);
	if (rv)
		return rv;
	rv = cache_register(&nametoid_cache);
	if (rv)
		cache_unregister(&idtoname_cache);
	return rv;
}

void
nfsd_idmap_shutdown(void)
{
	cache_unregister(&idtoname_cache);
	cache_unregister(&nametoid_cache);
}

static int
idmap_lookup(struct svc_rqst *rqstp,
		struct ent *(*lookup_fn)(struct ent *), struct ent *key,
		struct cache_detail *detail, struct ent **item)
{
	int ret;

	*item = lookup_fn(key);
	if (!*item)
		return -ENOMEM;
 retry:
	ret = cache_check(detail, &(*item)->h, &rqstp->rq_chandle);

	if (ret == -ETIMEDOUT) {
		struct ent *prev_item = *item;
		*item = lookup_fn(key);
		if (*item != prev_item)
			goto retry;
		cache_put(&(*item)->h, detail);
	}
	return ret;
}

static char *
rqst_authname(struct svc_rqst *rqstp)
{
	struct auth_domain *clp;

	clp = rqstp->rq_gssclient ? rqstp->rq_gssclient : rqstp->rq_client;
	return clp->name;
}

static int
idmap_name_to_id(struct svc_rqst *rqstp, int type, const char *name, u32 namelen,
		uid_t *id)
{
	struct ent *item, key = {
		.type = type,
	};
	int ret;

	if (namelen + 1 > sizeof(key.name))
		return -EINVAL;
	memcpy(key.name, name, namelen);
	key.name[namelen] = '\0';
	strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
	ret = idmap_lookup(rqstp, nametoid_lookup, &key, &nametoid_cache, &item);
	if (ret == -ENOENT)
		ret = -ESRCH; /* nfserr_badname */
	if (ret)
		return ret;
	*id = item->id;
	cache_put(&item->h, &nametoid_cache);
	return 0;
}

static int
idmap_id_to_name(struct svc_rqst *rqstp, int type, uid_t id, char *name)
{
	struct ent *item, key = {
		.id = id,
		.type = type,
	};
	int ret;

	strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
	ret = idmap_lookup(rqstp, idtoname_lookup, &key, &idtoname_cache, &item);
	if (ret == -ENOENT)
		return sprintf(name, "%u", id);
	if (ret)
		return ret;
	ret = strlen(item->name);
	BUG_ON(ret > IDMAP_NAMESZ);
	memcpy(name, item->name, ret);
	cache_put(&item->h, &idtoname_cache);
	return ret;
}

int
nfsd_map_name_to_uid(struct svc_rqst *rqstp, const char *name, size_t namelen,
		__u32 *id)
{
	return idmap_name_to_id(rqstp, IDMAP_TYPE_USER, name, namelen, id);
}

int
nfsd_map_name_to_gid(struct svc_rqst *rqstp, const char *name, size_t namelen,
		__u32 *id)
{
	return idmap_name_to_id(rqstp, IDMAP_TYPE_GROUP, name, namelen, id);
}

int
nfsd_map_uid_to_name(struct svc_rqst *rqstp, __u32 id, char *name)
{
	return idmap_id_to_name(rqstp, IDMAP_TYPE_USER, id, name);
}

int
nfsd_map_gid_to_name(struct svc_rqst *rqstp, __u32 id, char *name)
{
	return idmap_id_to_name(rqstp, IDMAP_TYPE_GROUP, id, name);
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Mapping of UID/GIDs to name and vice versa.
	3	*
	4	* Copyright (c) 2002, 2003 The Regents of the University of
	5	* Michigan. All rights reserved.
	6	*
	7	* Marius Aamodt Eriksen <marius@umich.edu>
	8	*
	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in the
	17	* documentation and/or other materials provided with the distribution.
	18	* 3. Neither the name of the University nor the names of its
	19	* contributors may be used to endorse or promote products derived
	20	* from this software without specific prior written permission.
	21	*
	22	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
	23	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	24	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	25	* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	26	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	27	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	28	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	29	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	30	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	31	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	32	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	33	*/
	34
1da177e4	35	#include <linux/module.h>
1da177e4	36	#include <linux/nfsd_idmap.h>
1da177e4	37	#include <linux/seq_file.h>
341eb184	38	#include <linux/sched.h>
5a0e3ad6	39	#include <linux/slab.h>
1da177e4 LT	40
	41	/*
	42	* Cache entry
	43	*/
	44
	45	/*
	46	* XXX we know that IDMAP_NAMESZ < PAGE_SIZE, but it's ugly to rely on
	47	* that.
	48	*/
	49
	50	#define IDMAP_TYPE_USER 0
	51	#define IDMAP_TYPE_GROUP 1
	52
	53	struct ent {
	54	struct cache_head h;
	55	int type; /* User / Group */
	56	uid_t id;
	57	char name[IDMAP_NAMESZ];
	58	char authname[IDMAP_NAMESZ];
	59	};
	60
1da177e4 LT	61	/* Common entry handling */
	62
	63	#define ENT_HASHBITS 8
	64	#define ENT_HASHMAX (1 << ENT_HASHBITS)
	65	#define ENT_HASHMASK (ENT_HASHMAX - 1)
	66
f9ecc921 N	67	static void
f9ecc921 N	68	ent_init(struct cache_head cnew, struct cache_head citm)
1da177e4	69	{
f9ecc921 N	70	struct ent *new = container_of(cnew, struct ent, h);
	71	struct ent *itm = container_of(citm, struct ent, h);
	72
1da177e4 LT	73	new->id = itm->id;
	74	new->type = itm->type;
	75
	76	strlcpy(new->name, itm->name, sizeof(new->name));
	77	strlcpy(new->authname, itm->authname, sizeof(new->name));
	78	}
	79
fd39ca9a	80	static void
baab935f	81	ent_put(struct kref *ref)
1da177e4	82	{
baab935f N	83	struct ent *map = container_of(ref, struct ent, h.ref);
baab935f N	84	kfree(map);
1da177e4 LT	85	}
1da177e4 LT	86
f9ecc921 N	87	static struct cache_head *
	88	ent_alloc(void)
	89	{
	90	struct ent e = kmalloc(sizeof(e), GFP_KERNEL);
	91	if (e)
	92	return &e->h;
	93	else
	94	return NULL;
	95	}
	96
1da177e4 LT	97	/*
	98	* ID -> Name cache
	99	*/
	100
	101	static struct cache_head *idtoname_table[ENT_HASHMAX];
	102
	103	static uint32_t
	104	idtoname_hash(struct ent *ent)
	105	{
	106	uint32_t hash;
	107
	108	hash = hash_str(ent->authname, ENT_HASHBITS);
	109	hash = hash_long(hash ^ ent->id, ENT_HASHBITS);
	110
	111	/* Flip LSB for user/group */
	112	if (ent->type == IDMAP_TYPE_GROUP)
	113	hash ^= 1;
	114
	115	return hash;
	116	}
	117
	118	static void
	119	idtoname_request(struct cache_detail cd, struct cache_head ch, char **bpp,
	120	int *blen)
	121	{
	122	struct ent *ent = container_of(ch, struct ent, h);
	123	char idstr[11];
	124
	125	qword_add(bpp, blen, ent->authname);
0a725fc4	126	snprintf(idstr, sizeof(idstr), "%u", ent->id);
1da177e4 LT	127	qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
	128	qword_add(bpp, blen, idstr);
	129
	130	(*bpp)[-1] = '\n';
	131	}
	132
bc74b4f5 TM	133	static int
	134	idtoname_upcall(struct cache_detail cd, struct cache_head ch)
	135	{
	136	return sunrpc_cache_pipe_upcall(cd, ch, idtoname_request);
	137	}
	138
f9ecc921 N	139	static int
f9ecc921 N	140	idtoname_match(struct cache_head ca, struct cache_head cb)
1da177e4	141	{
f9ecc921 N	142	struct ent *a = container_of(ca, struct ent, h);
	143	struct ent *b = container_of(cb, struct ent, h);
	144
1da177e4 LT	145	return (a->id == b->id && a->type == b->type &&
	146	strcmp(a->authname, b->authname) == 0);
	147	}
	148
	149	static int
	150	idtoname_show(struct seq_file m, struct cache_detail cd, struct cache_head *h)
	151	{
	152	struct ent *ent;
	153
	154	if (h == NULL) {
	155	seq_puts(m, "#domain type id [name]\n");
	156	return 0;
	157	}
	158	ent = container_of(h, struct ent, h);
0a725fc4	159	seq_printf(m, "%s %s %u", ent->authname,
1da177e4 LT	160	ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
	161	ent->id);
	162	if (test_bit(CACHE_VALID, &h->flags))
	163	seq_printf(m, " %s", ent->name);
	164	seq_printf(m, "\n");
	165	return 0;
	166	}
	167
	168	static void
2da8ca26	169	warn_no_idmapd(struct cache_detail *detail, int has_died)
1da177e4 LT	170	{
1da177e4 LT	171	printk("nfsd: nfsv4 idmapping failing: has idmapd %s?\n",
2da8ca26	172	has_died ? "died" : "not been started");
1da177e4 LT	173	}
	174
	175
	176	static int idtoname_parse(struct cache_detail , char , int);
f9ecc921 N	177	static struct ent idtoname_lookup(struct ent );
f9ecc921 N	178	static struct ent idtoname_update(struct ent , struct ent *);
1da177e4	179
fd39ca9a	180	static struct cache_detail idtoname_cache = {
f35279d3	181	.owner = THIS_MODULE,
1da177e4 LT	182	.hash_size = ENT_HASHMAX,
	183	.hash_table = idtoname_table,
	184	.name = "nfs4.idtoname",
	185	.cache_put = ent_put,
bc74b4f5	186	.cache_upcall = idtoname_upcall,
1da177e4 LT	187	.cache_parse = idtoname_parse,
	188	.cache_show = idtoname_show,
	189	.warn_no_listener = warn_no_idmapd,
f9ecc921 N	190	.match = idtoname_match,
	191	.init = ent_init,
	192	.update = ent_init,
	193	.alloc = ent_alloc,
1da177e4 LT	194	};
1da177e4 LT	195
a254b246	196	static int
1da177e4 LT	197	idtoname_parse(struct cache_detail cd, char buf, int buflen)
	198	{
	199	struct ent ent, *res;
	200	char buf1, bp;
c9b6cbe5	201	int len;
1da177e4 LT	202	int error = -EINVAL;
	203
	204	if (buf[buflen - 1] != '\n')
	205	return (-EINVAL);
	206	buf[buflen - 1]= '\0';
	207
	208	buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
	209	if (buf1 == NULL)
	210	return (-ENOMEM);
	211
	212	memset(&ent, 0, sizeof(ent));
	213
	214	/* Authentication name */
	215	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
	216	goto out;
	217	memcpy(ent.authname, buf1, sizeof(ent.authname));
	218
	219	/* Type */
	220	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
	221	goto out;
	222	ent.type = strcmp(buf1, "user") == 0 ?
	223	IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
	224
	225	/* ID */
	226	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
	227	goto out;
	228	ent.id = simple_strtoul(buf1, &bp, 10);
	229	if (bp == buf1)
	230	goto out;
	231
	232	/* expiry */
	233	ent.h.expiry_time = get_expiry(&buf);
	234	if (ent.h.expiry_time == 0)
	235	goto out;
	236
f9ecc921 N	237	error = -ENOMEM;
	238	res = idtoname_lookup(&ent);
	239	if (!res)
	240	goto out;
	241
1da177e4	242	/* Name */
c9b6cbe5 BF	243	error = -EINVAL;
	244	len = qword_get(&buf, buf1, PAGE_SIZE);
	245	if (len < 0)
1da177e4	246	goto out;
c9b6cbe5	247	if (len == 0)
1da177e4	248	set_bit(CACHE_NEGATIVE, &ent.h.flags);
d4395e03 BF	249	else if (len >= IDMAP_NAMESZ)
	250	goto out;
	251	else
1da177e4	252	memcpy(ent.name, buf1, sizeof(ent.name));
1da177e4	253	error = -ENOMEM;
f9ecc921 N	254	res = idtoname_update(&ent, res);
f9ecc921 N	255	if (res == NULL)
1da177e4 LT	256	goto out;
1da177e4 LT	257
baab935f	258	cache_put(&res->h, &idtoname_cache);
1da177e4 LT	259
	260	error = 0;
	261	out:
	262	kfree(buf1);
	263
	264	return error;
	265	}
	266
f9ecc921 N	267
	268	static struct ent *
	269	idtoname_lookup(struct ent *item)
	270	{
	271	struct cache_head *ch = sunrpc_cache_lookup(&idtoname_cache,
	272	&item->h,
	273	idtoname_hash(item));
	274	if (ch)
	275	return container_of(ch, struct ent, h);
	276	else
	277	return NULL;
	278	}
	279
	280	static struct ent *
	281	idtoname_update(struct ent new, struct ent old)
	282	{
	283	struct cache_head *ch = sunrpc_cache_update(&idtoname_cache,
	284	&new->h, &old->h,
	285	idtoname_hash(new));
	286	if (ch)
	287	return container_of(ch, struct ent, h);
	288	else
	289	return NULL;
	290	}
	291
1da177e4 LT	292
	293	/*
	294	* Name -> ID cache
	295	*/
	296
	297	static struct cache_head *nametoid_table[ENT_HASHMAX];
	298
	299	static inline int
	300	nametoid_hash(struct ent *ent)
	301	{
	302	return hash_str(ent->name, ENT_HASHBITS);
	303	}
	304
fd39ca9a	305	static void
1da177e4 LT	306	nametoid_request(struct cache_detail cd, struct cache_head ch, char **bpp,
	307	int *blen)
	308	{
	309	struct ent *ent = container_of(ch, struct ent, h);
	310
	311	qword_add(bpp, blen, ent->authname);
	312	qword_add(bpp, blen, ent->type == IDMAP_TYPE_GROUP ? "group" : "user");
	313	qword_add(bpp, blen, ent->name);
	314
	315	(*bpp)[-1] = '\n';
	316	}
	317
bc74b4f5 TM	318	static int
	319	nametoid_upcall(struct cache_detail cd, struct cache_head ch)
	320	{
	321	return sunrpc_cache_pipe_upcall(cd, ch, nametoid_request);
	322	}
	323
f9ecc921 N	324	static int
f9ecc921 N	325	nametoid_match(struct cache_head ca, struct cache_head cb)
1da177e4	326	{
f9ecc921 N	327	struct ent *a = container_of(ca, struct ent, h);
	328	struct ent *b = container_of(cb, struct ent, h);
	329
1da177e4 LT	330	return (a->type == b->type && strcmp(a->name, b->name) == 0 &&
	331	strcmp(a->authname, b->authname) == 0);
	332	}
	333
	334	static int
	335	nametoid_show(struct seq_file m, struct cache_detail cd, struct cache_head *h)
	336	{
	337	struct ent *ent;
	338
	339	if (h == NULL) {
	340	seq_puts(m, "#domain type name [id]\n");
	341	return 0;
	342	}
	343	ent = container_of(h, struct ent, h);
	344	seq_printf(m, "%s %s %s", ent->authname,
	345	ent->type == IDMAP_TYPE_GROUP ? "group" : "user",
	346	ent->name);
	347	if (test_bit(CACHE_VALID, &h->flags))
0a725fc4	348	seq_printf(m, " %u", ent->id);
1da177e4 LT	349	seq_printf(m, "\n");
	350	return 0;
	351	}
	352
f9ecc921 N	353	static struct ent nametoid_lookup(struct ent );
f9ecc921 N	354	static struct ent nametoid_update(struct ent , struct ent *);
fd39ca9a	355	static int nametoid_parse(struct cache_detail , char , int);
1da177e4	356
fd39ca9a	357	static struct cache_detail nametoid_cache = {
f35279d3	358	.owner = THIS_MODULE,
1da177e4 LT	359	.hash_size = ENT_HASHMAX,
	360	.hash_table = nametoid_table,
	361	.name = "nfs4.nametoid",
	362	.cache_put = ent_put,
bc74b4f5	363	.cache_upcall = nametoid_upcall,
1da177e4 LT	364	.cache_parse = nametoid_parse,
	365	.cache_show = nametoid_show,
	366	.warn_no_listener = warn_no_idmapd,
f9ecc921 N	367	.match = nametoid_match,
	368	.init = ent_init,
	369	.update = ent_init,
	370	.alloc = ent_alloc,
1da177e4 LT	371	};
1da177e4 LT	372
fd39ca9a	373	static int
1da177e4 LT	374	nametoid_parse(struct cache_detail cd, char buf, int buflen)
	375	{
	376	struct ent ent, *res;
	377	char *buf1;
	378	int error = -EINVAL;
	379
	380	if (buf[buflen - 1] != '\n')
	381	return (-EINVAL);
	382	buf[buflen - 1]= '\0';
	383
	384	buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
	385	if (buf1 == NULL)
	386	return (-ENOMEM);
	387
	388	memset(&ent, 0, sizeof(ent));
	389
	390	/* Authentication name */
	391	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
	392	goto out;
	393	memcpy(ent.authname, buf1, sizeof(ent.authname));
	394
	395	/* Type */
	396	if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
	397	goto out;
	398	ent.type = strcmp(buf1, "user") == 0 ?
	399	IDMAP_TYPE_USER : IDMAP_TYPE_GROUP;
	400
	401	/* Name */
	402	error = qword_get(&buf, buf1, PAGE_SIZE);
	403	if (error <= 0 \|\| error >= IDMAP_NAMESZ)
	404	goto out;
	405	memcpy(ent.name, buf1, sizeof(ent.name));
	406
	407	/* expiry */
	408	ent.h.expiry_time = get_expiry(&buf);
	409	if (ent.h.expiry_time == 0)
	410	goto out;
	411
	412	/* ID */
	413	error = get_int(&buf, &ent.id);
	414	if (error == -EINVAL)
	415	goto out;
	416	if (error == -ENOENT)
	417	set_bit(CACHE_NEGATIVE, &ent.h.flags);
	418
	419	error = -ENOMEM;
f9ecc921 N	420	res = nametoid_lookup(&ent);
	421	if (res == NULL)
	422	goto out;
	423	res = nametoid_update(&ent, res);
	424	if (res == NULL)
1da177e4 LT	425	goto out;
1da177e4 LT	426
baab935f	427	cache_put(&res->h, &nametoid_cache);
1da177e4 LT	428	error = 0;
	429	out:
	430	kfree(buf1);
	431
	432	return (error);
	433	}
	434
f9ecc921 N	435
	436	static struct ent *
	437	nametoid_lookup(struct ent *item)
	438	{
	439	struct cache_head *ch = sunrpc_cache_lookup(&nametoid_cache,
	440	&item->h,
	441	nametoid_hash(item));
	442	if (ch)
	443	return container_of(ch, struct ent, h);
	444	else
	445	return NULL;
	446	}
	447
	448	static struct ent *
	449	nametoid_update(struct ent new, struct ent old)
	450	{
	451	struct cache_head *ch = sunrpc_cache_update(&nametoid_cache,
	452	&new->h, &old->h,
	453	nametoid_hash(new));
	454	if (ch)
	455	return container_of(ch, struct ent, h);
	456	else
	457	return NULL;
	458	}
1da177e4 LT	459
	460	/*
	461	* Exported API
	462	*/
	463
dbf847ec	464	int
1da177e4 LT	465	nfsd_idmap_init(void)
1da177e4 LT	466	{
dbf847ec BF	467	int rv;
	468
	469	rv = cache_register(&idtoname_cache);
	470	if (rv)
	471	return rv;
	472	rv = cache_register(&nametoid_cache);
	473	if (rv)
	474	cache_unregister(&idtoname_cache);
	475	return rv;
1da177e4 LT	476	}
	477
	478	void
	479	nfsd_idmap_shutdown(void)
	480	{
df95a9d4 BF	481	cache_unregister(&idtoname_cache);
df95a9d4 BF	482	cache_unregister(&nametoid_cache);
1da177e4 LT	483	}
1da177e4 LT	484
1da177e4 LT	485	static int
1da177e4 LT	486	idmap_lookup(struct svc_rqst *rqstp,
f9ecc921	487	struct ent (lookup_fn)(struct ent ), struct ent key,
1da177e4 LT	488	struct cache_detail detail, struct ent *item)
1da177e4 LT	489	{
1da177e4 LT	490	int ret;
1da177e4 LT	491
839049a8 N	492	*item = lookup_fn(key);
839049a8 N	493	if (!*item)
1da177e4	494	return -ENOMEM;
839049a8 N	495	retry:
	496	ret = cache_check(detail, &(*item)->h, &rqstp->rq_chandle);
	497
	498	if (ret == -ETIMEDOUT) {
	499	struct ent prev_item = item;
	500	*item = lookup_fn(key);
	501	if (*item != prev_item)
	502	goto retry;
	503	cache_put(&(*item)->h, detail);
1da177e4	504	}
1da177e4 LT	505	return ret;
	506	}
	507
3ab4d8b1 BF	508	static char *
	509	rqst_authname(struct svc_rqst *rqstp)
	510	{
	511	struct auth_domain *clp;
	512
	513	clp = rqstp->rq_gssclient ? rqstp->rq_gssclient : rqstp->rq_client;
	514	return clp->name;
	515	}
	516
1da177e4 LT	517	static int
	518	idmap_name_to_id(struct svc_rqst rqstp, int type, const char name, u32 namelen,
	519	uid_t *id)
	520	{
	521	struct ent *item, key = {
	522	.type = type,
	523	};
	524	int ret;
	525
	526	if (namelen + 1 > sizeof(key.name))
	527	return -EINVAL;
	528	memcpy(key.name, name, namelen);
	529	key.name[namelen] = '\0';
3ab4d8b1	530	strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
1da177e4 LT	531	ret = idmap_lookup(rqstp, nametoid_lookup, &key, &nametoid_cache, &item);
	532	if (ret == -ENOENT)
	533	ret = -ESRCH; /* nfserr_badname */
	534	if (ret)
	535	return ret;
	536	*id = item->id;
baab935f	537	cache_put(&item->h, &nametoid_cache);
1da177e4 LT	538	return 0;
	539	}
	540
	541	static int
	542	idmap_id_to_name(struct svc_rqst rqstp, int type, uid_t id, char name)
	543	{
	544	struct ent *item, key = {
	545	.id = id,
	546	.type = type,
	547	};
	548	int ret;
	549
3ab4d8b1	550	strlcpy(key.authname, rqst_authname(rqstp), sizeof(key.authname));
1da177e4 LT	551	ret = idmap_lookup(rqstp, idtoname_lookup, &key, &idtoname_cache, &item);
	552	if (ret == -ENOENT)
	553	return sprintf(name, "%u", id);
	554	if (ret)
	555	return ret;
	556	ret = strlen(item->name);
	557	BUG_ON(ret > IDMAP_NAMESZ);
	558	memcpy(name, item->name, ret);
baab935f	559	cache_put(&item->h, &idtoname_cache);
1da177e4 LT	560	return ret;
	561	}
	562
	563	int
	564	nfsd_map_name_to_uid(struct svc_rqst rqstp, const char name, size_t namelen,
	565	__u32 *id)
	566	{
	567	return idmap_name_to_id(rqstp, IDMAP_TYPE_USER, name, namelen, id);
	568	}
	569
	570	int
	571	nfsd_map_name_to_gid(struct svc_rqst rqstp, const char name, size_t namelen,
	572	__u32 *id)
	573	{
	574	return idmap_name_to_id(rqstp, IDMAP_TYPE_GROUP, name, namelen, id);
	575	}
	576
	577	int
	578	nfsd_map_uid_to_name(struct svc_rqst rqstp, __u32 id, char name)
	579	{
	580	return idmap_id_to_name(rqstp, IDMAP_TYPE_USER, id, name);
	581	}
	582
	583	int
	584	nfsd_map_gid_to_name(struct svc_rqst rqstp, __u32 id, char name)
	585	{
	586	return idmap_id_to_name(rqstp, IDMAP_TYPE_GROUP, id, name);
	587	}