[mirror_ubuntu-bionic-kernel.git] / net / netlink / genetlink.c

/*
 * NETLINK      Generic Netlink Family
 *
 * 		Authors:	Jamal Hadi Salim
 * 				Thomas Graf <tgraf@suug.ch>
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/string.h>
#include <linux/skbuff.h>
#include <linux/mutex.h>
#include <net/sock.h>
#include <net/genetlink.h>

struct sock *genl_sock = NULL;

static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */

static void genl_lock(void)
{
	mutex_lock(&genl_mutex);
}

static int genl_trylock(void)
{
	return !mutex_trylock(&genl_mutex);
}

static void genl_unlock(void)
{
	mutex_unlock(&genl_mutex);

	if (genl_sock && genl_sock->sk_receive_queue.qlen)
		genl_sock->sk_data_ready(genl_sock, 0);
}

#define GENL_FAM_TAB_SIZE	16
#define GENL_FAM_TAB_MASK	(GENL_FAM_TAB_SIZE - 1)

static struct list_head family_ht[GENL_FAM_TAB_SIZE];

static int genl_ctrl_event(int event, void *data);

static inline unsigned int genl_family_hash(unsigned int id)
{
	return id & GENL_FAM_TAB_MASK;
}

static inline struct list_head *genl_family_chain(unsigned int id)
{
	return &family_ht[genl_family_hash(id)];
}

static struct genl_family *genl_family_find_byid(unsigned int id)
{
	struct genl_family *f;

	list_for_each_entry(f, genl_family_chain(id), family_list)
		if (f->id == id)
			return f;

	return NULL;
}

static struct genl_family *genl_family_find_byname(char *name)
{
	struct genl_family *f;
	int i;

	for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
		list_for_each_entry(f, genl_family_chain(i), family_list)
			if (strcmp(f->name, name) == 0)
				return f;

	return NULL;
}

static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
{
	struct genl_ops *ops;

	list_for_each_entry(ops, &family->ops_list, ops_list)
		if (ops->cmd == cmd)
			return ops;

	return NULL;
}

/* Of course we are going to have problems once we hit
 * 2^16 alive types, but that can only happen by year 2K
*/
static inline u16 genl_generate_id(void)
{
	static u16 id_gen_idx;
	int overflowed = 0;

	do {
		if (id_gen_idx == 0)
			id_gen_idx = GENL_MIN_ID;

		if (++id_gen_idx > GENL_MAX_ID) {
			if (!overflowed) {
				overflowed = 1;
				id_gen_idx = 0;
				continue;
			} else
				return 0;
		}

	} while (genl_family_find_byid(id_gen_idx));

	return id_gen_idx;
}

/**
 * genl_register_ops - register generic netlink operations
 * @family: generic netlink family
 * @ops: operations to be registered
 *
 * Registers the specified operations and assigns them to the specified
 * family. Either a doit or dumpit callback must be specified or the
 * operation will fail. Only one operation structure per command
 * identifier may be registered.
 *
 * See include/net/genetlink.h for more documenation on the operations
 * structure.
 *
 * Returns 0 on success or a negative error code.
 */
int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
{
	int err = -EINVAL;

	if (ops->dumpit == NULL && ops->doit == NULL)
		goto errout;

	if (genl_get_cmd(ops->cmd, family)) {
		err = -EEXIST;
		goto errout;
	}

	if (ops->dumpit)
		ops->flags |= GENL_CMD_CAP_DUMP;
	if (ops->doit)
		ops->flags |= GENL_CMD_CAP_DO;
	if (ops->policy)
		ops->flags |= GENL_CMD_CAP_HASPOL;

	genl_lock();
	list_add_tail(&ops->ops_list, &family->ops_list);
	genl_unlock();

	genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
	err = 0;
errout:
	return err;
}

/**
 * genl_unregister_ops - unregister generic netlink operations
 * @family: generic netlink family
 * @ops: operations to be unregistered
 *
 * Unregisters the specified operations and unassigns them from the
 * specified family. The operation blocks until the current message
 * processing has finished and doesn't start again until the
 * unregister process has finished.
 *
 * Note: It is not necessary to unregister all operations before
 *       unregistering the family, unregistering the family will cause
 *       all assigned operations to be unregistered automatically.
 *
 * Returns 0 on success or a negative error code.
 */
int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
{
	struct genl_ops *rc;

	genl_lock();
	list_for_each_entry(rc, &family->ops_list, ops_list) {
		if (rc == ops) {
			list_del(&ops->ops_list);
			genl_unlock();
			genl_ctrl_event(CTRL_CMD_DELOPS, ops);
			return 0;
		}
	}
	genl_unlock();

	return -ENOENT;
}

/**
 * genl_register_family - register a generic netlink family
 * @family: generic netlink family
 *
 * Registers the specified family after validating it first. Only one
 * family may be registered with the same family name or identifier.
 * The family id may equal GENL_ID_GENERATE causing an unique id to
 * be automatically generated and assigned.
 *
 * Return 0 on success or a negative error code.
 */
int genl_register_family(struct genl_family *family)
{
	int err = -EINVAL;

	if (family->id && family->id < GENL_MIN_ID)
		goto errout;

	if (family->id > GENL_MAX_ID)
		goto errout;

	INIT_LIST_HEAD(&family->ops_list);

	genl_lock();

	if (genl_family_find_byname(family->name)) {
		err = -EEXIST;
		goto errout_locked;
	}

	if (genl_family_find_byid(family->id)) {
		err = -EEXIST;
		goto errout_locked;
	}

	if (family->id == GENL_ID_GENERATE) {
		u16 newid = genl_generate_id();

		if (!newid) {
			err = -ENOMEM;
			goto errout_locked;
		}

		family->id = newid;
	}

	if (family->maxattr) {
		family->attrbuf = kmalloc((family->maxattr+1) *
					sizeof(struct nlattr *), GFP_KERNEL);
		if (family->attrbuf == NULL) {
			err = -ENOMEM;
			goto errout_locked;
		}
	} else
		family->attrbuf = NULL;

	list_add_tail(&family->family_list, genl_family_chain(family->id));
	genl_unlock();

	genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);

	return 0;

errout_locked:
	genl_unlock();
errout:
	return err;
}

/**
 * genl_unregister_family - unregister generic netlink family
 * @family: generic netlink family
 *
 * Unregisters the specified family.
 *
 * Returns 0 on success or a negative error code.
 */
int genl_unregister_family(struct genl_family *family)
{
	struct genl_family *rc;

	genl_lock();

	list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
		if (family->id != rc->id || strcmp(rc->name, family->name))
			continue;

		list_del(&rc->family_list);
		INIT_LIST_HEAD(&family->ops_list);
		genl_unlock();

		kfree(family->attrbuf);
		genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
		return 0;
	}

	genl_unlock();

	return -ENOENT;
}

static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
{
	struct genl_ops *ops;
	struct genl_family *family;
	struct genl_info info;
	struct genlmsghdr *hdr = nlmsg_data(nlh);
	int hdrlen, err;

	family = genl_family_find_byid(nlh->nlmsg_type);
	if (family == NULL)
		return -ENOENT;

	hdrlen = GENL_HDRLEN + family->hdrsize;
	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
		return -EINVAL;

	ops = genl_get_cmd(hdr->cmd, family);
	if (ops == NULL)
		return -EOPNOTSUPP;

	if ((ops->flags & GENL_ADMIN_PERM) &&
	    security_netlink_recv(skb, CAP_NET_ADMIN))
		return -EPERM;

	if (nlh->nlmsg_flags & NLM_F_DUMP) {
		if (ops->dumpit == NULL)
			return -EOPNOTSUPP;

		return netlink_dump_start(genl_sock, skb, nlh,
					  ops->dumpit, ops->done);
	}

	if (ops->doit == NULL)
		return -EOPNOTSUPP;

	if (family->attrbuf) {
		err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
				  ops->policy);
		if (err < 0)
			return err;
	}

	info.snd_seq = nlh->nlmsg_seq;
	info.snd_pid = NETLINK_CB(skb).pid;
	info.nlhdr = nlh;
	info.genlhdr = nlmsg_data(nlh);
	info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
	info.attrs = family->attrbuf;

	return ops->doit(skb, &info);
}

static void genl_rcv(struct sock *sk, int len)
{
	unsigned int qlen = 0;

	do {
		if (genl_trylock())
			return;
		netlink_run_queue(sk, &qlen, genl_rcv_msg);
		genl_unlock();
	} while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
}

/**************************************************************************
 * Controller
 **************************************************************************/

static struct genl_family genl_ctrl = {
	.id = GENL_ID_CTRL,
	.name = "nlctrl",
	.version = 0x2,
	.maxattr = CTRL_ATTR_MAX,
};

static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
			  u32 flags, struct sk_buff *skb, u8 cmd)
{
	void *hdr;

	hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
	if (hdr == NULL)
		return -1;

	NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
	NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
	NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
	NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
	NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);

	if (!list_empty(&family->ops_list)) {
		struct nlattr *nla_ops;
		struct genl_ops *ops;
		int idx = 1;

		nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
		if (nla_ops == NULL)
			goto nla_put_failure;

		list_for_each_entry(ops, &family->ops_list, ops_list) {
			struct nlattr *nest;

			nest = nla_nest_start(skb, idx++);
			if (nest == NULL)
				goto nla_put_failure;

			NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
			NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);

			nla_nest_end(skb, nest);
		}

		nla_nest_end(skb, nla_ops);
	}

	return genlmsg_end(skb, hdr);

nla_put_failure:
	return genlmsg_cancel(skb, hdr);
}

static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
{

	int i, n = 0;
	struct genl_family *rt;
	int chains_to_skip = cb->args[0];
	int fams_to_skip = cb->args[1];

	if (chains_to_skip != 0)
		genl_lock();

	for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
		if (i < chains_to_skip)
			continue;
		n = 0;
		list_for_each_entry(rt, genl_family_chain(i), family_list) {
			if (++n < fams_to_skip)
				continue;
			if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
					   cb->nlh->nlmsg_seq, NLM_F_MULTI,
					   skb, CTRL_CMD_NEWFAMILY) < 0)
				goto errout;
		}

		fams_to_skip = 0;
	}

errout:
	if (chains_to_skip != 0)
		genl_unlock();

	cb->args[0] = i;
	cb->args[1] = n;

	return skb->len;
}

static struct sk_buff *ctrl_build_msg(struct genl_family *family, u32 pid,
				      int seq, u8 cmd)
{
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (skb == NULL)
		return ERR_PTR(-ENOBUFS);

	err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
	if (err < 0) {
		nlmsg_free(skb);
		return ERR_PTR(err);
	}

	return skb;
}

static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = {
	[CTRL_ATTR_FAMILY_ID]	= { .type = NLA_U16 },
	[CTRL_ATTR_FAMILY_NAME]	= { .type = NLA_NUL_STRING,
				    .len = GENL_NAMSIZ - 1 },
};

static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
{
	struct sk_buff *msg;
	struct genl_family *res = NULL;
	int err = -EINVAL;

	if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
		u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
		res = genl_family_find_byid(id);
	}

	if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
		char *name;

		name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
		res = genl_family_find_byname(name);
	}

	if (res == NULL) {
		err = -ENOENT;
		goto errout;
	}

	msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
			     CTRL_CMD_NEWFAMILY);
	if (IS_ERR(msg)) {
		err = PTR_ERR(msg);
		goto errout;
	}

	err = genlmsg_reply(msg, info);
errout:
	return err;
}

static int genl_ctrl_event(int event, void *data)
{
	struct sk_buff *msg;

	if (genl_sock == NULL)
		return 0;

	switch (event) {
	case CTRL_CMD_NEWFAMILY:
	case CTRL_CMD_DELFAMILY:
		msg = ctrl_build_msg(data, 0, 0, event);
		if (IS_ERR(msg))
			return PTR_ERR(msg);

		genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
		break;
	}

	return 0;
}

static struct genl_ops genl_ctrl_ops = {
	.cmd		= CTRL_CMD_GETFAMILY,
	.doit		= ctrl_getfamily,
	.dumpit		= ctrl_dumpfamily,
	.policy		= ctrl_policy,
};

static int __init genl_init(void)
{
	int i, err;

	for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
		INIT_LIST_HEAD(&family_ht[i]);

	err = genl_register_family(&genl_ctrl);
	if (err < 0)
		goto errout;

	err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
	if (err < 0)
		goto errout_register;

	netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
	genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
					  genl_rcv, NULL, THIS_MODULE);
	if (genl_sock == NULL)
		panic("GENL: Cannot initialize generic netlink\n");

	return 0;

errout_register:
	genl_unregister_family(&genl_ctrl);
errout:
	panic("GENL: Cannot register controller: %d\n", err);
}

subsys_initcall(genl_init);

EXPORT_SYMBOL(genl_sock);
EXPORT_SYMBOL(genl_register_ops);
EXPORT_SYMBOL(genl_unregister_ops);
EXPORT_SYMBOL(genl_register_family);
EXPORT_SYMBOL(genl_unregister_family);
Commit	Line	Data
482a8524 TG	1	/*
	2	* NETLINK Generic Netlink Family
	3	*
	4	* Authors: Jamal Hadi Salim
	5	* Thomas Graf <tgraf@suug.ch>
	6	*/
	7
482a8524 TG	8	#include <linux/module.h>
	9	#include <linux/kernel.h>
	10	#include <linux/errno.h>
	11	#include <linux/types.h>
	12	#include <linux/socket.h>
	13	#include <linux/string.h>
	14	#include <linux/skbuff.h>
14cc3e2b	15	#include <linux/mutex.h>
482a8524 TG	16	#include <net/sock.h>
	17	#include <net/genetlink.h>
	18
	19	struct sock *genl_sock = NULL;
	20
14cc3e2b	21	static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
482a8524 TG	22
	23	static void genl_lock(void)
	24	{
14cc3e2b	25	mutex_lock(&genl_mutex);
482a8524 TG	26	}
	27
	28	static int genl_trylock(void)
	29	{
14cc3e2b	30	return !mutex_trylock(&genl_mutex);
482a8524 TG	31	}
	32
	33	static void genl_unlock(void)
	34	{
14cc3e2b	35	mutex_unlock(&genl_mutex);
482a8524 TG	36
	37	if (genl_sock && genl_sock->sk_receive_queue.qlen)
	38	genl_sock->sk_data_ready(genl_sock, 0);
	39	}
	40
	41	#define GENL_FAM_TAB_SIZE 16
	42	#define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
	43
	44	static struct list_head family_ht[GENL_FAM_TAB_SIZE];
	45
	46	static int genl_ctrl_event(int event, void *data);
	47
	48	static inline unsigned int genl_family_hash(unsigned int id)
	49	{
	50	return id & GENL_FAM_TAB_MASK;
	51	}
	52
	53	static inline struct list_head *genl_family_chain(unsigned int id)
	54	{
	55	return &family_ht[genl_family_hash(id)];
	56	}
	57
	58	static struct genl_family *genl_family_find_byid(unsigned int id)
	59	{
	60	struct genl_family *f;
	61
	62	list_for_each_entry(f, genl_family_chain(id), family_list)
	63	if (f->id == id)
	64	return f;
	65
	66	return NULL;
	67	}
	68
	69	static struct genl_family genl_family_find_byname(char name)
	70	{
	71	struct genl_family *f;
	72	int i;
	73
	74	for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
	75	list_for_each_entry(f, genl_family_chain(i), family_list)
	76	if (strcmp(f->name, name) == 0)
	77	return f;
	78
	79	return NULL;
	80	}
	81
	82	static struct genl_ops genl_get_cmd(u8 cmd, struct genl_family family)
	83	{
	84	struct genl_ops *ops;
	85
	86	list_for_each_entry(ops, &family->ops_list, ops_list)
	87	if (ops->cmd == cmd)
	88	return ops;
	89
	90	return NULL;
	91	}
	92
	93	/* Of course we are going to have problems once we hit
	94	* 2^16 alive types, but that can only happen by year 2K
	95	*/
	96	static inline u16 genl_generate_id(void)
	97	{
	98	static u16 id_gen_idx;
	99	int overflowed = 0;
100
101	do {
102	if (id_gen_idx == 0)
103	id_gen_idx = GENL_MIN_ID;
104
105	if (++id_gen_idx > GENL_MAX_ID) {
106	if (!overflowed) {
107	overflowed = 1;
108	id_gen_idx = 0;
109	continue;
110	} else
111	return 0;
112	}
113
114	} while (genl_family_find_byid(id_gen_idx));
115
116	return id_gen_idx;
117	}
118
119	/**
120	* genl_register_ops - register generic netlink operations
121	* @family: generic netlink family
122	* @ops: operations to be registered
123	*
124	* Registers the specified operations and assigns them to the specified
125	* family. Either a doit or dumpit callback must be specified or the
126	* operation will fail. Only one operation structure per command
127	* identifier may be registered.
128	*
129	* See include/net/genetlink.h for more documenation on the operations
130	* structure.
131	*
132	* Returns 0 on success or a negative error code.
133	*/
134	int genl_register_ops(struct genl_family family, struct genl_ops ops)
135	{
136	int err = -EINVAL;
137
138	if (ops->dumpit == NULL && ops->doit == NULL)
139	goto errout;
140
141	if (genl_get_cmd(ops->cmd, family)) {
142	err = -EEXIST;
143	goto errout;
144	}
145
334c29a6	146	if (ops->dumpit)
334c29a6	147	ops->flags \|= GENL_CMD_CAP_DUMP;
48d4ed7a JHS	148	if (ops->doit)
48d4ed7a JHS	149	ops->flags \|= GENL_CMD_CAP_DO;
334c29a6 JHS	150	if (ops->policy)
	151	ops->flags \|= GENL_CMD_CAP_HASPOL;
	152
482a8524 TG	153	genl_lock();
	154	list_add_tail(&ops->ops_list, &family->ops_list);
	155	genl_unlock();
	156
	157	genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
	158	err = 0;
	159	errout:
	160	return err;
	161	}
	162
	163	/**
	164	* genl_unregister_ops - unregister generic netlink operations
	165	* @family: generic netlink family
	166	* @ops: operations to be unregistered
	167	*
	168	* Unregisters the specified operations and unassigns them from the
	169	* specified family. The operation blocks until the current message
	170	* processing has finished and doesn't start again until the
	171	* unregister process has finished.
	172	*
	173	* Note: It is not necessary to unregister all operations before
	174	* unregistering the family, unregistering the family will cause
	175	* all assigned operations to be unregistered automatically.
	176	*
	177	* Returns 0 on success or a negative error code.
	178	*/
	179	int genl_unregister_ops(struct genl_family family, struct genl_ops ops)
	180	{
	181	struct genl_ops *rc;
	182
	183	genl_lock();
	184	list_for_each_entry(rc, &family->ops_list, ops_list) {
	185	if (rc == ops) {
	186	list_del(&ops->ops_list);
	187	genl_unlock();
	188	genl_ctrl_event(CTRL_CMD_DELOPS, ops);
	189	return 0;
	190	}
	191	}
	192	genl_unlock();
	193
	194	return -ENOENT;
	195	}
	196
	197	/**
	198	* genl_register_family - register a generic netlink family
	199	* @family: generic netlink family
	200	*
	201	* Registers the specified family after validating it first. Only one
	202	* family may be registered with the same family name or identifier.
	203	* The family id may equal GENL_ID_GENERATE causing an unique id to
	204	* be automatically generated and assigned.
	205	*
	206	* Return 0 on success or a negative error code.
	207	*/
	208	int genl_register_family(struct genl_family *family)
	209	{
	210	int err = -EINVAL;
	211
	212	if (family->id && family->id < GENL_MIN_ID)
	213	goto errout;
	214
	215	if (family->id > GENL_MAX_ID)
	216	goto errout;
217
218	INIT_LIST_HEAD(&family->ops_list);
219
220	genl_lock();
221
222	if (genl_family_find_byname(family->name)) {
223	err = -EEXIST;
224	goto errout_locked;
225	}
226
227	if (genl_family_find_byid(family->id)) {
228	err = -EEXIST;
229	goto errout_locked;
230	}
231
482a8524 TG	232	if (family->id == GENL_ID_GENERATE) {
	233	u16 newid = genl_generate_id();
	234
	235	if (!newid) {
	236	err = -ENOMEM;
	237	goto errout_locked;
	238	}
	239
	240	family->id = newid;
	241	}
	242
	243	if (family->maxattr) {
	244	family->attrbuf = kmalloc((family->maxattr+1) *
	245	sizeof(struct nlattr *), GFP_KERNEL);
	246	if (family->attrbuf == NULL) {
	247	err = -ENOMEM;
e200bd80	248	goto errout_locked;
482a8524 TG	249	}
	250	} else
	251	family->attrbuf = NULL;
	252
	253	list_add_tail(&family->family_list, genl_family_chain(family->id));
	254	genl_unlock();
	255
	256	genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
	257
	258	return 0;
	259
	260	errout_locked:
	261	genl_unlock();
	262	errout:
	263	return err;
	264	}
	265
	266	/**
	267	* genl_unregister_family - unregister generic netlink family
	268	* @family: generic netlink family
	269	*
	270	* Unregisters the specified family.
	271	*
	272	* Returns 0 on success or a negative error code.
	273	*/
	274	int genl_unregister_family(struct genl_family *family)
	275	{
	276	struct genl_family *rc;
	277
	278	genl_lock();
	279
	280	list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
	281	if (family->id != rc->id \|\| strcmp(rc->name, family->name))
	282	continue;
	283
	284	list_del(&rc->family_list);
	285	INIT_LIST_HEAD(&family->ops_list);
	286	genl_unlock();
	287
482a8524 TG	288	kfree(family->attrbuf);
	289	genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
	290	return 0;
	291	}
	292
	293	genl_unlock();
	294
	295	return -ENOENT;
	296	}
	297
1d00a4eb	298	static int genl_rcv_msg(struct sk_buff skb, struct nlmsghdr nlh)
482a8524 TG	299	{
	300	struct genl_ops *ops;
	301	struct genl_family *family;
	302	struct genl_info info;
	303	struct genlmsghdr *hdr = nlmsg_data(nlh);
1d00a4eb	304	int hdrlen, err;
482a8524	305
746fac4d	306	family = genl_family_find_byid(nlh->nlmsg_type);
1d00a4eb TG	307	if (family == NULL)
1d00a4eb TG	308	return -ENOENT;
482a8524 TG	309
	310	hdrlen = GENL_HDRLEN + family->hdrsize;
	311	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
1d00a4eb	312	return -EINVAL;
482a8524 TG	313
482a8524 TG	314	ops = genl_get_cmd(hdr->cmd, family);
1d00a4eb TG	315	if (ops == NULL)
1d00a4eb TG	316	return -EOPNOTSUPP;
482a8524	317
1d00a4eb TG	318	if ((ops->flags & GENL_ADMIN_PERM) &&
	319	security_netlink_recv(skb, CAP_NET_ADMIN))
	320	return -EPERM;
482a8524 TG	321
482a8524 TG	322	if (nlh->nlmsg_flags & NLM_F_DUMP) {
1d00a4eb TG	323	if (ops->dumpit == NULL)
1d00a4eb TG	324	return -EOPNOTSUPP;
482a8524	325
c702e804 TG	326	return netlink_dump_start(genl_sock, skb, nlh,
c702e804 TG	327	ops->dumpit, ops->done);
482a8524 TG	328	}
482a8524 TG	329
1d00a4eb TG	330	if (ops->doit == NULL)
1d00a4eb TG	331	return -EOPNOTSUPP;
482a8524 TG	332
	333	if (family->attrbuf) {
	334	err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
	335	ops->policy);
	336	if (err < 0)
1d00a4eb	337	return err;
482a8524 TG	338	}
	339
	340	info.snd_seq = nlh->nlmsg_seq;
	341	info.snd_pid = NETLINK_CB(skb).pid;
	342	info.nlhdr = nlh;
	343	info.genlhdr = nlmsg_data(nlh);
	344	info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
	345	info.attrs = family->attrbuf;
	346
1d00a4eb	347	return ops->doit(skb, &info);
482a8524 TG	348	}
	349
	350	static void genl_rcv(struct sock *sk, int len)
	351	{
	352	unsigned int qlen = 0;
	353
	354	do {
	355	if (genl_trylock())
	356	return;
e200bd80	357	netlink_run_queue(sk, &qlen, genl_rcv_msg);
482a8524 TG	358	genl_unlock();
	359	} while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
	360	}
	361
	362	/**************************************************************************
	363	* Controller
	364	**************************************************************************/
	365
17c157c8 TG	366	static struct genl_family genl_ctrl = {
	367	.id = GENL_ID_CTRL,
	368	.name = "nlctrl",
334c29a6	369	.version = 0x2,
17c157c8 TG	370	.maxattr = CTRL_ATTR_MAX,
	371	};
	372
482a8524 TG	373	static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
	374	u32 flags, struct sk_buff *skb, u8 cmd)
	375	{
	376	void *hdr;
	377
17c157c8	378	hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
482a8524 TG	379	if (hdr == NULL)
	380	return -1;
	381
	382	NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
	383	NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
eb328111 TG	384	NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
	385	NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
	386	NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);
	387
e94ef682 TG	388	if (!list_empty(&family->ops_list)) {
	389	struct nlattr *nla_ops;
	390	struct genl_ops *ops;
	391	int idx = 1;
eb328111	392
e94ef682 TG	393	nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
e94ef682 TG	394	if (nla_ops == NULL)
eb328111 TG	395	goto nla_put_failure;
eb328111 TG	396
e94ef682 TG	397	list_for_each_entry(ops, &family->ops_list, ops_list) {
e94ef682 TG	398	struct nlattr *nest;
eb328111	399
e94ef682 TG	400	nest = nla_nest_start(skb, idx++);
	401	if (nest == NULL)
	402	goto nla_put_failure;
eb328111	403
e94ef682 TG	404	NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
e94ef682 TG	405	NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);
eb328111	406
e94ef682 TG	407	nla_nest_end(skb, nest);
	408	}
	409
	410	nla_nest_end(skb, nla_ops);
	411	}
482a8524 TG	412
	413	return genlmsg_end(skb, hdr);
	414
	415	nla_put_failure:
	416	return genlmsg_cancel(skb, hdr);
	417	}
	418
	419	static int ctrl_dumpfamily(struct sk_buff skb, struct netlink_callback cb)
	420	{
	421
	422	int i, n = 0;
	423	struct genl_family *rt;
	424	int chains_to_skip = cb->args[0];
	425	int fams_to_skip = cb->args[1];
	426
eb328111 TG	427	if (chains_to_skip != 0)
	428	genl_lock();
	429
482a8524 TG	430	for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
	431	if (i < chains_to_skip)
	432	continue;
	433	n = 0;
	434	list_for_each_entry(rt, genl_family_chain(i), family_list) {
	435	if (++n < fams_to_skip)
	436	continue;
	437	if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
	438	cb->nlh->nlmsg_seq, NLM_F_MULTI,
	439	skb, CTRL_CMD_NEWFAMILY) < 0)
	440	goto errout;
	441	}
	442
	443	fams_to_skip = 0;
	444	}
	445
	446	errout:
eb328111 TG	447	if (chains_to_skip != 0)
	448	genl_unlock();
	449
482a8524 TG	450	cb->args[0] = i;
	451	cb->args[1] = n;
	452
	453	return skb->len;
	454	}
	455
	456	static struct sk_buff ctrl_build_msg(struct genl_family family, u32 pid,
b461d2f2	457	int seq, u8 cmd)
482a8524 TG	458	{
	459	struct sk_buff *skb;
	460	int err;
	461
339bf98f	462	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
482a8524 TG	463	if (skb == NULL)
	464	return ERR_PTR(-ENOBUFS);
	465
	466	err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
	467	if (err < 0) {
	468	nlmsg_free(skb);
	469	return ERR_PTR(err);
	470	}
	471
	472	return skb;
	473	}
	474
	475	static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = {
	476	[CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
5176f91e TG	477	[CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
5176f91e TG	478	.len = GENL_NAMSIZ - 1 },
482a8524 TG	479	};
	480
	481	static int ctrl_getfamily(struct sk_buff skb, struct genl_info info)
	482	{
	483	struct sk_buff *msg;
	484	struct genl_family *res = NULL;
	485	int err = -EINVAL;
	486
	487	if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
	488	u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
	489	res = genl_family_find_byid(id);
	490	}
	491
	492	if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
5176f91e	493	char *name;
482a8524	494
5176f91e	495	name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
482a8524 TG	496	res = genl_family_find_byname(name);
	497	}
	498
	499	if (res == NULL) {
	500	err = -ENOENT;
	501	goto errout;
	502	}
	503
	504	msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
	505	CTRL_CMD_NEWFAMILY);
	506	if (IS_ERR(msg)) {
	507	err = PTR_ERR(msg);
	508	goto errout;
	509	}
	510
81878d27	511	err = genlmsg_reply(msg, info);
482a8524 TG	512	errout:
	513	return err;
	514	}
	515
	516	static int genl_ctrl_event(int event, void *data)
	517	{
	518	struct sk_buff *msg;
	519
	520	if (genl_sock == NULL)
	521	return 0;
	522
	523	switch (event) {
	524	case CTRL_CMD_NEWFAMILY:
	525	case CTRL_CMD_DELFAMILY:
	526	msg = ctrl_build_msg(data, 0, 0, event);
	527	if (IS_ERR(msg))
	528	return PTR_ERR(msg);
	529
d387f6ad	530	genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
482a8524 TG	531	break;
	532	}
	533
	534	return 0;
	535	}
	536
	537	static struct genl_ops genl_ctrl_ops = {
	538	.cmd = CTRL_CMD_GETFAMILY,
	539	.doit = ctrl_getfamily,
	540	.dumpit = ctrl_dumpfamily,
	541	.policy = ctrl_policy,
	542	};
	543
482a8524 TG	544	static int __init genl_init(void)
	545	{
	546	int i, err;
	547
	548	for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
	549	INIT_LIST_HEAD(&family_ht[i]);
	550
	551	err = genl_register_family(&genl_ctrl);
	552	if (err < 0)
	553	goto errout;
	554
	555	err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
	556	if (err < 0)
	557	goto errout_register;
	558
	559	netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
	560	genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
af65bdfc	561	genl_rcv, NULL, THIS_MODULE);
e200bd80	562	if (genl_sock == NULL)
482a8524	563	panic("GENL: Cannot initialize generic netlink\n");
482a8524 TG	564
	565	return 0;
	566
	567	errout_register:
	568	genl_unregister_family(&genl_ctrl);
	569	errout:
	570	panic("GENL: Cannot register controller: %d\n", err);
482a8524 TG	571	}
	572
	573	subsys_initcall(genl_init);
	574
	575	EXPORT_SYMBOL(genl_sock);
	576	EXPORT_SYMBOL(genl_register_ops);
	577	EXPORT_SYMBOL(genl_unregister_ops);
	578	EXPORT_SYMBOL(genl_register_family);
	579	EXPORT_SYMBOL(genl_unregister_family);