[deliverable/linux.git] / net / sunrpc / auth_generic.c

/*
 * Generic RPC credential
 *
 * Copyright (C) 2008, Trond Myklebust <Trond.Myklebust@netapp.com>
 */

#include <linux/err.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/sunrpc/auth.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/debug.h>
#include <linux/sunrpc/sched.h>

#ifdef RPC_DEBUG
# define RPCDBG_FACILITY	RPCDBG_AUTH
#endif

#define RPC_MACHINE_CRED_USERID		((uid_t)0)
#define RPC_MACHINE_CRED_GROUPID	((gid_t)0)

struct generic_cred {
	struct rpc_cred gc_base;
	struct auth_cred acred;
};

static struct rpc_auth generic_auth;
static struct rpc_cred_cache generic_cred_cache;
static const struct rpc_credops generic_credops;

/*
 * Public call interface
 */
struct rpc_cred *rpc_lookup_cred(void)
{
	return rpcauth_lookupcred(&generic_auth, 0);
}
EXPORT_SYMBOL_GPL(rpc_lookup_cred);

/*
 * Public call interface for looking up machine creds.
 */
struct rpc_cred *rpc_lookup_machine_cred(void)
{
	struct auth_cred acred = {
		.uid = RPC_MACHINE_CRED_USERID,
		.gid = RPC_MACHINE_CRED_GROUPID,
		.machine_cred = 1,
	};

	dprintk("RPC:       looking up machine cred\n");
	return generic_auth.au_ops->lookup_cred(&generic_auth, &acred, 0);
}
EXPORT_SYMBOL_GPL(rpc_lookup_machine_cred);

static void
generic_bind_cred(struct rpc_task *task, struct rpc_cred *cred)
{
	struct rpc_auth *auth = task->tk_client->cl_auth;
	struct auth_cred *acred = &container_of(cred, struct generic_cred, gc_base)->acred;
	struct rpc_cred *ret;

	ret = auth->au_ops->lookup_cred(auth, acred, 0);
	if (!IS_ERR(ret))
		task->tk_msg.rpc_cred = ret;
	else
		task->tk_status = PTR_ERR(ret);
}

/*
 * Lookup generic creds for current process
 */
static struct rpc_cred *
generic_lookup_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
{
	return rpcauth_lookup_credcache(&generic_auth, acred, flags);
}

static struct rpc_cred *
generic_create_cred(struct rpc_auth *auth, struct auth_cred *acred, int flags)
{
	struct generic_cred *gcred;

	gcred = kmalloc(sizeof(*gcred), GFP_KERNEL);
	if (gcred == NULL)
		return ERR_PTR(-ENOMEM);

	rpcauth_init_cred(&gcred->gc_base, acred, &generic_auth, &generic_credops);
	gcred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_UPTODATE;

	gcred->acred.uid = acred->uid;
	gcred->acred.gid = acred->gid;
	gcred->acred.group_info = acred->group_info;
	if (gcred->acred.group_info != NULL)
		get_group_info(gcred->acred.group_info);
	gcred->acred.machine_cred = acred->machine_cred;

	dprintk("RPC:       allocated %s cred %p for uid %d gid %d\n",
			gcred->acred.machine_cred ? "machine" : "generic",
			gcred, acred->uid, acred->gid);
	return &gcred->gc_base;
}

static void
generic_free_cred(struct rpc_cred *cred)
{
	struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);

	dprintk("RPC:       generic_free_cred %p\n", gcred);
	if (gcred->acred.group_info != NULL)
		put_group_info(gcred->acred.group_info);
	kfree(gcred);
}

static void
generic_free_cred_callback(struct rcu_head *head)
{
	struct rpc_cred *cred = container_of(head, struct rpc_cred, cr_rcu);
	generic_free_cred(cred);
}

static void
generic_destroy_cred(struct rpc_cred *cred)
{
	call_rcu(&cred->cr_rcu, generic_free_cred_callback);
}

/*
 * Match credentials against current process creds.
 */
static int
generic_match(struct auth_cred *acred, struct rpc_cred *cred, int flags)
{
	struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);

	if (gcred->acred.uid != acred->uid ||
	    gcred->acred.gid != acred->gid ||
	    gcred->acred.group_info != acred->group_info ||
	    gcred->acred.machine_cred != acred->machine_cred)
		return 0;
	return 1;
}

void __init rpc_init_generic_auth(void)
{
	spin_lock_init(&generic_cred_cache.lock);
}

void __exit rpc_destroy_generic_auth(void)
{
	rpcauth_clear_credcache(&generic_cred_cache);
}

static struct rpc_cred_cache generic_cred_cache = {
	{{ NULL, },},
};

static const struct rpc_authops generic_auth_ops = {
	.owner = THIS_MODULE,
	.au_name = "Generic",
	.lookup_cred = generic_lookup_cred,
	.crcreate = generic_create_cred,
};

static struct rpc_auth generic_auth = {
	.au_ops = &generic_auth_ops,
	.au_count = ATOMIC_INIT(0),
	.au_credcache = &generic_cred_cache,
};

static const struct rpc_credops generic_credops = {
	.cr_name = "Generic cred",
	.crdestroy = generic_destroy_cred,
	.crbind = generic_bind_cred,
	.crmatch = generic_match,
};
Commit	Line	Data
9a559efd TM	1	/*
	2	* Generic RPC credential
	3	*
	4	* Copyright (C) 2008, Trond Myklebust <Trond.Myklebust@netapp.com>
	5	*/
	6
	7	#include <linux/err.h>
	8	#include <linux/types.h>
	9	#include <linux/module.h>
	10	#include <linux/sched.h>
	11	#include <linux/sunrpc/auth.h>
	12	#include <linux/sunrpc/clnt.h>
	13	#include <linux/sunrpc/debug.h>
	14	#include <linux/sunrpc/sched.h>
	15
	16	#ifdef RPC_DEBUG
	17	# define RPCDBG_FACILITY RPCDBG_AUTH
	18	#endif
	19
b4528762 TM	20	#define RPC_MACHINE_CRED_USERID ((uid_t)0)
b4528762 TM	21	#define RPC_MACHINE_CRED_GROUPID ((gid_t)0)
7c67db3a	22
9a559efd TM	23	struct generic_cred {
	24	struct rpc_cred gc_base;
	25	struct auth_cred acred;
	26	};
	27
	28	static struct rpc_auth generic_auth;
	29	static struct rpc_cred_cache generic_cred_cache;
	30	static const struct rpc_credops generic_credops;
	31
	32	/*
	33	* Public call interface
	34	*/
	35	struct rpc_cred *rpc_lookup_cred(void)
	36	{
	37	return rpcauth_lookupcred(&generic_auth, 0);
	38	}
	39	EXPORT_SYMBOL_GPL(rpc_lookup_cred);
	40
7c67db3a TM	41	/*
	42	* Public call interface for looking up machine creds.
	43	*/
	44	struct rpc_cred *rpc_lookup_machine_cred(void)
	45	{
	46	struct auth_cred acred = {
b4528762 TM	47	.uid = RPC_MACHINE_CRED_USERID,
b4528762 TM	48	.gid = RPC_MACHINE_CRED_GROUPID,
7c67db3a TM	49	.machine_cred = 1,
	50	};
	51
	52	dprintk("RPC: looking up machine cred\n");
	53	return generic_auth.au_ops->lookup_cred(&generic_auth, &acred, 0);
	54	}
	55	EXPORT_SYMBOL_GPL(rpc_lookup_machine_cred);
	56
5c691044 TM	57	static void
	58	generic_bind_cred(struct rpc_task task, struct rpc_cred cred)
	59	{
	60	struct rpc_auth *auth = task->tk_client->cl_auth;
	61	struct auth_cred *acred = &container_of(cred, struct generic_cred, gc_base)->acred;
	62	struct rpc_cred *ret;
	63
	64	ret = auth->au_ops->lookup_cred(auth, acred, 0);
	65	if (!IS_ERR(ret))
	66	task->tk_msg.rpc_cred = ret;
	67	else
	68	task->tk_status = PTR_ERR(ret);
	69	}
	70
9a559efd TM	71	/*
	72	* Lookup generic creds for current process
	73	*/
	74	static struct rpc_cred *
	75	generic_lookup_cred(struct rpc_auth auth, struct auth_cred acred, int flags)
	76	{
	77	return rpcauth_lookup_credcache(&generic_auth, acred, flags);
	78	}
	79
	80	static struct rpc_cred *
	81	generic_create_cred(struct rpc_auth auth, struct auth_cred acred, int flags)
	82	{
	83	struct generic_cred *gcred;
	84
	85	gcred = kmalloc(sizeof(*gcred), GFP_KERNEL);
	86	if (gcred == NULL)
	87	return ERR_PTR(-ENOMEM);
	88
	89	rpcauth_init_cred(&gcred->gc_base, acred, &generic_auth, &generic_credops);
	90	gcred->gc_base.cr_flags = 1UL << RPCAUTH_CRED_UPTODATE;
	91
	92	gcred->acred.uid = acred->uid;
	93	gcred->acred.gid = acred->gid;
	94	gcred->acred.group_info = acred->group_info;
	95	if (gcred->acred.group_info != NULL)
	96	get_group_info(gcred->acred.group_info);
7c67db3a	97	gcred->acred.machine_cred = acred->machine_cred;
9a559efd	98
7c67db3a TM	99	dprintk("RPC: allocated %s cred %p for uid %d gid %d\n",
7c67db3a TM	100	gcred->acred.machine_cred ? "machine" : "generic",
9a559efd TM	101	gcred, acred->uid, acred->gid);
	102	return &gcred->gc_base;
	103	}
	104
	105	static void
	106	generic_free_cred(struct rpc_cred *cred)
	107	{
	108	struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);
	109
	110	dprintk("RPC: generic_free_cred %p\n", gcred);
	111	if (gcred->acred.group_info != NULL)
	112	put_group_info(gcred->acred.group_info);
	113	kfree(gcred);
	114	}
	115
	116	static void
	117	generic_free_cred_callback(struct rcu_head *head)
	118	{
	119	struct rpc_cred *cred = container_of(head, struct rpc_cred, cr_rcu);
	120	generic_free_cred(cred);
	121	}
	122
	123	static void
	124	generic_destroy_cred(struct rpc_cred *cred)
	125	{
	126	call_rcu(&cred->cr_rcu, generic_free_cred_callback);
	127	}
	128
	129	/*
	130	* Match credentials against current process creds.
	131	*/
	132	static int
	133	generic_match(struct auth_cred acred, struct rpc_cred cred, int flags)
	134	{
	135	struct generic_cred *gcred = container_of(cred, struct generic_cred, gc_base);
	136
	137	if (gcred->acred.uid != acred->uid \|\|
	138	gcred->acred.gid != acred->gid \|\|
7c67db3a TM	139	gcred->acred.group_info != acred->group_info \|\|
7c67db3a TM	140	gcred->acred.machine_cred != acred->machine_cred)
9a559efd TM	141	return 0;
	142	return 1;
	143	}
	144
	145	void __init rpc_init_generic_auth(void)
	146	{
	147	spin_lock_init(&generic_cred_cache.lock);
	148	}
	149
	150	void __exit rpc_destroy_generic_auth(void)
	151	{
	152	rpcauth_clear_credcache(&generic_cred_cache);
	153	}
	154
	155	static struct rpc_cred_cache generic_cred_cache = {
	156	{{ NULL, },},
	157	};
	158
	159	static const struct rpc_authops generic_auth_ops = {
	160	.owner = THIS_MODULE,
9a559efd	161	.au_name = "Generic",
9a559efd TM	162	.lookup_cred = generic_lookup_cred,
	163	.crcreate = generic_create_cred,
	164	};
	165
	166	static struct rpc_auth generic_auth = {
	167	.au_ops = &generic_auth_ops,
	168	.au_count = ATOMIC_INIT(0),
	169	.au_credcache = &generic_cred_cache,
	170	};
	171
	172	static const struct rpc_credops generic_credops = {
	173	.cr_name = "Generic cred",
	174	.crdestroy = generic_destroy_cred,
5c691044	175	.crbind = generic_bind_cred,
9a559efd TM	176	.crmatch = generic_match,
9a559efd TM	177	};