blob: 8c11ca4a2121692614ac43064c2718695d11bf6b [file] [log] [blame]
Thomas Graf482a8522005-11-10 02:25:56 +01001/*
2 * NETLINK Generic Netlink Family
3 *
4 * Authors: Jamal Hadi Salim
5 * Thomas Graf <tgraf@suug.ch>
Johannes Berg2dbba6f2007-07-18 15:47:52 -07006 * Johannes Berg <johannes@sipsolutions.net>
Thomas Graf482a8522005-11-10 02:25:56 +01007 */
8
Thomas Graf482a8522005-11-10 02:25:56 +01009#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>
Ingo Molnar14cc3e22006-03-26 01:37:14 -080016#include <linux/mutex.h>
Johannes Berg2dbba6f2007-07-18 15:47:52 -070017#include <linux/bitmap.h>
Thomas Graf482a8522005-11-10 02:25:56 +010018#include <net/sock.h>
19#include <net/genetlink.h>
20
21struct sock *genl_sock = NULL;
22
Ingo Molnar14cc3e22006-03-26 01:37:14 -080023static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
Thomas Graf482a8522005-11-10 02:25:56 +010024
25static void genl_lock(void)
26{
Ingo Molnar14cc3e22006-03-26 01:37:14 -080027 mutex_lock(&genl_mutex);
Thomas Graf482a8522005-11-10 02:25:56 +010028}
29
30static int genl_trylock(void)
31{
Ingo Molnar14cc3e22006-03-26 01:37:14 -080032 return !mutex_trylock(&genl_mutex);
Thomas Graf482a8522005-11-10 02:25:56 +010033}
34
35static void genl_unlock(void)
36{
Ingo Molnar14cc3e22006-03-26 01:37:14 -080037 mutex_unlock(&genl_mutex);
Thomas Graf482a8522005-11-10 02:25:56 +010038
39 if (genl_sock && genl_sock->sk_receive_queue.qlen)
40 genl_sock->sk_data_ready(genl_sock, 0);
41}
42
43#define GENL_FAM_TAB_SIZE 16
44#define GENL_FAM_TAB_MASK (GENL_FAM_TAB_SIZE - 1)
45
46static struct list_head family_ht[GENL_FAM_TAB_SIZE];
Johannes Berg2dbba6f2007-07-18 15:47:52 -070047/*
48 * Bitmap of multicast groups that are currently in use.
49 *
50 * To avoid an allocation at boot of just one unsigned long,
51 * declare it global instead.
52 * Bit 0 is marked as already used since group 0 is invalid.
53 */
54static unsigned long mc_group_start = 0x1;
55static unsigned long *mc_groups = &mc_group_start;
56static unsigned long mc_groups_longs = 1;
Thomas Graf482a8522005-11-10 02:25:56 +010057
58static int genl_ctrl_event(int event, void *data);
59
60static inline unsigned int genl_family_hash(unsigned int id)
61{
62 return id & GENL_FAM_TAB_MASK;
63}
64
65static inline struct list_head *genl_family_chain(unsigned int id)
66{
67 return &family_ht[genl_family_hash(id)];
68}
69
70static struct genl_family *genl_family_find_byid(unsigned int id)
71{
72 struct genl_family *f;
73
74 list_for_each_entry(f, genl_family_chain(id), family_list)
75 if (f->id == id)
76 return f;
77
78 return NULL;
79}
80
81static struct genl_family *genl_family_find_byname(char *name)
82{
83 struct genl_family *f;
84 int i;
85
86 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
87 list_for_each_entry(f, genl_family_chain(i), family_list)
88 if (strcmp(f->name, name) == 0)
89 return f;
90
91 return NULL;
92}
93
94static struct genl_ops *genl_get_cmd(u8 cmd, struct genl_family *family)
95{
96 struct genl_ops *ops;
97
98 list_for_each_entry(ops, &family->ops_list, ops_list)
99 if (ops->cmd == cmd)
100 return ops;
101
102 return NULL;
103}
104
105/* Of course we are going to have problems once we hit
106 * 2^16 alive types, but that can only happen by year 2K
107*/
108static inline u16 genl_generate_id(void)
109{
110 static u16 id_gen_idx;
111 int overflowed = 0;
112
113 do {
114 if (id_gen_idx == 0)
115 id_gen_idx = GENL_MIN_ID;
116
117 if (++id_gen_idx > GENL_MAX_ID) {
118 if (!overflowed) {
119 overflowed = 1;
120 id_gen_idx = 0;
121 continue;
122 } else
123 return 0;
124 }
125
126 } while (genl_family_find_byid(id_gen_idx));
127
128 return id_gen_idx;
129}
130
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700131static struct genl_multicast_group notify_grp;
132
133/**
134 * genl_register_mc_group - register a multicast group
135 *
136 * Registers the specified multicast group and notifies userspace
137 * about the new group.
138 *
139 * Returns 0 on success or a negative error code.
140 *
141 * @family: The generic netlink family the group shall be registered for.
142 * @grp: The group to register, must have a name.
143 */
144int genl_register_mc_group(struct genl_family *family,
145 struct genl_multicast_group *grp)
146{
147 int id;
148 unsigned long *new_groups;
149 int err;
150
151 BUG_ON(grp->name[0] == '\0');
152
153 genl_lock();
154
155 /* special-case our own group */
156 if (grp == &notify_grp)
157 id = GENL_ID_CTRL;
158 else
159 id = find_first_zero_bit(mc_groups,
160 mc_groups_longs * BITS_PER_LONG);
161
162
163 if (id >= mc_groups_longs * BITS_PER_LONG) {
164 size_t nlen = (mc_groups_longs + 1) * sizeof(unsigned long);
165
166 if (mc_groups == &mc_group_start) {
167 new_groups = kzalloc(nlen, GFP_KERNEL);
168 if (!new_groups) {
169 err = -ENOMEM;
170 goto out;
171 }
172 mc_groups = new_groups;
173 *mc_groups = mc_group_start;
174 } else {
175 new_groups = krealloc(mc_groups, nlen, GFP_KERNEL);
176 if (!new_groups) {
177 err = -ENOMEM;
178 goto out;
179 }
180 mc_groups = new_groups;
181 mc_groups[mc_groups_longs] = 0;
182 }
183 mc_groups_longs++;
184 }
185
186 err = netlink_change_ngroups(genl_sock,
Thomas Graf2c04ddb2007-07-24 15:33:51 -0700187 mc_groups_longs * BITS_PER_LONG);
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700188 if (err)
189 goto out;
190
191 grp->id = id;
192 set_bit(id, mc_groups);
193 list_add_tail(&grp->list, &family->mcast_groups);
194 grp->family = family;
195
196 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, grp);
197 out:
198 genl_unlock();
Thomas Graf79d310d2007-07-24 15:34:53 -0700199 return err;
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700200}
201EXPORT_SYMBOL(genl_register_mc_group);
202
Thomas Graf79dc43862007-07-24 15:32:46 -0700203static void __genl_unregister_mc_group(struct genl_family *family,
204 struct genl_multicast_group *grp)
205{
206 BUG_ON(grp->family != family);
207 netlink_clear_multicast_users(genl_sock, grp->id);
208 clear_bit(grp->id, mc_groups);
209 list_del(&grp->list);
210 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, grp);
211 grp->id = 0;
212 grp->family = NULL;
213}
214
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700215/**
216 * genl_unregister_mc_group - unregister a multicast group
217 *
218 * Unregisters the specified multicast group and notifies userspace
219 * about it. All current listeners on the group are removed.
220 *
221 * Note: It is not necessary to unregister all multicast groups before
222 * unregistering the family, unregistering the family will cause
223 * all assigned multicast groups to be unregistered automatically.
224 *
225 * @family: Generic netlink family the group belongs to.
226 * @grp: The group to unregister, must have been registered successfully
227 * previously.
228 */
229void genl_unregister_mc_group(struct genl_family *family,
230 struct genl_multicast_group *grp)
231{
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700232 genl_lock();
Thomas Graf79dc43862007-07-24 15:32:46 -0700233 __genl_unregister_mc_group(family, grp);
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700234 genl_unlock();
235}
236
237static void genl_unregister_mc_groups(struct genl_family *family)
238{
239 struct genl_multicast_group *grp, *tmp;
240
Thomas Graf79dc43862007-07-24 15:32:46 -0700241 genl_lock();
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700242 list_for_each_entry_safe(grp, tmp, &family->mcast_groups, list)
Thomas Graf79dc43862007-07-24 15:32:46 -0700243 __genl_unregister_mc_group(family, grp);
244 genl_unlock();
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700245}
246
Thomas Graf482a8522005-11-10 02:25:56 +0100247/**
248 * genl_register_ops - register generic netlink operations
249 * @family: generic netlink family
250 * @ops: operations to be registered
251 *
252 * Registers the specified operations and assigns them to the specified
253 * family. Either a doit or dumpit callback must be specified or the
254 * operation will fail. Only one operation structure per command
255 * identifier may be registered.
256 *
257 * See include/net/genetlink.h for more documenation on the operations
258 * structure.
259 *
260 * Returns 0 on success or a negative error code.
261 */
262int genl_register_ops(struct genl_family *family, struct genl_ops *ops)
263{
264 int err = -EINVAL;
265
266 if (ops->dumpit == NULL && ops->doit == NULL)
267 goto errout;
268
269 if (genl_get_cmd(ops->cmd, family)) {
270 err = -EEXIST;
271 goto errout;
272 }
273
Jamal Hadi Salim334c29a2006-12-04 19:31:51 -0800274 if (ops->dumpit)
Jamal Hadi Salim334c29a2006-12-04 19:31:51 -0800275 ops->flags |= GENL_CMD_CAP_DUMP;
Jamal Hadi Salim48d4ed72006-12-06 20:06:25 -0800276 if (ops->doit)
277 ops->flags |= GENL_CMD_CAP_DO;
Jamal Hadi Salim334c29a2006-12-04 19:31:51 -0800278 if (ops->policy)
279 ops->flags |= GENL_CMD_CAP_HASPOL;
280
Thomas Graf482a8522005-11-10 02:25:56 +0100281 genl_lock();
282 list_add_tail(&ops->ops_list, &family->ops_list);
283 genl_unlock();
284
285 genl_ctrl_event(CTRL_CMD_NEWOPS, ops);
286 err = 0;
287errout:
288 return err;
289}
290
291/**
292 * genl_unregister_ops - unregister generic netlink operations
293 * @family: generic netlink family
294 * @ops: operations to be unregistered
295 *
296 * Unregisters the specified operations and unassigns them from the
297 * specified family. The operation blocks until the current message
298 * processing has finished and doesn't start again until the
299 * unregister process has finished.
300 *
301 * Note: It is not necessary to unregister all operations before
302 * unregistering the family, unregistering the family will cause
303 * all assigned operations to be unregistered automatically.
304 *
305 * Returns 0 on success or a negative error code.
306 */
307int genl_unregister_ops(struct genl_family *family, struct genl_ops *ops)
308{
309 struct genl_ops *rc;
310
311 genl_lock();
312 list_for_each_entry(rc, &family->ops_list, ops_list) {
313 if (rc == ops) {
314 list_del(&ops->ops_list);
315 genl_unlock();
316 genl_ctrl_event(CTRL_CMD_DELOPS, ops);
317 return 0;
318 }
319 }
320 genl_unlock();
321
322 return -ENOENT;
323}
324
325/**
326 * genl_register_family - register a generic netlink family
327 * @family: generic netlink family
328 *
329 * Registers the specified family after validating it first. Only one
330 * family may be registered with the same family name or identifier.
331 * The family id may equal GENL_ID_GENERATE causing an unique id to
332 * be automatically generated and assigned.
333 *
334 * Return 0 on success or a negative error code.
335 */
336int genl_register_family(struct genl_family *family)
337{
338 int err = -EINVAL;
339
340 if (family->id && family->id < GENL_MIN_ID)
341 goto errout;
342
343 if (family->id > GENL_MAX_ID)
344 goto errout;
345
346 INIT_LIST_HEAD(&family->ops_list);
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700347 INIT_LIST_HEAD(&family->mcast_groups);
Thomas Graf482a8522005-11-10 02:25:56 +0100348
349 genl_lock();
350
351 if (genl_family_find_byname(family->name)) {
352 err = -EEXIST;
353 goto errout_locked;
354 }
355
356 if (genl_family_find_byid(family->id)) {
357 err = -EEXIST;
358 goto errout_locked;
359 }
360
Thomas Graf482a8522005-11-10 02:25:56 +0100361 if (family->id == GENL_ID_GENERATE) {
362 u16 newid = genl_generate_id();
363
364 if (!newid) {
365 err = -ENOMEM;
366 goto errout_locked;
367 }
368
369 family->id = newid;
370 }
371
372 if (family->maxattr) {
373 family->attrbuf = kmalloc((family->maxattr+1) *
374 sizeof(struct nlattr *), GFP_KERNEL);
375 if (family->attrbuf == NULL) {
376 err = -ENOMEM;
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800377 goto errout_locked;
Thomas Graf482a8522005-11-10 02:25:56 +0100378 }
379 } else
380 family->attrbuf = NULL;
381
382 list_add_tail(&family->family_list, genl_family_chain(family->id));
383 genl_unlock();
384
385 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family);
386
387 return 0;
388
389errout_locked:
390 genl_unlock();
391errout:
392 return err;
393}
394
395/**
396 * genl_unregister_family - unregister generic netlink family
397 * @family: generic netlink family
398 *
399 * Unregisters the specified family.
400 *
401 * Returns 0 on success or a negative error code.
402 */
403int genl_unregister_family(struct genl_family *family)
404{
405 struct genl_family *rc;
406
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700407 genl_unregister_mc_groups(family);
408
Thomas Graf482a8522005-11-10 02:25:56 +0100409 genl_lock();
410
411 list_for_each_entry(rc, genl_family_chain(family->id), family_list) {
412 if (family->id != rc->id || strcmp(rc->name, family->name))
413 continue;
414
415 list_del(&rc->family_list);
416 INIT_LIST_HEAD(&family->ops_list);
417 genl_unlock();
418
Thomas Graf482a8522005-11-10 02:25:56 +0100419 kfree(family->attrbuf);
420 genl_ctrl_event(CTRL_CMD_DELFAMILY, family);
421 return 0;
422 }
423
424 genl_unlock();
425
426 return -ENOENT;
427}
428
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700429static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
Thomas Graf482a8522005-11-10 02:25:56 +0100430{
431 struct genl_ops *ops;
432 struct genl_family *family;
433 struct genl_info info;
434 struct genlmsghdr *hdr = nlmsg_data(nlh);
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700435 int hdrlen, err;
Thomas Graf482a8522005-11-10 02:25:56 +0100436
YOSHIFUJI Hideaki746fac42007-02-09 23:25:07 +0900437 family = genl_family_find_byid(nlh->nlmsg_type);
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700438 if (family == NULL)
439 return -ENOENT;
Thomas Graf482a8522005-11-10 02:25:56 +0100440
441 hdrlen = GENL_HDRLEN + family->hdrsize;
442 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700443 return -EINVAL;
Thomas Graf482a8522005-11-10 02:25:56 +0100444
445 ops = genl_get_cmd(hdr->cmd, family);
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700446 if (ops == NULL)
447 return -EOPNOTSUPP;
Thomas Graf482a8522005-11-10 02:25:56 +0100448
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700449 if ((ops->flags & GENL_ADMIN_PERM) &&
450 security_netlink_recv(skb, CAP_NET_ADMIN))
451 return -EPERM;
Thomas Graf482a8522005-11-10 02:25:56 +0100452
453 if (nlh->nlmsg_flags & NLM_F_DUMP) {
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700454 if (ops->dumpit == NULL)
455 return -EOPNOTSUPP;
Thomas Graf482a8522005-11-10 02:25:56 +0100456
Thomas Grafc702e802007-03-22 23:30:55 -0700457 return netlink_dump_start(genl_sock, skb, nlh,
458 ops->dumpit, ops->done);
Thomas Graf482a8522005-11-10 02:25:56 +0100459 }
460
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700461 if (ops->doit == NULL)
462 return -EOPNOTSUPP;
Thomas Graf482a8522005-11-10 02:25:56 +0100463
464 if (family->attrbuf) {
465 err = nlmsg_parse(nlh, hdrlen, family->attrbuf, family->maxattr,
466 ops->policy);
467 if (err < 0)
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700468 return err;
Thomas Graf482a8522005-11-10 02:25:56 +0100469 }
470
471 info.snd_seq = nlh->nlmsg_seq;
472 info.snd_pid = NETLINK_CB(skb).pid;
473 info.nlhdr = nlh;
474 info.genlhdr = nlmsg_data(nlh);
475 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
476 info.attrs = family->attrbuf;
477
Thomas Graf1d00a4e2007-03-22 23:30:12 -0700478 return ops->doit(skb, &info);
Thomas Graf482a8522005-11-10 02:25:56 +0100479}
480
481static void genl_rcv(struct sock *sk, int len)
482{
483 unsigned int qlen = 0;
484
485 do {
486 if (genl_trylock())
487 return;
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800488 netlink_run_queue(sk, &qlen, genl_rcv_msg);
Thomas Graf482a8522005-11-10 02:25:56 +0100489 genl_unlock();
490 } while (qlen && genl_sock && genl_sock->sk_receive_queue.qlen);
491}
492
493/**************************************************************************
494 * Controller
495 **************************************************************************/
496
Thomas Graf17c157c2006-11-14 19:46:02 -0800497static struct genl_family genl_ctrl = {
498 .id = GENL_ID_CTRL,
499 .name = "nlctrl",
Jamal Hadi Salim334c29a2006-12-04 19:31:51 -0800500 .version = 0x2,
Thomas Graf17c157c2006-11-14 19:46:02 -0800501 .maxattr = CTRL_ATTR_MAX,
502};
503
Thomas Graf482a8522005-11-10 02:25:56 +0100504static int ctrl_fill_info(struct genl_family *family, u32 pid, u32 seq,
505 u32 flags, struct sk_buff *skb, u8 cmd)
506{
507 void *hdr;
508
Thomas Graf17c157c2006-11-14 19:46:02 -0800509 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
Thomas Graf482a8522005-11-10 02:25:56 +0100510 if (hdr == NULL)
511 return -1;
512
513 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, family->name);
514 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, family->id);
Thomas Grafeb328112006-09-18 00:01:59 -0700515 NLA_PUT_U32(skb, CTRL_ATTR_VERSION, family->version);
516 NLA_PUT_U32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize);
517 NLA_PUT_U32(skb, CTRL_ATTR_MAXATTR, family->maxattr);
518
Thomas Grafe94ef682006-11-23 11:44:37 -0800519 if (!list_empty(&family->ops_list)) {
520 struct nlattr *nla_ops;
521 struct genl_ops *ops;
522 int idx = 1;
Thomas Grafeb328112006-09-18 00:01:59 -0700523
Thomas Grafe94ef682006-11-23 11:44:37 -0800524 nla_ops = nla_nest_start(skb, CTRL_ATTR_OPS);
525 if (nla_ops == NULL)
Thomas Grafeb328112006-09-18 00:01:59 -0700526 goto nla_put_failure;
527
Thomas Grafe94ef682006-11-23 11:44:37 -0800528 list_for_each_entry(ops, &family->ops_list, ops_list) {
529 struct nlattr *nest;
Thomas Grafeb328112006-09-18 00:01:59 -0700530
Thomas Grafe94ef682006-11-23 11:44:37 -0800531 nest = nla_nest_start(skb, idx++);
532 if (nest == NULL)
533 goto nla_put_failure;
Thomas Grafeb328112006-09-18 00:01:59 -0700534
Thomas Grafe94ef682006-11-23 11:44:37 -0800535 NLA_PUT_U32(skb, CTRL_ATTR_OP_ID, ops->cmd);
536 NLA_PUT_U32(skb, CTRL_ATTR_OP_FLAGS, ops->flags);
Thomas Grafeb328112006-09-18 00:01:59 -0700537
Thomas Grafe94ef682006-11-23 11:44:37 -0800538 nla_nest_end(skb, nest);
539 }
540
541 nla_nest_end(skb, nla_ops);
Thomas Grafeb328112006-09-18 00:01:59 -0700542 }
543
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700544 if (!list_empty(&family->mcast_groups)) {
545 struct genl_multicast_group *grp;
546 struct nlattr *nla_grps;
547 int idx = 1;
548
549 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
550 if (nla_grps == NULL)
551 goto nla_put_failure;
552
553 list_for_each_entry(grp, &family->mcast_groups, list) {
554 struct nlattr *nest;
555
556 nest = nla_nest_start(skb, idx++);
557 if (nest == NULL)
558 goto nla_put_failure;
559
560 NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
561 NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
562 grp->name);
563
564 nla_nest_end(skb, nest);
565 }
566 nla_nest_end(skb, nla_grps);
567 }
568
569 return genlmsg_end(skb, hdr);
570
571nla_put_failure:
572 return genlmsg_cancel(skb, hdr);
573}
574
575static int ctrl_fill_mcgrp_info(struct genl_multicast_group *grp, u32 pid,
576 u32 seq, u32 flags, struct sk_buff *skb,
577 u8 cmd)
578{
579 void *hdr;
580 struct nlattr *nla_grps;
581 struct nlattr *nest;
582
583 hdr = genlmsg_put(skb, pid, seq, &genl_ctrl, flags, cmd);
584 if (hdr == NULL)
585 return -1;
586
587 NLA_PUT_STRING(skb, CTRL_ATTR_FAMILY_NAME, grp->family->name);
588 NLA_PUT_U16(skb, CTRL_ATTR_FAMILY_ID, grp->family->id);
589
590 nla_grps = nla_nest_start(skb, CTRL_ATTR_MCAST_GROUPS);
591 if (nla_grps == NULL)
592 goto nla_put_failure;
593
594 nest = nla_nest_start(skb, 1);
595 if (nest == NULL)
596 goto nla_put_failure;
597
598 NLA_PUT_U32(skb, CTRL_ATTR_MCAST_GRP_ID, grp->id);
599 NLA_PUT_STRING(skb, CTRL_ATTR_MCAST_GRP_NAME,
600 grp->name);
601
602 nla_nest_end(skb, nest);
603 nla_nest_end(skb, nla_grps);
604
Thomas Graf482a8522005-11-10 02:25:56 +0100605 return genlmsg_end(skb, hdr);
606
607nla_put_failure:
608 return genlmsg_cancel(skb, hdr);
609}
610
611static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
612{
613
614 int i, n = 0;
615 struct genl_family *rt;
616 int chains_to_skip = cb->args[0];
617 int fams_to_skip = cb->args[1];
618
Thomas Grafeb328112006-09-18 00:01:59 -0700619 if (chains_to_skip != 0)
620 genl_lock();
621
Thomas Graf482a8522005-11-10 02:25:56 +0100622 for (i = 0; i < GENL_FAM_TAB_SIZE; i++) {
623 if (i < chains_to_skip)
624 continue;
625 n = 0;
626 list_for_each_entry(rt, genl_family_chain(i), family_list) {
627 if (++n < fams_to_skip)
628 continue;
629 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).pid,
630 cb->nlh->nlmsg_seq, NLM_F_MULTI,
631 skb, CTRL_CMD_NEWFAMILY) < 0)
632 goto errout;
633 }
634
635 fams_to_skip = 0;
636 }
637
638errout:
Thomas Grafeb328112006-09-18 00:01:59 -0700639 if (chains_to_skip != 0)
640 genl_unlock();
641
Thomas Graf482a8522005-11-10 02:25:56 +0100642 cb->args[0] = i;
643 cb->args[1] = n;
644
645 return skb->len;
646}
647
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700648static struct sk_buff *ctrl_build_family_msg(struct genl_family *family,
649 u32 pid, int seq, u8 cmd)
Thomas Graf482a8522005-11-10 02:25:56 +0100650{
651 struct sk_buff *skb;
652 int err;
653
Thomas Graf339bf982006-11-10 14:10:15 -0800654 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
Thomas Graf482a8522005-11-10 02:25:56 +0100655 if (skb == NULL)
656 return ERR_PTR(-ENOBUFS);
657
658 err = ctrl_fill_info(family, pid, seq, 0, skb, cmd);
659 if (err < 0) {
660 nlmsg_free(skb);
661 return ERR_PTR(err);
662 }
663
664 return skb;
665}
666
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700667static struct sk_buff *ctrl_build_mcgrp_msg(struct genl_multicast_group *grp,
668 u32 pid, int seq, u8 cmd)
669{
670 struct sk_buff *skb;
671 int err;
672
673 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
674 if (skb == NULL)
675 return ERR_PTR(-ENOBUFS);
676
677 err = ctrl_fill_mcgrp_info(grp, pid, seq, 0, skb, cmd);
678 if (err < 0) {
679 nlmsg_free(skb);
680 return ERR_PTR(err);
681 }
682
683 return skb;
684}
685
Patrick McHardyef7c79e2007-06-05 12:38:30 -0700686static const struct nla_policy ctrl_policy[CTRL_ATTR_MAX+1] = {
Thomas Graf482a8522005-11-10 02:25:56 +0100687 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
Thomas Graf5176f912006-08-26 20:13:18 -0700688 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
689 .len = GENL_NAMSIZ - 1 },
Thomas Graf482a8522005-11-10 02:25:56 +0100690};
691
692static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
693{
694 struct sk_buff *msg;
695 struct genl_family *res = NULL;
696 int err = -EINVAL;
697
698 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
699 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
700 res = genl_family_find_byid(id);
701 }
702
703 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
Thomas Graf5176f912006-08-26 20:13:18 -0700704 char *name;
Thomas Graf482a8522005-11-10 02:25:56 +0100705
Thomas Graf5176f912006-08-26 20:13:18 -0700706 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
Thomas Graf482a8522005-11-10 02:25:56 +0100707 res = genl_family_find_byname(name);
708 }
709
710 if (res == NULL) {
711 err = -ENOENT;
712 goto errout;
713 }
714
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700715 msg = ctrl_build_family_msg(res, info->snd_pid, info->snd_seq,
716 CTRL_CMD_NEWFAMILY);
Thomas Graf482a8522005-11-10 02:25:56 +0100717 if (IS_ERR(msg)) {
718 err = PTR_ERR(msg);
719 goto errout;
720 }
721
Thomas Graf81878d22006-11-14 19:45:27 -0800722 err = genlmsg_reply(msg, info);
Thomas Graf482a8522005-11-10 02:25:56 +0100723errout:
724 return err;
725}
726
727static int genl_ctrl_event(int event, void *data)
728{
729 struct sk_buff *msg;
730
731 if (genl_sock == NULL)
732 return 0;
733
734 switch (event) {
735 case CTRL_CMD_NEWFAMILY:
736 case CTRL_CMD_DELFAMILY:
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700737 msg = ctrl_build_family_msg(data, 0, 0, event);
738 if (IS_ERR(msg))
739 return PTR_ERR(msg);
740
741 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
742 break;
743 case CTRL_CMD_NEWMCAST_GRP:
744 case CTRL_CMD_DELMCAST_GRP:
745 msg = ctrl_build_mcgrp_msg(data, 0, 0, event);
Thomas Graf482a8522005-11-10 02:25:56 +0100746 if (IS_ERR(msg))
747 return PTR_ERR(msg);
748
Thomas Grafd387f6a2006-08-15 00:31:06 -0700749 genlmsg_multicast(msg, 0, GENL_ID_CTRL, GFP_KERNEL);
Thomas Graf482a8522005-11-10 02:25:56 +0100750 break;
751 }
752
753 return 0;
754}
755
756static struct genl_ops genl_ctrl_ops = {
757 .cmd = CTRL_CMD_GETFAMILY,
758 .doit = ctrl_getfamily,
759 .dumpit = ctrl_dumpfamily,
760 .policy = ctrl_policy,
761};
762
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700763static struct genl_multicast_group notify_grp = {
764 .name = "notify",
765};
766
Thomas Graf482a8522005-11-10 02:25:56 +0100767static int __init genl_init(void)
768{
769 int i, err;
770
771 for (i = 0; i < GENL_FAM_TAB_SIZE; i++)
772 INIT_LIST_HEAD(&family_ht[i]);
773
774 err = genl_register_family(&genl_ctrl);
775 if (err < 0)
776 goto errout;
777
778 err = genl_register_ops(&genl_ctrl, &genl_ctrl_ops);
779 if (err < 0)
780 goto errout_register;
781
782 netlink_set_nonroot(NETLINK_GENERIC, NL_NONROOT_RECV);
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700783
784 /* we'll bump the group number right afterwards */
785 genl_sock = netlink_kernel_create(NETLINK_GENERIC, 0, genl_rcv,
786 NULL, THIS_MODULE);
Jamal Hadi Salime200bd82006-02-13 15:51:24 -0800787 if (genl_sock == NULL)
Thomas Graf482a8522005-11-10 02:25:56 +0100788 panic("GENL: Cannot initialize generic netlink\n");
Thomas Graf482a8522005-11-10 02:25:56 +0100789
Johannes Berg2dbba6f2007-07-18 15:47:52 -0700790 err = genl_register_mc_group(&genl_ctrl, &notify_grp);
791 if (err < 0)
792 goto errout_register;
793
Thomas Graf482a8522005-11-10 02:25:56 +0100794 return 0;
795
796errout_register:
797 genl_unregister_family(&genl_ctrl);
798errout:
799 panic("GENL: Cannot register controller: %d\n", err);
Thomas Graf482a8522005-11-10 02:25:56 +0100800}
801
802subsys_initcall(genl_init);
803
804EXPORT_SYMBOL(genl_sock);
805EXPORT_SYMBOL(genl_register_ops);
806EXPORT_SYMBOL(genl_unregister_ops);
807EXPORT_SYMBOL(genl_register_family);
808EXPORT_SYMBOL(genl_unregister_family);