1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
13#include <linux/errno.h>
14#include <linux/types.h>
15#include <linux/socket.h>
16#include <linux/string.h>
17#include <linux/skbuff.h>
18#include <linux/mutex.h>
19#include <linux/bitmap.h>
20#include <linux/rwsem.h>
21#include <linux/idr.h>
22#include <net/sock.h>
23#include <net/genetlink.h>
24
25static DEFINE_MUTEX(genl_mutex);
26static DECLARE_RWSEM(cb_lock);
27
28atomic_t genl_sk_destructing_cnt = ATOMIC_INIT(0);
29DECLARE_WAIT_QUEUE_HEAD(genl_sk_destructing_waitq);
30
31void genl_lock(void)
32{
33 mutex_lock(&genl_mutex);
34}
35EXPORT_SYMBOL(genl_lock);
36
37void genl_unlock(void)
38{
39 mutex_unlock(&genl_mutex);
40}
41EXPORT_SYMBOL(genl_unlock);
42
43static void genl_lock_all(void)
44{
45 down_write(&cb_lock);
46 genl_lock();
47}
48
49static void genl_unlock_all(void)
50{
51 genl_unlock();
52 up_write(&cb_lock);
53}
54
55static DEFINE_IDR(genl_fam_idr);
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75static unsigned long mc_group_start = 0x3 | BIT(GENL_ID_CTRL) |
76 BIT(GENL_ID_VFS_DQUOT) |
77 BIT(GENL_ID_PMCRAID);
78static unsigned long *mc_groups = &mc_group_start;
79static unsigned long mc_groups_longs = 1;
80
81static int genl_ctrl_event(int event, const struct genl_family *family,
82 const struct genl_multicast_group *grp,
83 int grp_id);
84
85static const struct genl_family *genl_family_find_byid(unsigned int id)
86{
87 return idr_find(&genl_fam_idr, id);
88}
89
90static const struct genl_family *genl_family_find_byname(char *name)
91{
92 const struct genl_family *family;
93 unsigned int id;
94
95 idr_for_each_entry(&genl_fam_idr, family, id)
96 if (strcmp(family->name, name) == 0)
97 return family;
98
99 return NULL;
100}
101
102static int genl_get_cmd_cnt(const struct genl_family *family)
103{
104 return family->n_ops + family->n_small_ops;
105}
106
107static void genl_op_from_full(const struct genl_family *family,
108 unsigned int i, struct genl_ops *op)
109{
110 *op = family->ops[i];
111
112 if (!op->maxattr)
113 op->maxattr = family->maxattr;
114 if (!op->policy)
115 op->policy = family->policy;
116}
117
118static int genl_get_cmd_full(u32 cmd, const struct genl_family *family,
119 struct genl_ops *op)
120{
121 int i;
122
123 for (i = 0; i < family->n_ops; i++)
124 if (family->ops[i].cmd == cmd) {
125 genl_op_from_full(family, i, op);
126 return 0;
127 }
128
129 return -ENOENT;
130}
131
132static void genl_op_from_small(const struct genl_family *family,
133 unsigned int i, struct genl_ops *op)
134{
135 memset(op, 0, sizeof(*op));
136 op->doit = family->small_ops[i].doit;
137 op->dumpit = family->small_ops[i].dumpit;
138 op->cmd = family->small_ops[i].cmd;
139 op->internal_flags = family->small_ops[i].internal_flags;
140 op->flags = family->small_ops[i].flags;
141 op->validate = family->small_ops[i].validate;
142
143 op->maxattr = family->maxattr;
144 op->policy = family->policy;
145}
146
147static int genl_get_cmd_small(u32 cmd, const struct genl_family *family,
148 struct genl_ops *op)
149{
150 int i;
151
152 for (i = 0; i < family->n_small_ops; i++)
153 if (family->small_ops[i].cmd == cmd) {
154 genl_op_from_small(family, i, op);
155 return 0;
156 }
157
158 return -ENOENT;
159}
160
161static int genl_get_cmd(u32 cmd, const struct genl_family *family,
162 struct genl_ops *op)
163{
164 if (!genl_get_cmd_full(cmd, family, op))
165 return 0;
166 return genl_get_cmd_small(cmd, family, op);
167}
168
169static void genl_get_cmd_by_index(unsigned int i,
170 const struct genl_family *family,
171 struct genl_ops *op)
172{
173 if (i < family->n_ops)
174 genl_op_from_full(family, i, op);
175 else if (i < family->n_ops + family->n_small_ops)
176 genl_op_from_small(family, i - family->n_ops, op);
177 else
178 WARN_ON_ONCE(1);
179}
180
181static int genl_allocate_reserve_groups(int n_groups, int *first_id)
182{
183 unsigned long *new_groups;
184 int start = 0;
185 int i;
186 int id;
187 bool fits;
188
189 do {
190 if (start == 0)
191 id = find_first_zero_bit(mc_groups,
192 mc_groups_longs *
193 BITS_PER_LONG);
194 else
195 id = find_next_zero_bit(mc_groups,
196 mc_groups_longs * BITS_PER_LONG,
197 start);
198
199 fits = true;
200 for (i = id;
201 i < min_t(int, id + n_groups,
202 mc_groups_longs * BITS_PER_LONG);
203 i++) {
204 if (test_bit(i, mc_groups)) {
205 start = i;
206 fits = false;
207 break;
208 }
209 }
210
211 if (id + n_groups > mc_groups_longs * BITS_PER_LONG) {
212 unsigned long new_longs = mc_groups_longs +
213 BITS_TO_LONGS(n_groups);
214 size_t nlen = new_longs * sizeof(unsigned long);
215
216 if (mc_groups == &mc_group_start) {
217 new_groups = kzalloc(nlen, GFP_KERNEL);
218 if (!new_groups)
219 return -ENOMEM;
220 mc_groups = new_groups;
221 *mc_groups = mc_group_start;
222 } else {
223 new_groups = krealloc(mc_groups, nlen,
224 GFP_KERNEL);
225 if (!new_groups)
226 return -ENOMEM;
227 mc_groups = new_groups;
228 for (i = 0; i < BITS_TO_LONGS(n_groups); i++)
229 mc_groups[mc_groups_longs + i] = 0;
230 }
231 mc_groups_longs = new_longs;
232 }
233 } while (!fits);
234
235 for (i = id; i < id + n_groups; i++)
236 set_bit(i, mc_groups);
237 *first_id = id;
238 return 0;
239}
240
241static struct genl_family genl_ctrl;
242
243static int genl_validate_assign_mc_groups(struct genl_family *family)
244{
245 int first_id;
246 int n_groups = family->n_mcgrps;
247 int err = 0, i;
248 bool groups_allocated = false;
249
250 if (!n_groups)
251 return 0;
252
253 for (i = 0; i < n_groups; i++) {
254 const struct genl_multicast_group *grp = &family->mcgrps[i];
255
256 if (WARN_ON(grp->name[0] == '\0'))
257 return -EINVAL;
258 if (WARN_ON(memchr(grp->name, '\0', GENL_NAMSIZ) == NULL))
259 return -EINVAL;
260 }
261
262
263 if (family == &genl_ctrl) {
264 first_id = GENL_ID_CTRL;
265 BUG_ON(n_groups != 1);
266 } else if (strcmp(family->name, "NET_DM") == 0) {
267 first_id = 1;
268 BUG_ON(n_groups != 1);
269 } else if (family->id == GENL_ID_VFS_DQUOT) {
270 first_id = GENL_ID_VFS_DQUOT;
271 BUG_ON(n_groups != 1);
272 } else if (family->id == GENL_ID_PMCRAID) {
273 first_id = GENL_ID_PMCRAID;
274 BUG_ON(n_groups != 1);
275 } else {
276 groups_allocated = true;
277 err = genl_allocate_reserve_groups(n_groups, &first_id);
278 if (err)
279 return err;
280 }
281
282 family->mcgrp_offset = first_id;
283
284
285 if (!init_net.genl_sock)
286 return 0;
287
288 if (family->netnsok) {
289 struct net *net;
290
291 netlink_table_grab();
292 rcu_read_lock();
293 for_each_net_rcu(net) {
294 err = __netlink_change_ngroups(net->genl_sock,
295 mc_groups_longs * BITS_PER_LONG);
296 if (err) {
297
298
299
300
301
302
303 break;
304 }
305 }
306 rcu_read_unlock();
307 netlink_table_ungrab();
308 } else {
309 err = netlink_change_ngroups(init_net.genl_sock,
310 mc_groups_longs * BITS_PER_LONG);
311 }
312
313 if (groups_allocated && err) {
314 for (i = 0; i < family->n_mcgrps; i++)
315 clear_bit(family->mcgrp_offset + i, mc_groups);
316 }
317
318 return err;
319}
320
321static void genl_unregister_mc_groups(const struct genl_family *family)
322{
323 struct net *net;
324 int i;
325
326 netlink_table_grab();
327 rcu_read_lock();
328 for_each_net_rcu(net) {
329 for (i = 0; i < family->n_mcgrps; i++)
330 __netlink_clear_multicast_users(
331 net->genl_sock, family->mcgrp_offset + i);
332 }
333 rcu_read_unlock();
334 netlink_table_ungrab();
335
336 for (i = 0; i < family->n_mcgrps; i++) {
337 int grp_id = family->mcgrp_offset + i;
338
339 if (grp_id != 1)
340 clear_bit(grp_id, mc_groups);
341 genl_ctrl_event(CTRL_CMD_DELMCAST_GRP, family,
342 &family->mcgrps[i], grp_id);
343 }
344}
345
346static int genl_validate_ops(const struct genl_family *family)
347{
348 int i, j;
349
350 if (WARN_ON(family->n_ops && !family->ops) ||
351 WARN_ON(family->n_small_ops && !family->small_ops))
352 return -EINVAL;
353
354 for (i = 0; i < genl_get_cmd_cnt(family); i++) {
355 struct genl_ops op;
356
357 genl_get_cmd_by_index(i, family, &op);
358 if (op.dumpit == NULL && op.doit == NULL)
359 return -EINVAL;
360 for (j = i + 1; j < genl_get_cmd_cnt(family); j++) {
361 struct genl_ops op2;
362
363 genl_get_cmd_by_index(j, family, &op2);
364 if (op.cmd == op2.cmd)
365 return -EINVAL;
366 }
367 }
368
369 return 0;
370}
371
372
373
374
375
376
377
378
379
380
381
382
383
384int genl_register_family(struct genl_family *family)
385{
386 int err, i;
387 int start = GENL_START_ALLOC, end = GENL_MAX_ID;
388
389 err = genl_validate_ops(family);
390 if (err)
391 return err;
392
393 genl_lock_all();
394
395 if (genl_family_find_byname(family->name)) {
396 err = -EEXIST;
397 goto errout_locked;
398 }
399
400
401
402
403
404
405
406
407 if (family == &genl_ctrl) {
408
409 start = end = GENL_ID_CTRL;
410 } else if (strcmp(family->name, "pmcraid") == 0) {
411 start = end = GENL_ID_PMCRAID;
412 } else if (strcmp(family->name, "VFS_DQUOT") == 0) {
413 start = end = GENL_ID_VFS_DQUOT;
414 }
415
416 family->id = idr_alloc_cyclic(&genl_fam_idr, family,
417 start, end + 1, GFP_KERNEL);
418 if (family->id < 0) {
419 err = family->id;
420 goto errout_locked;
421 }
422
423 err = genl_validate_assign_mc_groups(family);
424 if (err)
425 goto errout_remove;
426
427 genl_unlock_all();
428
429
430 genl_ctrl_event(CTRL_CMD_NEWFAMILY, family, NULL, 0);
431 for (i = 0; i < family->n_mcgrps; i++)
432 genl_ctrl_event(CTRL_CMD_NEWMCAST_GRP, family,
433 &family->mcgrps[i], family->mcgrp_offset + i);
434
435 return 0;
436
437errout_remove:
438 idr_remove(&genl_fam_idr, family->id);
439errout_locked:
440 genl_unlock_all();
441 return err;
442}
443EXPORT_SYMBOL(genl_register_family);
444
445
446
447
448
449
450
451
452
453int genl_unregister_family(const struct genl_family *family)
454{
455 genl_lock_all();
456
457 if (!genl_family_find_byid(family->id)) {
458 genl_unlock_all();
459 return -ENOENT;
460 }
461
462 genl_unregister_mc_groups(family);
463
464 idr_remove(&genl_fam_idr, family->id);
465
466 up_write(&cb_lock);
467 wait_event(genl_sk_destructing_waitq,
468 atomic_read(&genl_sk_destructing_cnt) == 0);
469 genl_unlock();
470
471 genl_ctrl_event(CTRL_CMD_DELFAMILY, family, NULL, 0);
472
473 return 0;
474}
475EXPORT_SYMBOL(genl_unregister_family);
476
477
478
479
480
481
482
483
484
485
486
487
488void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq,
489 const struct genl_family *family, int flags, u8 cmd)
490{
491 struct nlmsghdr *nlh;
492 struct genlmsghdr *hdr;
493
494 nlh = nlmsg_put(skb, portid, seq, family->id, GENL_HDRLEN +
495 family->hdrsize, flags);
496 if (nlh == NULL)
497 return NULL;
498
499 hdr = nlmsg_data(nlh);
500 hdr->cmd = cmd;
501 hdr->version = family->version;
502 hdr->reserved = 0;
503
504 return (char *) hdr + GENL_HDRLEN;
505}
506EXPORT_SYMBOL(genlmsg_put);
507
508static struct genl_dumpit_info *genl_dumpit_info_alloc(void)
509{
510 return kmalloc(sizeof(struct genl_dumpit_info), GFP_KERNEL);
511}
512
513static void genl_dumpit_info_free(const struct genl_dumpit_info *info)
514{
515 kfree(info);
516}
517
518static struct nlattr **
519genl_family_rcv_msg_attrs_parse(const struct genl_family *family,
520 struct nlmsghdr *nlh,
521 struct netlink_ext_ack *extack,
522 const struct genl_ops *ops,
523 int hdrlen,
524 enum genl_validate_flags no_strict_flag)
525{
526 enum netlink_validation validate = ops->validate & no_strict_flag ?
527 NL_VALIDATE_LIBERAL :
528 NL_VALIDATE_STRICT;
529 struct nlattr **attrbuf;
530 int err;
531
532 if (!ops->maxattr)
533 return NULL;
534
535 attrbuf = kmalloc_array(ops->maxattr + 1,
536 sizeof(struct nlattr *), GFP_KERNEL);
537 if (!attrbuf)
538 return ERR_PTR(-ENOMEM);
539
540 err = __nlmsg_parse(nlh, hdrlen, attrbuf, ops->maxattr, ops->policy,
541 validate, extack);
542 if (err) {
543 kfree(attrbuf);
544 return ERR_PTR(err);
545 }
546 return attrbuf;
547}
548
549static void genl_family_rcv_msg_attrs_free(struct nlattr **attrbuf)
550{
551 kfree(attrbuf);
552}
553
554struct genl_start_context {
555 const struct genl_family *family;
556 struct nlmsghdr *nlh;
557 struct netlink_ext_ack *extack;
558 const struct genl_ops *ops;
559 int hdrlen;
560};
561
562static int genl_start(struct netlink_callback *cb)
563{
564 struct genl_start_context *ctx = cb->data;
565 const struct genl_ops *ops = ctx->ops;
566 struct genl_dumpit_info *info;
567 struct nlattr **attrs = NULL;
568 int rc = 0;
569
570 if (ops->validate & GENL_DONT_VALIDATE_DUMP)
571 goto no_attrs;
572
573 if (ctx->nlh->nlmsg_len < nlmsg_msg_size(ctx->hdrlen))
574 return -EINVAL;
575
576 attrs = genl_family_rcv_msg_attrs_parse(ctx->family, ctx->nlh, ctx->extack,
577 ops, ctx->hdrlen,
578 GENL_DONT_VALIDATE_DUMP_STRICT);
579 if (IS_ERR(attrs))
580 return PTR_ERR(attrs);
581
582no_attrs:
583 info = genl_dumpit_info_alloc();
584 if (!info) {
585 genl_family_rcv_msg_attrs_free(attrs);
586 return -ENOMEM;
587 }
588 info->family = ctx->family;
589 info->op = *ops;
590 info->attrs = attrs;
591
592 cb->data = info;
593 if (ops->start) {
594 if (!ctx->family->parallel_ops)
595 genl_lock();
596 rc = ops->start(cb);
597 if (!ctx->family->parallel_ops)
598 genl_unlock();
599 }
600
601 if (rc) {
602 genl_family_rcv_msg_attrs_free(info->attrs);
603 genl_dumpit_info_free(info);
604 cb->data = NULL;
605 }
606 return rc;
607}
608
609static int genl_lock_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
610{
611 const struct genl_ops *ops = &genl_dumpit_info(cb)->op;
612 int rc;
613
614 genl_lock();
615 rc = ops->dumpit(skb, cb);
616 genl_unlock();
617 return rc;
618}
619
620static int genl_lock_done(struct netlink_callback *cb)
621{
622 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
623 const struct genl_ops *ops = &info->op;
624 int rc = 0;
625
626 if (ops->done) {
627 genl_lock();
628 rc = ops->done(cb);
629 genl_unlock();
630 }
631 genl_family_rcv_msg_attrs_free(info->attrs);
632 genl_dumpit_info_free(info);
633 return rc;
634}
635
636static int genl_parallel_done(struct netlink_callback *cb)
637{
638 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
639 const struct genl_ops *ops = &info->op;
640 int rc = 0;
641
642 if (ops->done)
643 rc = ops->done(cb);
644 genl_family_rcv_msg_attrs_free(info->attrs);
645 genl_dumpit_info_free(info);
646 return rc;
647}
648
649static int genl_family_rcv_msg_dumpit(const struct genl_family *family,
650 struct sk_buff *skb,
651 struct nlmsghdr *nlh,
652 struct netlink_ext_ack *extack,
653 const struct genl_ops *ops,
654 int hdrlen, struct net *net)
655{
656 struct genl_start_context ctx;
657 int err;
658
659 if (!ops->dumpit)
660 return -EOPNOTSUPP;
661
662 ctx.family = family;
663 ctx.nlh = nlh;
664 ctx.extack = extack;
665 ctx.ops = ops;
666 ctx.hdrlen = hdrlen;
667
668 if (!family->parallel_ops) {
669 struct netlink_dump_control c = {
670 .module = family->module,
671 .data = &ctx,
672 .start = genl_start,
673 .dump = genl_lock_dumpit,
674 .done = genl_lock_done,
675 };
676
677 genl_unlock();
678 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
679 genl_lock();
680 } else {
681 struct netlink_dump_control c = {
682 .module = family->module,
683 .data = &ctx,
684 .start = genl_start,
685 .dump = ops->dumpit,
686 .done = genl_parallel_done,
687 };
688
689 err = __netlink_dump_start(net->genl_sock, skb, nlh, &c);
690 }
691
692 return err;
693}
694
695static int genl_family_rcv_msg_doit(const struct genl_family *family,
696 struct sk_buff *skb,
697 struct nlmsghdr *nlh,
698 struct netlink_ext_ack *extack,
699 const struct genl_ops *ops,
700 int hdrlen, struct net *net)
701{
702 struct nlattr **attrbuf;
703 struct genl_info info;
704 int err;
705
706 if (!ops->doit)
707 return -EOPNOTSUPP;
708
709 attrbuf = genl_family_rcv_msg_attrs_parse(family, nlh, extack,
710 ops, hdrlen,
711 GENL_DONT_VALIDATE_STRICT);
712 if (IS_ERR(attrbuf))
713 return PTR_ERR(attrbuf);
714
715 info.snd_seq = nlh->nlmsg_seq;
716 info.snd_portid = NETLINK_CB(skb).portid;
717 info.nlhdr = nlh;
718 info.genlhdr = nlmsg_data(nlh);
719 info.userhdr = nlmsg_data(nlh) + GENL_HDRLEN;
720 info.attrs = attrbuf;
721 info.extack = extack;
722 genl_info_net_set(&info, net);
723 memset(&info.user_ptr, 0, sizeof(info.user_ptr));
724
725 if (family->pre_doit) {
726 err = family->pre_doit(ops, skb, &info);
727 if (err)
728 goto out;
729 }
730
731 err = ops->doit(skb, &info);
732
733 if (family->post_doit)
734 family->post_doit(ops, skb, &info);
735
736out:
737 genl_family_rcv_msg_attrs_free(attrbuf);
738
739 return err;
740}
741
742static int genl_family_rcv_msg(const struct genl_family *family,
743 struct sk_buff *skb,
744 struct nlmsghdr *nlh,
745 struct netlink_ext_ack *extack)
746{
747 struct net *net = sock_net(skb->sk);
748 struct genlmsghdr *hdr = nlmsg_data(nlh);
749 struct genl_ops op;
750 int hdrlen;
751
752
753 if (!family->netnsok && !net_eq(net, &init_net))
754 return -ENOENT;
755
756 hdrlen = GENL_HDRLEN + family->hdrsize;
757 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen))
758 return -EINVAL;
759
760 if (genl_get_cmd(hdr->cmd, family, &op))
761 return -EOPNOTSUPP;
762
763 if ((op.flags & GENL_ADMIN_PERM) &&
764 !netlink_capable(skb, CAP_NET_ADMIN))
765 return -EPERM;
766
767 if ((op.flags & GENL_UNS_ADMIN_PERM) &&
768 !netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN))
769 return -EPERM;
770
771 if ((nlh->nlmsg_flags & NLM_F_DUMP) == NLM_F_DUMP)
772 return genl_family_rcv_msg_dumpit(family, skb, nlh, extack,
773 &op, hdrlen, net);
774 else
775 return genl_family_rcv_msg_doit(family, skb, nlh, extack,
776 &op, hdrlen, net);
777}
778
779static int genl_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
780 struct netlink_ext_ack *extack)
781{
782 const struct genl_family *family;
783 int err;
784
785 family = genl_family_find_byid(nlh->nlmsg_type);
786 if (family == NULL)
787 return -ENOENT;
788
789 if (!family->parallel_ops)
790 genl_lock();
791
792 err = genl_family_rcv_msg(family, skb, nlh, extack);
793
794 if (!family->parallel_ops)
795 genl_unlock();
796
797 return err;
798}
799
800static void genl_rcv(struct sk_buff *skb)
801{
802 down_read(&cb_lock);
803 netlink_rcv_skb(skb, &genl_rcv_msg);
804 up_read(&cb_lock);
805}
806
807
808
809
810
811static struct genl_family genl_ctrl;
812
813static int ctrl_fill_info(const struct genl_family *family, u32 portid, u32 seq,
814 u32 flags, struct sk_buff *skb, u8 cmd)
815{
816 void *hdr;
817
818 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
819 if (hdr == NULL)
820 return -1;
821
822 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
823 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id) ||
824 nla_put_u32(skb, CTRL_ATTR_VERSION, family->version) ||
825 nla_put_u32(skb, CTRL_ATTR_HDRSIZE, family->hdrsize) ||
826 nla_put_u32(skb, CTRL_ATTR_MAXATTR, family->maxattr))
827 goto nla_put_failure;
828
829 if (genl_get_cmd_cnt(family)) {
830 struct nlattr *nla_ops;
831 int i;
832
833 nla_ops = nla_nest_start_noflag(skb, CTRL_ATTR_OPS);
834 if (nla_ops == NULL)
835 goto nla_put_failure;
836
837 for (i = 0; i < genl_get_cmd_cnt(family); i++) {
838 struct nlattr *nest;
839 struct genl_ops op;
840 u32 op_flags;
841
842 genl_get_cmd_by_index(i, family, &op);
843 op_flags = op.flags;
844 if (op.dumpit)
845 op_flags |= GENL_CMD_CAP_DUMP;
846 if (op.doit)
847 op_flags |= GENL_CMD_CAP_DO;
848 if (op.policy)
849 op_flags |= GENL_CMD_CAP_HASPOL;
850
851 nest = nla_nest_start_noflag(skb, i + 1);
852 if (nest == NULL)
853 goto nla_put_failure;
854
855 if (nla_put_u32(skb, CTRL_ATTR_OP_ID, op.cmd) ||
856 nla_put_u32(skb, CTRL_ATTR_OP_FLAGS, op_flags))
857 goto nla_put_failure;
858
859 nla_nest_end(skb, nest);
860 }
861
862 nla_nest_end(skb, nla_ops);
863 }
864
865 if (family->n_mcgrps) {
866 struct nlattr *nla_grps;
867 int i;
868
869 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
870 if (nla_grps == NULL)
871 goto nla_put_failure;
872
873 for (i = 0; i < family->n_mcgrps; i++) {
874 struct nlattr *nest;
875 const struct genl_multicast_group *grp;
876
877 grp = &family->mcgrps[i];
878
879 nest = nla_nest_start_noflag(skb, i + 1);
880 if (nest == NULL)
881 goto nla_put_failure;
882
883 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID,
884 family->mcgrp_offset + i) ||
885 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
886 grp->name))
887 goto nla_put_failure;
888
889 nla_nest_end(skb, nest);
890 }
891 nla_nest_end(skb, nla_grps);
892 }
893
894 genlmsg_end(skb, hdr);
895 return 0;
896
897nla_put_failure:
898 genlmsg_cancel(skb, hdr);
899 return -EMSGSIZE;
900}
901
902static int ctrl_fill_mcgrp_info(const struct genl_family *family,
903 const struct genl_multicast_group *grp,
904 int grp_id, u32 portid, u32 seq, u32 flags,
905 struct sk_buff *skb, u8 cmd)
906{
907 void *hdr;
908 struct nlattr *nla_grps;
909 struct nlattr *nest;
910
911 hdr = genlmsg_put(skb, portid, seq, &genl_ctrl, flags, cmd);
912 if (hdr == NULL)
913 return -1;
914
915 if (nla_put_string(skb, CTRL_ATTR_FAMILY_NAME, family->name) ||
916 nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, family->id))
917 goto nla_put_failure;
918
919 nla_grps = nla_nest_start_noflag(skb, CTRL_ATTR_MCAST_GROUPS);
920 if (nla_grps == NULL)
921 goto nla_put_failure;
922
923 nest = nla_nest_start_noflag(skb, 1);
924 if (nest == NULL)
925 goto nla_put_failure;
926
927 if (nla_put_u32(skb, CTRL_ATTR_MCAST_GRP_ID, grp_id) ||
928 nla_put_string(skb, CTRL_ATTR_MCAST_GRP_NAME,
929 grp->name))
930 goto nla_put_failure;
931
932 nla_nest_end(skb, nest);
933 nla_nest_end(skb, nla_grps);
934
935 genlmsg_end(skb, hdr);
936 return 0;
937
938nla_put_failure:
939 genlmsg_cancel(skb, hdr);
940 return -EMSGSIZE;
941}
942
943static int ctrl_dumpfamily(struct sk_buff *skb, struct netlink_callback *cb)
944{
945 int n = 0;
946 struct genl_family *rt;
947 struct net *net = sock_net(skb->sk);
948 int fams_to_skip = cb->args[0];
949 unsigned int id;
950
951 idr_for_each_entry(&genl_fam_idr, rt, id) {
952 if (!rt->netnsok && !net_eq(net, &init_net))
953 continue;
954
955 if (n++ < fams_to_skip)
956 continue;
957
958 if (ctrl_fill_info(rt, NETLINK_CB(cb->skb).portid,
959 cb->nlh->nlmsg_seq, NLM_F_MULTI,
960 skb, CTRL_CMD_NEWFAMILY) < 0) {
961 n--;
962 break;
963 }
964 }
965
966 cb->args[0] = n;
967 return skb->len;
968}
969
970static struct sk_buff *ctrl_build_family_msg(const struct genl_family *family,
971 u32 portid, int seq, u8 cmd)
972{
973 struct sk_buff *skb;
974 int err;
975
976 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
977 if (skb == NULL)
978 return ERR_PTR(-ENOBUFS);
979
980 err = ctrl_fill_info(family, portid, seq, 0, skb, cmd);
981 if (err < 0) {
982 nlmsg_free(skb);
983 return ERR_PTR(err);
984 }
985
986 return skb;
987}
988
989static struct sk_buff *
990ctrl_build_mcgrp_msg(const struct genl_family *family,
991 const struct genl_multicast_group *grp,
992 int grp_id, u32 portid, int seq, u8 cmd)
993{
994 struct sk_buff *skb;
995 int err;
996
997 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
998 if (skb == NULL)
999 return ERR_PTR(-ENOBUFS);
1000
1001 err = ctrl_fill_mcgrp_info(family, grp, grp_id, portid,
1002 seq, 0, skb, cmd);
1003 if (err < 0) {
1004 nlmsg_free(skb);
1005 return ERR_PTR(err);
1006 }
1007
1008 return skb;
1009}
1010
1011static const struct nla_policy ctrl_policy_family[] = {
1012 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
1013 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
1014 .len = GENL_NAMSIZ - 1 },
1015};
1016
1017static int ctrl_getfamily(struct sk_buff *skb, struct genl_info *info)
1018{
1019 struct sk_buff *msg;
1020 const struct genl_family *res = NULL;
1021 int err = -EINVAL;
1022
1023 if (info->attrs[CTRL_ATTR_FAMILY_ID]) {
1024 u16 id = nla_get_u16(info->attrs[CTRL_ATTR_FAMILY_ID]);
1025 res = genl_family_find_byid(id);
1026 err = -ENOENT;
1027 }
1028
1029 if (info->attrs[CTRL_ATTR_FAMILY_NAME]) {
1030 char *name;
1031
1032 name = nla_data(info->attrs[CTRL_ATTR_FAMILY_NAME]);
1033 res = genl_family_find_byname(name);
1034#ifdef CONFIG_MODULES
1035 if (res == NULL) {
1036 genl_unlock();
1037 up_read(&cb_lock);
1038 request_module("net-pf-%d-proto-%d-family-%s",
1039 PF_NETLINK, NETLINK_GENERIC, name);
1040 down_read(&cb_lock);
1041 genl_lock();
1042 res = genl_family_find_byname(name);
1043 }
1044#endif
1045 err = -ENOENT;
1046 }
1047
1048 if (res == NULL)
1049 return err;
1050
1051 if (!res->netnsok && !net_eq(genl_info_net(info), &init_net)) {
1052
1053 return -ENOENT;
1054 }
1055
1056 msg = ctrl_build_family_msg(res, info->snd_portid, info->snd_seq,
1057 CTRL_CMD_NEWFAMILY);
1058 if (IS_ERR(msg))
1059 return PTR_ERR(msg);
1060
1061 return genlmsg_reply(msg, info);
1062}
1063
1064static int genl_ctrl_event(int event, const struct genl_family *family,
1065 const struct genl_multicast_group *grp,
1066 int grp_id)
1067{
1068 struct sk_buff *msg;
1069
1070
1071 if (!init_net.genl_sock)
1072 return 0;
1073
1074 switch (event) {
1075 case CTRL_CMD_NEWFAMILY:
1076 case CTRL_CMD_DELFAMILY:
1077 WARN_ON(grp);
1078 msg = ctrl_build_family_msg(family, 0, 0, event);
1079 break;
1080 case CTRL_CMD_NEWMCAST_GRP:
1081 case CTRL_CMD_DELMCAST_GRP:
1082 BUG_ON(!grp);
1083 msg = ctrl_build_mcgrp_msg(family, grp, grp_id, 0, 0, event);
1084 break;
1085 default:
1086 return -EINVAL;
1087 }
1088
1089 if (IS_ERR(msg))
1090 return PTR_ERR(msg);
1091
1092 if (!family->netnsok) {
1093 genlmsg_multicast_netns(&genl_ctrl, &init_net, msg, 0,
1094 0, GFP_KERNEL);
1095 } else {
1096 rcu_read_lock();
1097 genlmsg_multicast_allns(&genl_ctrl, msg, 0,
1098 0, GFP_ATOMIC);
1099 rcu_read_unlock();
1100 }
1101
1102 return 0;
1103}
1104
1105struct ctrl_dump_policy_ctx {
1106 struct netlink_policy_dump_state *state;
1107 const struct genl_family *rt;
1108 unsigned int opidx;
1109 u32 op;
1110 u16 fam_id;
1111 u8 policies:1,
1112 single_op:1;
1113};
1114
1115static const struct nla_policy ctrl_policy_policy[] = {
1116 [CTRL_ATTR_FAMILY_ID] = { .type = NLA_U16 },
1117 [CTRL_ATTR_FAMILY_NAME] = { .type = NLA_NUL_STRING,
1118 .len = GENL_NAMSIZ - 1 },
1119 [CTRL_ATTR_OP] = { .type = NLA_U32 },
1120};
1121
1122static int ctrl_dumppolicy_start(struct netlink_callback *cb)
1123{
1124 const struct genl_dumpit_info *info = genl_dumpit_info(cb);
1125 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1126 struct nlattr **tb = info->attrs;
1127 const struct genl_family *rt;
1128 struct genl_ops op;
1129 int err, i;
1130
1131 BUILD_BUG_ON(sizeof(*ctx) > sizeof(cb->ctx));
1132
1133 if (!tb[CTRL_ATTR_FAMILY_ID] && !tb[CTRL_ATTR_FAMILY_NAME])
1134 return -EINVAL;
1135
1136 if (tb[CTRL_ATTR_FAMILY_ID]) {
1137 ctx->fam_id = nla_get_u16(tb[CTRL_ATTR_FAMILY_ID]);
1138 } else {
1139 rt = genl_family_find_byname(
1140 nla_data(tb[CTRL_ATTR_FAMILY_NAME]));
1141 if (!rt)
1142 return -ENOENT;
1143 ctx->fam_id = rt->id;
1144 }
1145
1146 rt = genl_family_find_byid(ctx->fam_id);
1147 if (!rt)
1148 return -ENOENT;
1149
1150 ctx->rt = rt;
1151
1152 if (tb[CTRL_ATTR_OP]) {
1153 ctx->single_op = true;
1154 ctx->op = nla_get_u32(tb[CTRL_ATTR_OP]);
1155
1156 err = genl_get_cmd(ctx->op, rt, &op);
1157 if (err) {
1158 NL_SET_BAD_ATTR(cb->extack, tb[CTRL_ATTR_OP]);
1159 return err;
1160 }
1161
1162 if (!op.policy)
1163 return -ENODATA;
1164
1165 return netlink_policy_dump_add_policy(&ctx->state, op.policy,
1166 op.maxattr);
1167 }
1168
1169 for (i = 0; i < genl_get_cmd_cnt(rt); i++) {
1170 genl_get_cmd_by_index(i, rt, &op);
1171
1172 if (op.policy) {
1173 err = netlink_policy_dump_add_policy(&ctx->state,
1174 op.policy,
1175 op.maxattr);
1176 if (err)
1177 return err;
1178 }
1179 }
1180
1181 if (!ctx->state)
1182 return -ENODATA;
1183 return 0;
1184}
1185
1186static void *ctrl_dumppolicy_prep(struct sk_buff *skb,
1187 struct netlink_callback *cb)
1188{
1189 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1190 void *hdr;
1191
1192 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
1193 cb->nlh->nlmsg_seq, &genl_ctrl,
1194 NLM_F_MULTI, CTRL_CMD_GETPOLICY);
1195 if (!hdr)
1196 return NULL;
1197
1198 if (nla_put_u16(skb, CTRL_ATTR_FAMILY_ID, ctx->fam_id))
1199 return NULL;
1200
1201 return hdr;
1202}
1203
1204static int ctrl_dumppolicy_put_op(struct sk_buff *skb,
1205 struct netlink_callback *cb,
1206 struct genl_ops *op)
1207{
1208 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1209 struct nlattr *nest_pol, *nest_op;
1210 void *hdr;
1211 int idx;
1212
1213
1214 if (!op->policy)
1215 return 0;
1216 if (!op->doit &&
1217 (!op->dumpit || op->validate & GENL_DONT_VALIDATE_DUMP))
1218 return 0;
1219
1220 hdr = ctrl_dumppolicy_prep(skb, cb);
1221 if (!hdr)
1222 return -ENOBUFS;
1223
1224 nest_pol = nla_nest_start(skb, CTRL_ATTR_OP_POLICY);
1225 if (!nest_pol)
1226 goto err;
1227
1228 nest_op = nla_nest_start(skb, op->cmd);
1229 if (!nest_op)
1230 goto err;
1231
1232
1233 idx = netlink_policy_dump_get_policy_idx(ctx->state,
1234 op->policy,
1235 op->maxattr);
1236
1237 if (op->doit && nla_put_u32(skb, CTRL_ATTR_POLICY_DO, idx))
1238 goto err;
1239
1240 if (op->dumpit && !(op->validate & GENL_DONT_VALIDATE_DUMP) &&
1241 nla_put_u32(skb, CTRL_ATTR_POLICY_DUMP, idx))
1242 goto err;
1243
1244 nla_nest_end(skb, nest_op);
1245 nla_nest_end(skb, nest_pol);
1246 genlmsg_end(skb, hdr);
1247
1248 return 0;
1249err:
1250 genlmsg_cancel(skb, hdr);
1251 return -ENOBUFS;
1252}
1253
1254static int ctrl_dumppolicy(struct sk_buff *skb, struct netlink_callback *cb)
1255{
1256 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1257 void *hdr;
1258
1259 if (!ctx->policies) {
1260 while (ctx->opidx < genl_get_cmd_cnt(ctx->rt)) {
1261 struct genl_ops op;
1262
1263 if (ctx->single_op) {
1264 int err;
1265
1266 err = genl_get_cmd(ctx->op, ctx->rt, &op);
1267 if (WARN_ON(err))
1268 return skb->len;
1269
1270
1271 ctx->opidx = genl_get_cmd_cnt(ctx->rt);
1272 } else {
1273 genl_get_cmd_by_index(ctx->opidx, ctx->rt, &op);
1274 }
1275
1276 if (ctrl_dumppolicy_put_op(skb, cb, &op))
1277 return skb->len;
1278
1279 ctx->opidx++;
1280 }
1281
1282
1283 ctx->policies = true;
1284 }
1285
1286 while (netlink_policy_dump_loop(ctx->state)) {
1287 struct nlattr *nest;
1288
1289 hdr = ctrl_dumppolicy_prep(skb, cb);
1290 if (!hdr)
1291 goto nla_put_failure;
1292
1293 nest = nla_nest_start(skb, CTRL_ATTR_POLICY);
1294 if (!nest)
1295 goto nla_put_failure;
1296
1297 if (netlink_policy_dump_write(skb, ctx->state))
1298 goto nla_put_failure;
1299
1300 nla_nest_end(skb, nest);
1301
1302 genlmsg_end(skb, hdr);
1303 }
1304
1305 return skb->len;
1306
1307nla_put_failure:
1308 genlmsg_cancel(skb, hdr);
1309 return skb->len;
1310}
1311
1312static int ctrl_dumppolicy_done(struct netlink_callback *cb)
1313{
1314 struct ctrl_dump_policy_ctx *ctx = (void *)cb->ctx;
1315
1316 netlink_policy_dump_free(ctx->state);
1317 return 0;
1318}
1319
1320static const struct genl_ops genl_ctrl_ops[] = {
1321 {
1322 .cmd = CTRL_CMD_GETFAMILY,
1323 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
1324 .policy = ctrl_policy_family,
1325 .maxattr = ARRAY_SIZE(ctrl_policy_family) - 1,
1326 .doit = ctrl_getfamily,
1327 .dumpit = ctrl_dumpfamily,
1328 },
1329 {
1330 .cmd = CTRL_CMD_GETPOLICY,
1331 .policy = ctrl_policy_policy,
1332 .maxattr = ARRAY_SIZE(ctrl_policy_policy) - 1,
1333 .start = ctrl_dumppolicy_start,
1334 .dumpit = ctrl_dumppolicy,
1335 .done = ctrl_dumppolicy_done,
1336 },
1337};
1338
1339static const struct genl_multicast_group genl_ctrl_groups[] = {
1340 { .name = "notify", },
1341};
1342
1343static struct genl_family genl_ctrl __ro_after_init = {
1344 .module = THIS_MODULE,
1345 .ops = genl_ctrl_ops,
1346 .n_ops = ARRAY_SIZE(genl_ctrl_ops),
1347 .mcgrps = genl_ctrl_groups,
1348 .n_mcgrps = ARRAY_SIZE(genl_ctrl_groups),
1349 .id = GENL_ID_CTRL,
1350 .name = "nlctrl",
1351 .version = 0x2,
1352 .netnsok = true,
1353};
1354
1355static int genl_bind(struct net *net, int group)
1356{
1357 const struct genl_family *family;
1358 unsigned int id;
1359 int ret = 0;
1360
1361 genl_lock_all();
1362
1363 idr_for_each_entry(&genl_fam_idr, family, id) {
1364 const struct genl_multicast_group *grp;
1365 int i;
1366
1367 if (family->n_mcgrps == 0)
1368 continue;
1369
1370 i = group - family->mcgrp_offset;
1371 if (i < 0 || i >= family->n_mcgrps)
1372 continue;
1373
1374 grp = &family->mcgrps[i];
1375 if ((grp->flags & GENL_UNS_ADMIN_PERM) &&
1376 !ns_capable(net->user_ns, CAP_NET_ADMIN))
1377 ret = -EPERM;
1378
1379 break;
1380 }
1381
1382 genl_unlock_all();
1383 return ret;
1384}
1385
1386static int __net_init genl_pernet_init(struct net *net)
1387{
1388 struct netlink_kernel_cfg cfg = {
1389 .input = genl_rcv,
1390 .flags = NL_CFG_F_NONROOT_RECV,
1391 .bind = genl_bind,
1392 };
1393
1394
1395 net->genl_sock = netlink_kernel_create(net, NETLINK_GENERIC, &cfg);
1396
1397 if (!net->genl_sock && net_eq(net, &init_net))
1398 panic("GENL: Cannot initialize generic netlink\n");
1399
1400 if (!net->genl_sock)
1401 return -ENOMEM;
1402
1403 return 0;
1404}
1405
1406static void __net_exit genl_pernet_exit(struct net *net)
1407{
1408 netlink_kernel_release(net->genl_sock);
1409 net->genl_sock = NULL;
1410}
1411
1412static struct pernet_operations genl_pernet_ops = {
1413 .init = genl_pernet_init,
1414 .exit = genl_pernet_exit,
1415};
1416
1417static int __init genl_init(void)
1418{
1419 int err;
1420
1421 err = genl_register_family(&genl_ctrl);
1422 if (err < 0)
1423 goto problem;
1424
1425 err = register_pernet_subsys(&genl_pernet_ops);
1426 if (err)
1427 goto problem;
1428
1429 return 0;
1430
1431problem:
1432 panic("GENL: Cannot register controller: %d\n", err);
1433}
1434
1435core_initcall(genl_init);
1436
1437static int genlmsg_mcast(struct sk_buff *skb, u32 portid, unsigned long group,
1438 gfp_t flags)
1439{
1440 struct sk_buff *tmp;
1441 struct net *net, *prev = NULL;
1442 bool delivered = false;
1443 int err;
1444
1445 for_each_net_rcu(net) {
1446 if (prev) {
1447 tmp = skb_clone(skb, flags);
1448 if (!tmp) {
1449 err = -ENOMEM;
1450 goto error;
1451 }
1452 err = nlmsg_multicast(prev->genl_sock, tmp,
1453 portid, group, flags);
1454 if (!err)
1455 delivered = true;
1456 else if (err != -ESRCH)
1457 goto error;
1458 }
1459
1460 prev = net;
1461 }
1462
1463 err = nlmsg_multicast(prev->genl_sock, skb, portid, group, flags);
1464 if (!err)
1465 delivered = true;
1466 else if (err != -ESRCH)
1467 return err;
1468 return delivered ? 0 : -ESRCH;
1469 error:
1470 kfree_skb(skb);
1471 return err;
1472}
1473
1474int genlmsg_multicast_allns(const struct genl_family *family,
1475 struct sk_buff *skb, u32 portid,
1476 unsigned int group, gfp_t flags)
1477{
1478 if (WARN_ON_ONCE(group >= family->n_mcgrps))
1479 return -EINVAL;
1480
1481 group = family->mcgrp_offset + group;
1482 return genlmsg_mcast(skb, portid, group, flags);
1483}
1484EXPORT_SYMBOL(genlmsg_multicast_allns);
1485
1486void genl_notify(const struct genl_family *family, struct sk_buff *skb,
1487 struct genl_info *info, u32 group, gfp_t flags)
1488{
1489 struct net *net = genl_info_net(info);
1490 struct sock *sk = net->genl_sock;
1491
1492 if (WARN_ON_ONCE(group >= family->n_mcgrps))
1493 return;
1494
1495 group = family->mcgrp_offset + group;
1496 nlmsg_notify(sk, skb, info->snd_portid, group,
1497 nlmsg_report(info->nlhdr), flags);
1498}
1499EXPORT_SYMBOL(genl_notify);
1500
