[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / netlink / genetlink.c

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

#include <linux/config.h>
#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 <net/sock.h>
#include <net/genetlink.h>

struct sock *genl_sock = NULL;

static DECLARE_MUTEX(genl_sem); /* serialization of message processing */

static void genl_lock(void)
{
	down(&genl_sem);
}

static int genl_trylock(void)
{
	return down_trylock(&genl_sem);
}

static void genl_unlock(void)
{
	up(&genl_sem);

	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;
	}

	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 (!try_module_get(family->owner)) {
		err = -EBUSY;
		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;
		}
	} 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();

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

	genl_unlock();

	return -ENOENT;
}

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

	if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
		goto ignore;

	if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
		goto ignore;

       	family = genl_family_find_byid(nlh->nlmsg_type);
	if (family == NULL) {
		err = -ENOENT;
		goto errout;
	}

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

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

	if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb)) {
		err = -EPERM;
		goto errout;
	}

	if (nlh->nlmsg_flags & NLM_F_DUMP) {
		if (ops->dumpit == NULL) {
			err = -EOPNOTSUPP;
			goto errout;
		}

		*errp = err = netlink_dump_start(genl_sock, skb, nlh,
						 ops->dumpit, NULL);
		if (err == 0)
			skb_pull(skb, min(NLMSG_ALIGN(nlh->nlmsg_len),
					  skb->len));
		return -1;
	}

	if (ops->doit == NULL) {
		err = -EOPNOTSUPP;
		goto errout;
	}

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

	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;

	*errp = err = ops->doit(skb, &info);
	return err;

ignore:
	return 0;

errout:
	*errp = err;
	return -1;
}

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 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_ID_CTRL, 0, flags, cmd,
			  family->version);
	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);

	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];

	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:
	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, int cmd)
{
	struct sk_buff *skb;
	int err;

	skb = nlmsg_new(NLMSG_GOODSIZE);
	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_STRING },
};

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[GENL_NAMSIZ];

		if (nla_strlcpy(name, info->attrs[CTRL_ATTR_FAMILY_NAME],
				GENL_NAMSIZ) >= GENL_NAMSIZ)
			goto errout;

		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_unicast(msg, info->snd_pid);
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);
		break;
	}

	return 0;
}

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

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

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, THIS_MODULE);
	if (genl_sock == NULL) {
		panic("GENL: Cannot initialize generic netlink\n");
		return -ENOMEM;
	}

	return 0;

errout_register:
	genl_unregister_family(&genl_ctrl);
errout:
	panic("GENL: Cannot register controller: %d\n", err);
	return 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
	8	#include <linux/config.h>
	9	#include <linux/module.h>
	10	#include <linux/kernel.h>
	11	#include <linux/errno.h>
	12	#include <linux/types.h>
	13	#include <linux/socket.h>
	14	#include <linux/string.h>
	15	#include <linux/skbuff.h>
	16	#include <net/sock.h>
	17	#include <net/genetlink.h>
	18
	19	struct sock *genl_sock = NULL;
	20
	21	static DECLARE_MUTEX(genl_sem); /* serialization of message processing */
	22
	23	static void genl_lock(void)
	24	{
	25	down(&genl_sem);
	26	}
	27
	28	static int genl_trylock(void)
	29	{
	30	return down_trylock(&genl_sem);
	31	}
	32
	33	static void genl_unlock(void)
	34	{
	35	up(&genl_sem);
	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
146	genl_lock();
147	list_add_tail(&ops->ops_list, &family->ops_list);
148	genl_unlock();
149
150	genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
151	err = 0;
152	errout:
153	return err;
154	}
155
156	/**
157	* genl_unregister_ops - unregister generic netlink operations
158	* @family: generic netlink family
159	* @ops: operations to be unregistered
160	*
161	* Unregisters the specified operations and unassigns them from the
162	* specified family. The operation blocks until the current message
163	* processing has finished and doesn't start again until the
164	* unregister process has finished.
165	*
166	* Note: It is not necessary to unregister all operations before
167	* unregistering the family, unregistering the family will cause
168	* all assigned operations to be unregistered automatically.
169	*
170	* Returns 0 on success or a negative error code.
171	*/
172	int genl_unregister_ops(struct genl_family family, struct genl_ops ops)
173	{
174	struct genl_ops *rc;
175
176	genl_lock();
177	list_for_each_entry(rc, &family->ops_list, ops_list) {
178	if (rc == ops) {
179	list_del(&ops->ops_list);
180	genl_unlock();
181	genl_ctrl_event(CTRL_CMD_DELOPS, ops);
182	return 0;
183	}
184	}
185	genl_unlock();
186
187	return -ENOENT;
188	}
189
190	/**
191	* genl_register_family - register a generic netlink family
192	* @family: generic netlink family
193	*
194	* Registers the specified family after validating it first. Only one
195	* family may be registered with the same family name or identifier.
196	* The family id may equal GENL_ID_GENERATE causing an unique id to
197	* be automatically generated and assigned.
198	*
199	* Return 0 on success or a negative error code.
200	*/
201	int genl_register_family(struct genl_family *family)
202	{
203	int err = -EINVAL;
204
205	if (family->id && family->id < GENL_MIN_ID)
206	goto errout;
207
208	if (family->id > GENL_MAX_ID)
209	goto errout;
210
211	INIT_LIST_HEAD(&family->ops_list);
212
213	genl_lock();
214
215	if (genl_family_find_byname(family->name)) {
216	err = -EEXIST;
217	goto errout_locked;
218	}
219
220	if (genl_family_find_byid(family->id)) {
221	err = -EEXIST;
222	goto errout_locked;
223	}
224
225	if (!try_module_get(family->owner)) {
226	err = -EBUSY;
227	goto errout_locked;
228	}
229
230	if (family->id == GENL_ID_GENERATE) {
231	u16 newid = genl_generate_id();
232
233	if (!newid) {
234	err = -ENOMEM;
235	goto errout_locked;
236	}
237
238	family->id = newid;
239	}
240
241	if (family->maxattr) {
242	family->attrbuf = kmalloc((family->maxattr+1) *
243	sizeof(struct nlattr *), GFP_KERNEL);
244	if (family->attrbuf == NULL) {
245	err = -ENOMEM;
246	goto errout;
247	}
248	} else
249	family->attrbuf = NULL;
250
251	list_add_tail(&family->family_list, genl_family_chain(family->id));
252	genl_unlock();
253
254	genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
255
256	return 0;
257
258	errout_locked:
259	genl_unlock();
260	errout:
261	return err;
262	}
263
264	/**
265	* genl_unregister_family - unregister generic netlink family
266	* @family: generic netlink family
267	*
268	* Unregisters the specified family.
269	*
270	* Returns 0 on success or a negative error code.
271	*/
272	int genl_unregister_family(struct genl_family *family)
273	{
274	struct genl_family *rc;
275
276	genl_lock();
277
278	list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
279	if (family->id != rc->id \|\| strcmp(rc->name, family->name))
280	continue;
281
282	list_del(&rc->family_list);
283	INIT_LIST_HEAD(&family->ops_list);
284	genl_unlock();
285
286	module_put(family->owner);
287	kfree(family->attrbuf);
288	genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
289	return 0;
290	}
291
292	genl_unlock();
293
294	return -ENOENT;
295	}
296
297	static inline int genl_rcv_msg(struct sk_buff skb, struct nlmsghdr nlh,
298	int *errp)
299	{
300	struct genl_ops *ops;
301	struct genl_family *family;
302	struct genl_info info;
303	struct genlmsghdr *hdr = nlmsg_data(nlh);
304	int hdrlen, err = -EINVAL;
305
306	if (!(nlh->nlmsg_flags & NLM_F_REQUEST))
307	goto ignore;
308
309	if (nlh->nlmsg_type < NLMSG_MIN_TYPE)
310	goto ignore;
311
312	family = genl_family_find_byid(nlh->nlmsg_type);
313	if (family == NULL) {
314	err = -ENOENT;
315	goto errout;
316	}
317
318	hdrlen = GENL_HDRLEN + family->hdrsize;
319	if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
320	goto errout;
321
322	ops = genl_get_cmd(hdr->cmd, family);
323	if (ops == NULL) {
324	err = -EOPNOTSUPP;
325	goto errout;
326	}
327
328	if ((ops->flags & GENL_ADMIN_PERM) && security_netlink_recv(skb)) {
329	err = -EPERM;
330	goto errout;
331	}
332
333	if (nlh->nlmsg_flags & NLM_F_DUMP) {
334	if (ops->dumpit == NULL) {
335	err = -EOPNOTSUPP;
336	goto errout;
337	}
338
339	*errp = err = netlink_dump_start(genl_sock, skb, nlh,
340	ops->dumpit, NULL);
341	if (err == 0)
342	skb_pull(skb, min(NLMSG_ALIGN(nlh->nlmsg_len),
343	skb->len));
344	return -1;
345	}
346
347	if (ops->doit == NULL) {
348	err = -EOPNOTSUPP;
349	goto errout;
350	}
351
352	if (family->attrbuf) {
353	err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
354	ops->policy);
355	if (err < 0)
356	goto errout;
357	}
358
359	info.snd_seq = nlh->nlmsg_seq;
360	info.snd_pid = NETLINK_CB(skb).pid;
361	info.nlhdr = nlh;
362	info.genlhdr = nlmsg_data(nlh);
363	info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
364	info.attrs = family->attrbuf;
365
366	*errp = err = ops->doit(skb, &info);
367	return err;
368
369	ignore:
370	return 0;
371
372	errout:
373	*errp = err;
374	return -1;
375	}
376
377	static void genl_rcv(struct sock *sk, int len)
378	{
379	unsigned int qlen = 0;
380
381	do {
382	if (genl_trylock())
383	return;
384	netlink_run_queue(sk, &qlen, &genl_rcv_msg);
385	genl_unlock();
386	} while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
387	}
388
389	/**************************************************************************
390	* Controller
391	**************************************************************************/
392
393	static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
394	u32 flags, struct sk_buff *skb, u8 cmd)
395	{
396	void *hdr;
397
398	hdr = genlmsg_put(skb, pid, seq, GENL_ID_CTRL, 0, flags, cmd,
399	family->version);
400	if (hdr == NULL)
401	return -1;
402
403	NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
404	NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
405
406	return genlmsg_end(skb, hdr);
407
408	nla_put_failure:
409	return genlmsg_cancel(skb, hdr);
410	}
411
412	static int ctrl_dumpfamily(struct sk_buff skb, struct netlink_callback cb)
413	{
414
415	int i, n = 0;
416	struct genl_family *rt;
417	int chains_to_skip = cb->args[0];
418	int fams_to_skip = cb->args[1];
419
420	for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
421	if (i < chains_to_skip)
422	continue;
423	n = 0;
424	list_for_each_entry(rt, genl_family_chain(i), family_list) {
425	if (++n < fams_to_skip)
426	continue;
427	if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
428	cb->nlh->nlmsg_seq, NLM_F_MULTI,
429	skb, CTRL_CMD_NEWFAMILY) < 0)
430	goto errout;
431	}
432
433	fams_to_skip = 0;
434	}
435
436	errout:
437	cb->args[0] = i;
438	cb->args[1] = n;
439
440	return skb->len;
441	}
442
443	static struct sk_buff ctrl_build_msg(struct genl_family family, u32 pid,
444	int seq, int cmd)
445	{
446	struct sk_buff *skb;
447	int err;
448
449	skb = nlmsg_new(NLMSG_GOODSIZE);
450	if (skb == NULL)
451	return ERR_PTR(-ENOBUFS);
452
453	err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
454	if (err < 0) {
455	nlmsg_free(skb);
456	return ERR_PTR(err);
457	}
458
459	return skb;
460	}
461
462	static struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] __read_mostly = {
463	[CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
464	[CTRL_ATTR_FAMILY_NAME] = { .type = NLA_STRING },
465	};
466
467	static int ctrl_getfamily(struct sk_buff skb, struct genl_info info)
468	{
469	struct sk_buff *msg;
470	struct genl_family *res = NULL;
471	int err = -EINVAL;
472
473	if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
474	u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
475	res = genl_family_find_byid(id);
476	}
477
478	if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
479	char name[GENL_NAMSIZ];
480
481	if (nla_strlcpy(name, info->attrs[CTRL_ATTR_FAMILY_NAME],
482	GENL_NAMSIZ) >= GENL_NAMSIZ)
483	goto errout;
484
485	res = genl_family_find_byname(name);
486	}
487
488	if (res == NULL) {
489	err = -ENOENT;
490	goto errout;
491	}
492
493	msg = ctrl_build_msg(res, info->snd_pid, info->snd_seq,
494	CTRL_CMD_NEWFAMILY);
495	if (IS_ERR(msg)) {
496	err = PTR_ERR(msg);
497	goto errout;
498	}
499
500	err = genlmsg_unicast(msg, info->snd_pid);
501	errout:
502	return err;
503	}
504
505	static int genl_ctrl_event(int event, void *data)
506	{
507	struct sk_buff *msg;
508
509	if (genl_sock == NULL)
510	return 0;
511
512	switch (event) {
513	case CTRL_CMD_NEWFAMILY:
514	case CTRL_CMD_DELFAMILY:
515	msg = ctrl_build_msg(data, 0, 0, event);
516	if (IS_ERR(msg))
517	return PTR_ERR(msg);
518
519	genlmsg_multicast(msg, 0, GENL_ID_CTRL);
520	break;
521	}
522
523	return 0;
524	}
525
526	static struct genl_ops genl_ctrl_ops = {
527	.cmd = CTRL_CMD_GETFAMILY,
528	.doit = ctrl_getfamily,
529	.dumpit = ctrl_dumpfamily,
530	.policy = ctrl_policy,
531	};
532
533	static struct genl_family genl_ctrl = {
534	.id = GENL_ID_CTRL,
535	.name = "nlctrl",
536	.version = 0x1,
537	.maxattr = CTRL_ATTR_MAX,
538	.owner = THIS_MODULE,
539	};
540
541	static int __init genl_init(void)
542	{
543	int i, err;
544
545	for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
546	INIT_LIST_HEAD(&family_ht[i]);
547
548	err = genl_register_family(&genl_ctrl);
549	if (err < 0)
550	goto errout;
551
552	err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
553	if (err < 0)
554	goto errout_register;
555
556	netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
557	genl_sock = netlink_kernel_create(NETLINK_GENERIC, GENL_MAX_ID,
558	genl_rcv, THIS_MODULE);
559	if (genl_sock == NULL) {
560	panic("GENL: Cannot initialize generic netlink\n");
561	return -ENOMEM;
562	}
563
564	return 0;
565
566	errout_register:
567	genl_unregister_family(&genl_ctrl);
568	errout:
569	panic("GENL: Cannot register controller: %d\n", err);
570	return err;
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);