1
2#include <linux/err.h>
3#include <linux/igmp.h>
4#include <linux/kernel.h>
5#include <linux/netdevice.h>
6#include <linux/rculist.h>
7#include <linux/skbuff.h>
8#include <linux/if_ether.h>
9#include <net/ip.h>
10#include <net/netlink.h>
11#include <net/switchdev.h>
12#if IS_ENABLED(CONFIG_IPV6)
13#include <net/ipv6.h>
14#include <net/addrconf.h>
15#endif
16
17#include "br_private.h"
18
19static int br_rports_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
20 struct net_device *dev)
21{
22 struct net_bridge *br = netdev_priv(dev);
23 struct net_bridge_port *p;
24 struct nlattr *nest, *port_nest;
25
26 if (!br->multicast_router || hlist_empty(&br->router_list))
27 return 0;
28
29 nest = nla_nest_start_noflag(skb, MDBA_ROUTER);
30 if (nest == NULL)
31 return -EMSGSIZE;
32
33 hlist_for_each_entry_rcu(p, &br->router_list, rlist) {
34 if (!p)
35 continue;
36 port_nest = nla_nest_start_noflag(skb, MDBA_ROUTER_PORT);
37 if (!port_nest)
38 goto fail;
39 if (nla_put_nohdr(skb, sizeof(u32), &p->dev->ifindex) ||
40 nla_put_u32(skb, MDBA_ROUTER_PATTR_TIMER,
41 br_timer_value(&p->multicast_router_timer)) ||
42 nla_put_u8(skb, MDBA_ROUTER_PATTR_TYPE,
43 p->multicast_router)) {
44 nla_nest_cancel(skb, port_nest);
45 goto fail;
46 }
47 nla_nest_end(skb, port_nest);
48 }
49
50 nla_nest_end(skb, nest);
51 return 0;
52fail:
53 nla_nest_cancel(skb, nest);
54 return -EMSGSIZE;
55}
56
57static void __mdb_entry_fill_flags(struct br_mdb_entry *e, unsigned char flags)
58{
59 e->state = flags & MDB_PG_FLAGS_PERMANENT;
60 e->flags = 0;
61 if (flags & MDB_PG_FLAGS_OFFLOAD)
62 e->flags |= MDB_FLAGS_OFFLOAD;
63 if (flags & MDB_PG_FLAGS_FAST_LEAVE)
64 e->flags |= MDB_FLAGS_FAST_LEAVE;
65 if (flags & MDB_PG_FLAGS_STAR_EXCL)
66 e->flags |= MDB_FLAGS_STAR_EXCL;
67 if (flags & MDB_PG_FLAGS_BLOCKED)
68 e->flags |= MDB_FLAGS_BLOCKED;
69}
70
71static void __mdb_entry_to_br_ip(struct br_mdb_entry *entry, struct br_ip *ip,
72 struct nlattr **mdb_attrs)
73{
74 memset(ip, 0, sizeof(struct br_ip));
75 ip->vid = entry->vid;
76 ip->proto = entry->addr.proto;
77 switch (ip->proto) {
78 case htons(ETH_P_IP):
79 ip->dst.ip4 = entry->addr.u.ip4;
80 if (mdb_attrs && mdb_attrs[MDBE_ATTR_SOURCE])
81 ip->src.ip4 = nla_get_in_addr(mdb_attrs[MDBE_ATTR_SOURCE]);
82 break;
83#if IS_ENABLED(CONFIG_IPV6)
84 case htons(ETH_P_IPV6):
85 ip->dst.ip6 = entry->addr.u.ip6;
86 if (mdb_attrs && mdb_attrs[MDBE_ATTR_SOURCE])
87 ip->src.ip6 = nla_get_in6_addr(mdb_attrs[MDBE_ATTR_SOURCE]);
88 break;
89#endif
90 }
91
92}
93
94static int __mdb_fill_srcs(struct sk_buff *skb,
95 struct net_bridge_port_group *p)
96{
97 struct net_bridge_group_src *ent;
98 struct nlattr *nest, *nest_ent;
99
100 if (hlist_empty(&p->src_list))
101 return 0;
102
103 nest = nla_nest_start(skb, MDBA_MDB_EATTR_SRC_LIST);
104 if (!nest)
105 return -EMSGSIZE;
106
107 hlist_for_each_entry_rcu(ent, &p->src_list, node,
108 lockdep_is_held(&p->key.port->br->multicast_lock)) {
109 nest_ent = nla_nest_start(skb, MDBA_MDB_SRCLIST_ENTRY);
110 if (!nest_ent)
111 goto out_cancel_err;
112 switch (ent->addr.proto) {
113 case htons(ETH_P_IP):
114 if (nla_put_in_addr(skb, MDBA_MDB_SRCATTR_ADDRESS,
115 ent->addr.src.ip4)) {
116 nla_nest_cancel(skb, nest_ent);
117 goto out_cancel_err;
118 }
119 break;
120#if IS_ENABLED(CONFIG_IPV6)
121 case htons(ETH_P_IPV6):
122 if (nla_put_in6_addr(skb, MDBA_MDB_SRCATTR_ADDRESS,
123 &ent->addr.src.ip6)) {
124 nla_nest_cancel(skb, nest_ent);
125 goto out_cancel_err;
126 }
127 break;
128#endif
129 default:
130 nla_nest_cancel(skb, nest_ent);
131 continue;
132 }
133 if (nla_put_u32(skb, MDBA_MDB_SRCATTR_TIMER,
134 br_timer_value(&ent->timer))) {
135 nla_nest_cancel(skb, nest_ent);
136 goto out_cancel_err;
137 }
138 nla_nest_end(skb, nest_ent);
139 }
140
141 nla_nest_end(skb, nest);
142
143 return 0;
144
145out_cancel_err:
146 nla_nest_cancel(skb, nest);
147 return -EMSGSIZE;
148}
149
150static int __mdb_fill_info(struct sk_buff *skb,
151 struct net_bridge_mdb_entry *mp,
152 struct net_bridge_port_group *p)
153{
154 bool dump_srcs_mode = false;
155 struct timer_list *mtimer;
156 struct nlattr *nest_ent;
157 struct br_mdb_entry e;
158 u8 flags = 0;
159 int ifindex;
160
161 memset(&e, 0, sizeof(e));
162 if (p) {
163 ifindex = p->key.port->dev->ifindex;
164 mtimer = &p->timer;
165 flags = p->flags;
166 } else {
167 ifindex = mp->br->dev->ifindex;
168 mtimer = &mp->timer;
169 }
170
171 __mdb_entry_fill_flags(&e, flags);
172 e.ifindex = ifindex;
173 e.vid = mp->addr.vid;
174 if (mp->addr.proto == htons(ETH_P_IP))
175 e.addr.u.ip4 = mp->addr.dst.ip4;
176#if IS_ENABLED(CONFIG_IPV6)
177 if (mp->addr.proto == htons(ETH_P_IPV6))
178 e.addr.u.ip6 = mp->addr.dst.ip6;
179#endif
180 e.addr.proto = mp->addr.proto;
181 nest_ent = nla_nest_start_noflag(skb,
182 MDBA_MDB_ENTRY_INFO);
183 if (!nest_ent)
184 return -EMSGSIZE;
185
186 if (nla_put_nohdr(skb, sizeof(e), &e) ||
187 nla_put_u32(skb,
188 MDBA_MDB_EATTR_TIMER,
189 br_timer_value(mtimer)))
190 goto nest_err;
191
192 switch (mp->addr.proto) {
193 case htons(ETH_P_IP):
194 dump_srcs_mode = !!(mp->br->multicast_igmp_version == 3);
195 if (mp->addr.src.ip4) {
196 if (nla_put_in_addr(skb, MDBA_MDB_EATTR_SOURCE,
197 mp->addr.src.ip4))
198 goto nest_err;
199 break;
200 }
201 break;
202#if IS_ENABLED(CONFIG_IPV6)
203 case htons(ETH_P_IPV6):
204 dump_srcs_mode = !!(mp->br->multicast_mld_version == 2);
205 if (!ipv6_addr_any(&mp->addr.src.ip6)) {
206 if (nla_put_in6_addr(skb, MDBA_MDB_EATTR_SOURCE,
207 &mp->addr.src.ip6))
208 goto nest_err;
209 break;
210 }
211 break;
212#endif
213 }
214 if (p) {
215 if (nla_put_u8(skb, MDBA_MDB_EATTR_RTPROT, p->rt_protocol))
216 goto nest_err;
217 if (dump_srcs_mode &&
218 (__mdb_fill_srcs(skb, p) ||
219 nla_put_u8(skb, MDBA_MDB_EATTR_GROUP_MODE,
220 p->filter_mode)))
221 goto nest_err;
222 }
223 nla_nest_end(skb, nest_ent);
224
225 return 0;
226
227nest_err:
228 nla_nest_cancel(skb, nest_ent);
229 return -EMSGSIZE;
230}
231
232static int br_mdb_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
233 struct net_device *dev)
234{
235 int idx = 0, s_idx = cb->args[1], err = 0, pidx = 0, s_pidx = cb->args[2];
236 struct net_bridge *br = netdev_priv(dev);
237 struct net_bridge_mdb_entry *mp;
238 struct nlattr *nest, *nest2;
239
240 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
241 return 0;
242
243 nest = nla_nest_start_noflag(skb, MDBA_MDB);
244 if (nest == NULL)
245 return -EMSGSIZE;
246
247 hlist_for_each_entry_rcu(mp, &br->mdb_list, mdb_node) {
248 struct net_bridge_port_group *p;
249 struct net_bridge_port_group __rcu **pp;
250
251 if (idx < s_idx)
252 goto skip;
253
254 nest2 = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
255 if (!nest2) {
256 err = -EMSGSIZE;
257 break;
258 }
259
260 if (!s_pidx && mp->host_joined) {
261 err = __mdb_fill_info(skb, mp, NULL);
262 if (err) {
263 nla_nest_cancel(skb, nest2);
264 break;
265 }
266 }
267
268 for (pp = &mp->ports; (p = rcu_dereference(*pp)) != NULL;
269 pp = &p->next) {
270 if (!p->key.port)
271 continue;
272 if (pidx < s_pidx)
273 goto skip_pg;
274
275 err = __mdb_fill_info(skb, mp, p);
276 if (err) {
277 nla_nest_end(skb, nest2);
278 goto out;
279 }
280skip_pg:
281 pidx++;
282 }
283 pidx = 0;
284 s_pidx = 0;
285 nla_nest_end(skb, nest2);
286skip:
287 idx++;
288 }
289
290out:
291 cb->args[1] = idx;
292 cb->args[2] = pidx;
293 nla_nest_end(skb, nest);
294 return err;
295}
296
297static int br_mdb_valid_dump_req(const struct nlmsghdr *nlh,
298 struct netlink_ext_ack *extack)
299{
300 struct br_port_msg *bpm;
301
302 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*bpm))) {
303 NL_SET_ERR_MSG_MOD(extack, "Invalid header for mdb dump request");
304 return -EINVAL;
305 }
306
307 bpm = nlmsg_data(nlh);
308 if (bpm->ifindex) {
309 NL_SET_ERR_MSG_MOD(extack, "Filtering by device index is not supported for mdb dump request");
310 return -EINVAL;
311 }
312 if (nlmsg_attrlen(nlh, sizeof(*bpm))) {
313 NL_SET_ERR_MSG(extack, "Invalid data after header in mdb dump request");
314 return -EINVAL;
315 }
316
317 return 0;
318}
319
320static int br_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
321{
322 struct net_device *dev;
323 struct net *net = sock_net(skb->sk);
324 struct nlmsghdr *nlh = NULL;
325 int idx = 0, s_idx;
326
327 if (cb->strict_check) {
328 int err = br_mdb_valid_dump_req(cb->nlh, cb->extack);
329
330 if (err < 0)
331 return err;
332 }
333
334 s_idx = cb->args[0];
335
336 rcu_read_lock();
337
338 cb->seq = net->dev_base_seq;
339
340 for_each_netdev_rcu(net, dev) {
341 if (dev->priv_flags & IFF_EBRIDGE) {
342 struct br_port_msg *bpm;
343
344 if (idx < s_idx)
345 goto skip;
346
347 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
348 cb->nlh->nlmsg_seq, RTM_GETMDB,
349 sizeof(*bpm), NLM_F_MULTI);
350 if (nlh == NULL)
351 break;
352
353 bpm = nlmsg_data(nlh);
354 memset(bpm, 0, sizeof(*bpm));
355 bpm->ifindex = dev->ifindex;
356 if (br_mdb_fill_info(skb, cb, dev) < 0)
357 goto out;
358 if (br_rports_fill_info(skb, cb, dev) < 0)
359 goto out;
360
361 cb->args[1] = 0;
362 nlmsg_end(skb, nlh);
363 skip:
364 idx++;
365 }
366 }
367
368out:
369 if (nlh)
370 nlmsg_end(skb, nlh);
371 rcu_read_unlock();
372 cb->args[0] = idx;
373 return skb->len;
374}
375
376static int nlmsg_populate_mdb_fill(struct sk_buff *skb,
377 struct net_device *dev,
378 struct net_bridge_mdb_entry *mp,
379 struct net_bridge_port_group *pg,
380 int type)
381{
382 struct nlmsghdr *nlh;
383 struct br_port_msg *bpm;
384 struct nlattr *nest, *nest2;
385
386 nlh = nlmsg_put(skb, 0, 0, type, sizeof(*bpm), 0);
387 if (!nlh)
388 return -EMSGSIZE;
389
390 bpm = nlmsg_data(nlh);
391 memset(bpm, 0, sizeof(*bpm));
392 bpm->family = AF_BRIDGE;
393 bpm->ifindex = dev->ifindex;
394 nest = nla_nest_start_noflag(skb, MDBA_MDB);
395 if (nest == NULL)
396 goto cancel;
397 nest2 = nla_nest_start_noflag(skb, MDBA_MDB_ENTRY);
398 if (nest2 == NULL)
399 goto end;
400
401 if (__mdb_fill_info(skb, mp, pg))
402 goto end;
403
404 nla_nest_end(skb, nest2);
405 nla_nest_end(skb, nest);
406 nlmsg_end(skb, nlh);
407 return 0;
408
409end:
410 nla_nest_end(skb, nest);
411cancel:
412 nlmsg_cancel(skb, nlh);
413 return -EMSGSIZE;
414}
415
416static size_t rtnl_mdb_nlmsg_size(struct net_bridge_port_group *pg)
417{
418 size_t nlmsg_size = NLMSG_ALIGN(sizeof(struct br_port_msg)) +
419 nla_total_size(sizeof(struct br_mdb_entry)) +
420 nla_total_size(sizeof(u32));
421 struct net_bridge_group_src *ent;
422 size_t addr_size = 0;
423
424 if (!pg)
425 goto out;
426
427
428 nlmsg_size += nla_total_size(sizeof(u8));
429
430 switch (pg->key.addr.proto) {
431 case htons(ETH_P_IP):
432
433 if (pg->key.addr.src.ip4)
434 nlmsg_size += nla_total_size(sizeof(__be32));
435 if (pg->key.port->br->multicast_igmp_version == 2)
436 goto out;
437 addr_size = sizeof(__be32);
438 break;
439#if IS_ENABLED(CONFIG_IPV6)
440 case htons(ETH_P_IPV6):
441
442 if (!ipv6_addr_any(&pg->key.addr.src.ip6))
443 nlmsg_size += nla_total_size(sizeof(struct in6_addr));
444 if (pg->key.port->br->multicast_mld_version == 1)
445 goto out;
446 addr_size = sizeof(struct in6_addr);
447 break;
448#endif
449 }
450
451
452 nlmsg_size += nla_total_size(sizeof(u8));
453
454
455 if (!hlist_empty(&pg->src_list))
456 nlmsg_size += nla_total_size(0);
457
458 hlist_for_each_entry(ent, &pg->src_list, node) {
459
460
461
462 nlmsg_size += nla_total_size(0) +
463 nla_total_size(addr_size) +
464 nla_total_size(sizeof(u32));
465 }
466out:
467 return nlmsg_size;
468}
469
470struct br_mdb_complete_info {
471 struct net_bridge_port *port;
472 struct br_ip ip;
473};
474
475static void br_mdb_complete(struct net_device *dev, int err, void *priv)
476{
477 struct br_mdb_complete_info *data = priv;
478 struct net_bridge_port_group __rcu **pp;
479 struct net_bridge_port_group *p;
480 struct net_bridge_mdb_entry *mp;
481 struct net_bridge_port *port = data->port;
482 struct net_bridge *br = port->br;
483
484 if (err)
485 goto err;
486
487 spin_lock_bh(&br->multicast_lock);
488 mp = br_mdb_ip_get(br, &data->ip);
489 if (!mp)
490 goto out;
491 for (pp = &mp->ports; (p = mlock_dereference(*pp, br)) != NULL;
492 pp = &p->next) {
493 if (p->key.port != port)
494 continue;
495 p->flags |= MDB_PG_FLAGS_OFFLOAD;
496 }
497out:
498 spin_unlock_bh(&br->multicast_lock);
499err:
500 kfree(priv);
501}
502
503static void br_mdb_switchdev_host_port(struct net_device *dev,
504 struct net_device *lower_dev,
505 struct net_bridge_mdb_entry *mp,
506 int type)
507{
508 struct switchdev_obj_port_mdb mdb = {
509 .obj = {
510 .id = SWITCHDEV_OBJ_ID_HOST_MDB,
511 .flags = SWITCHDEV_F_DEFER,
512 },
513 .vid = mp->addr.vid,
514 };
515
516 if (mp->addr.proto == htons(ETH_P_IP))
517 ip_eth_mc_map(mp->addr.dst.ip4, mdb.addr);
518#if IS_ENABLED(CONFIG_IPV6)
519 else
520 ipv6_eth_mc_map(&mp->addr.dst.ip6, mdb.addr);
521#endif
522
523 mdb.obj.orig_dev = dev;
524 switch (type) {
525 case RTM_NEWMDB:
526 switchdev_port_obj_add(lower_dev, &mdb.obj, NULL);
527 break;
528 case RTM_DELMDB:
529 switchdev_port_obj_del(lower_dev, &mdb.obj);
530 break;
531 }
532}
533
534static void br_mdb_switchdev_host(struct net_device *dev,
535 struct net_bridge_mdb_entry *mp, int type)
536{
537 struct net_device *lower_dev;
538 struct list_head *iter;
539
540 netdev_for_each_lower_dev(dev, lower_dev, iter)
541 br_mdb_switchdev_host_port(dev, lower_dev, mp, type);
542}
543
544void br_mdb_notify(struct net_device *dev,
545 struct net_bridge_mdb_entry *mp,
546 struct net_bridge_port_group *pg,
547 int type)
548{
549 struct br_mdb_complete_info *complete_info;
550 struct switchdev_obj_port_mdb mdb = {
551 .obj = {
552 .id = SWITCHDEV_OBJ_ID_PORT_MDB,
553 .flags = SWITCHDEV_F_DEFER,
554 },
555 .vid = mp->addr.vid,
556 };
557 struct net *net = dev_net(dev);
558 struct sk_buff *skb;
559 int err = -ENOBUFS;
560
561 if (pg) {
562 if (mp->addr.proto == htons(ETH_P_IP))
563 ip_eth_mc_map(mp->addr.dst.ip4, mdb.addr);
564#if IS_ENABLED(CONFIG_IPV6)
565 else
566 ipv6_eth_mc_map(&mp->addr.dst.ip6, mdb.addr);
567#endif
568 mdb.obj.orig_dev = pg->key.port->dev;
569 switch (type) {
570 case RTM_NEWMDB:
571 complete_info = kmalloc(sizeof(*complete_info), GFP_ATOMIC);
572 if (!complete_info)
573 break;
574 complete_info->port = pg->key.port;
575 complete_info->ip = mp->addr;
576 mdb.obj.complete_priv = complete_info;
577 mdb.obj.complete = br_mdb_complete;
578 if (switchdev_port_obj_add(pg->key.port->dev, &mdb.obj, NULL))
579 kfree(complete_info);
580 break;
581 case RTM_DELMDB:
582 switchdev_port_obj_del(pg->key.port->dev, &mdb.obj);
583 break;
584 }
585 } else {
586 br_mdb_switchdev_host(dev, mp, type);
587 }
588
589 skb = nlmsg_new(rtnl_mdb_nlmsg_size(pg), GFP_ATOMIC);
590 if (!skb)
591 goto errout;
592
593 err = nlmsg_populate_mdb_fill(skb, dev, mp, pg, type);
594 if (err < 0) {
595 kfree_skb(skb);
596 goto errout;
597 }
598
599 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
600 return;
601errout:
602 rtnl_set_sk_err(net, RTNLGRP_MDB, err);
603}
604
605static int nlmsg_populate_rtr_fill(struct sk_buff *skb,
606 struct net_device *dev,
607 int ifindex, u32 pid,
608 u32 seq, int type, unsigned int flags)
609{
610 struct br_port_msg *bpm;
611 struct nlmsghdr *nlh;
612 struct nlattr *nest;
613
614 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), 0);
615 if (!nlh)
616 return -EMSGSIZE;
617
618 bpm = nlmsg_data(nlh);
619 memset(bpm, 0, sizeof(*bpm));
620 bpm->family = AF_BRIDGE;
621 bpm->ifindex = dev->ifindex;
622 nest = nla_nest_start_noflag(skb, MDBA_ROUTER);
623 if (!nest)
624 goto cancel;
625
626 if (nla_put_u32(skb, MDBA_ROUTER_PORT, ifindex))
627 goto end;
628
629 nla_nest_end(skb, nest);
630 nlmsg_end(skb, nlh);
631 return 0;
632
633end:
634 nla_nest_end(skb, nest);
635cancel:
636 nlmsg_cancel(skb, nlh);
637 return -EMSGSIZE;
638}
639
640static inline size_t rtnl_rtr_nlmsg_size(void)
641{
642 return NLMSG_ALIGN(sizeof(struct br_port_msg))
643 + nla_total_size(sizeof(__u32));
644}
645
646void br_rtr_notify(struct net_device *dev, struct net_bridge_port *port,
647 int type)
648{
649 struct net *net = dev_net(dev);
650 struct sk_buff *skb;
651 int err = -ENOBUFS;
652 int ifindex;
653
654 ifindex = port ? port->dev->ifindex : 0;
655 skb = nlmsg_new(rtnl_rtr_nlmsg_size(), GFP_ATOMIC);
656 if (!skb)
657 goto errout;
658
659 err = nlmsg_populate_rtr_fill(skb, dev, ifindex, 0, 0, type, NTF_SELF);
660 if (err < 0) {
661 kfree_skb(skb);
662 goto errout;
663 }
664
665 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
666 return;
667
668errout:
669 rtnl_set_sk_err(net, RTNLGRP_MDB, err);
670}
671
672static bool is_valid_mdb_entry(struct br_mdb_entry *entry,
673 struct netlink_ext_ack *extack)
674{
675 if (entry->ifindex == 0) {
676 NL_SET_ERR_MSG_MOD(extack, "Zero entry ifindex is not allowed");
677 return false;
678 }
679
680 if (entry->addr.proto == htons(ETH_P_IP)) {
681 if (!ipv4_is_multicast(entry->addr.u.ip4)) {
682 NL_SET_ERR_MSG_MOD(extack, "IPv4 entry group address is not multicast");
683 return false;
684 }
685 if (ipv4_is_local_multicast(entry->addr.u.ip4)) {
686 NL_SET_ERR_MSG_MOD(extack, "IPv4 entry group address is local multicast");
687 return false;
688 }
689#if IS_ENABLED(CONFIG_IPV6)
690 } else if (entry->addr.proto == htons(ETH_P_IPV6)) {
691 if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6)) {
692 NL_SET_ERR_MSG_MOD(extack, "IPv6 entry group address is link-local all nodes");
693 return false;
694 }
695#endif
696 } else {
697 NL_SET_ERR_MSG_MOD(extack, "Unknown entry protocol");
698 return false;
699 }
700
701 if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) {
702 NL_SET_ERR_MSG_MOD(extack, "Unknown entry state");
703 return false;
704 }
705 if (entry->vid >= VLAN_VID_MASK) {
706 NL_SET_ERR_MSG_MOD(extack, "Invalid entry VLAN id");
707 return false;
708 }
709
710 return true;
711}
712
713static bool is_valid_mdb_source(struct nlattr *attr, __be16 proto,
714 struct netlink_ext_ack *extack)
715{
716 switch (proto) {
717 case htons(ETH_P_IP):
718 if (nla_len(attr) != sizeof(struct in_addr)) {
719 NL_SET_ERR_MSG_MOD(extack, "IPv4 invalid source address length");
720 return false;
721 }
722 if (ipv4_is_multicast(nla_get_in_addr(attr))) {
723 NL_SET_ERR_MSG_MOD(extack, "IPv4 multicast source address is not allowed");
724 return false;
725 }
726 break;
727#if IS_ENABLED(CONFIG_IPV6)
728 case htons(ETH_P_IPV6): {
729 struct in6_addr src;
730
731 if (nla_len(attr) != sizeof(struct in6_addr)) {
732 NL_SET_ERR_MSG_MOD(extack, "IPv6 invalid source address length");
733 return false;
734 }
735 src = nla_get_in6_addr(attr);
736 if (ipv6_addr_is_multicast(&src)) {
737 NL_SET_ERR_MSG_MOD(extack, "IPv6 multicast source address is not allowed");
738 return false;
739 }
740 break;
741 }
742#endif
743 default:
744 NL_SET_ERR_MSG_MOD(extack, "Invalid protocol used with source address");
745 return false;
746 }
747
748 return true;
749}
750
751static const struct nla_policy br_mdbe_attrs_pol[MDBE_ATTR_MAX + 1] = {
752 [MDBE_ATTR_SOURCE] = NLA_POLICY_RANGE(NLA_BINARY,
753 sizeof(struct in_addr),
754 sizeof(struct in6_addr)),
755};
756
757static int br_mdb_parse(struct sk_buff *skb, struct nlmsghdr *nlh,
758 struct net_device **pdev, struct br_mdb_entry **pentry,
759 struct nlattr **mdb_attrs, struct netlink_ext_ack *extack)
760{
761 struct net *net = sock_net(skb->sk);
762 struct br_mdb_entry *entry;
763 struct br_port_msg *bpm;
764 struct nlattr *tb[MDBA_SET_ENTRY_MAX+1];
765 struct net_device *dev;
766 int err;
767
768 err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb,
769 MDBA_SET_ENTRY_MAX, NULL, NULL);
770 if (err < 0)
771 return err;
772
773 bpm = nlmsg_data(nlh);
774 if (bpm->ifindex == 0) {
775 NL_SET_ERR_MSG_MOD(extack, "Invalid bridge ifindex");
776 return -EINVAL;
777 }
778
779 dev = __dev_get_by_index(net, bpm->ifindex);
780 if (dev == NULL) {
781 NL_SET_ERR_MSG_MOD(extack, "Bridge device doesn't exist");
782 return -ENODEV;
783 }
784
785 if (!(dev->priv_flags & IFF_EBRIDGE)) {
786 NL_SET_ERR_MSG_MOD(extack, "Device is not a bridge");
787 return -EOPNOTSUPP;
788 }
789
790 *pdev = dev;
791
792 if (!tb[MDBA_SET_ENTRY]) {
793 NL_SET_ERR_MSG_MOD(extack, "Missing MDBA_SET_ENTRY attribute");
794 return -EINVAL;
795 }
796 if (nla_len(tb[MDBA_SET_ENTRY]) != sizeof(struct br_mdb_entry)) {
797 NL_SET_ERR_MSG_MOD(extack, "Invalid MDBA_SET_ENTRY attribute length");
798 return -EINVAL;
799 }
800
801 entry = nla_data(tb[MDBA_SET_ENTRY]);
802 if (!is_valid_mdb_entry(entry, extack))
803 return -EINVAL;
804 *pentry = entry;
805
806 if (tb[MDBA_SET_ENTRY_ATTRS]) {
807 err = nla_parse_nested(mdb_attrs, MDBE_ATTR_MAX,
808 tb[MDBA_SET_ENTRY_ATTRS],
809 br_mdbe_attrs_pol, extack);
810 if (err)
811 return err;
812 if (mdb_attrs[MDBE_ATTR_SOURCE] &&
813 !is_valid_mdb_source(mdb_attrs[MDBE_ATTR_SOURCE],
814 entry->addr.proto, extack))
815 return -EINVAL;
816 } else {
817 memset(mdb_attrs, 0,
818 sizeof(struct nlattr *) * (MDBE_ATTR_MAX + 1));
819 }
820
821 return 0;
822}
823
824static int br_mdb_add_group(struct net_bridge *br, struct net_bridge_port *port,
825 struct br_mdb_entry *entry,
826 struct nlattr **mdb_attrs,
827 struct netlink_ext_ack *extack)
828{
829 struct net_bridge_mdb_entry *mp, *star_mp;
830 struct net_bridge_port_group *p;
831 struct net_bridge_port_group __rcu **pp;
832 struct br_ip group, star_group;
833 unsigned long now = jiffies;
834 u8 filter_mode;
835 int err;
836
837 __mdb_entry_to_br_ip(entry, &group, mdb_attrs);
838
839
840 if (!port) {
841
842 if (entry->state) {
843 NL_SET_ERR_MSG_MOD(extack, "Flags are not allowed for host groups");
844 return -EINVAL;
845 }
846 if (!br_multicast_is_star_g(&group)) {
847 NL_SET_ERR_MSG_MOD(extack, "Groups with sources cannot be manually host joined");
848 return -EINVAL;
849 }
850 }
851
852 mp = br_mdb_ip_get(br, &group);
853 if (!mp) {
854 mp = br_multicast_new_group(br, &group);
855 err = PTR_ERR_OR_ZERO(mp);
856 if (err)
857 return err;
858 }
859
860
861 if (!port) {
862 if (mp->host_joined) {
863 NL_SET_ERR_MSG_MOD(extack, "Group is already joined by host");
864 return -EEXIST;
865 }
866
867 br_multicast_host_join(mp, false);
868 br_mdb_notify(br->dev, mp, NULL, RTM_NEWMDB);
869
870 return 0;
871 }
872
873 for (pp = &mp->ports;
874 (p = mlock_dereference(*pp, br)) != NULL;
875 pp = &p->next) {
876 if (p->key.port == port) {
877 NL_SET_ERR_MSG_MOD(extack, "Group is already joined by port");
878 return -EEXIST;
879 }
880 if ((unsigned long)p->key.port < (unsigned long)port)
881 break;
882 }
883
884 filter_mode = br_multicast_is_star_g(&group) ? MCAST_EXCLUDE :
885 MCAST_INCLUDE;
886
887 p = br_multicast_new_port_group(port, &group, *pp, entry->state, NULL,
888 filter_mode, RTPROT_STATIC);
889 if (unlikely(!p)) {
890 NL_SET_ERR_MSG_MOD(extack, "Couldn't allocate new port group");
891 return -ENOMEM;
892 }
893 rcu_assign_pointer(*pp, p);
894 if (entry->state == MDB_TEMPORARY)
895 mod_timer(&p->timer, now + br->multicast_membership_interval);
896 br_mdb_notify(br->dev, mp, p, RTM_NEWMDB);
897
898
899
900
901
902 if (br_multicast_should_handle_mode(br, group.proto)) {
903 switch (filter_mode) {
904 case MCAST_EXCLUDE:
905 br_multicast_star_g_handle_mode(p, MCAST_EXCLUDE);
906 break;
907 case MCAST_INCLUDE:
908 star_group = p->key.addr;
909 memset(&star_group.src, 0, sizeof(star_group.src));
910 star_mp = br_mdb_ip_get(br, &star_group);
911 if (star_mp)
912 br_multicast_sg_add_exclude_ports(star_mp, p);
913 break;
914 }
915 }
916
917 return 0;
918}
919
920static int __br_mdb_add(struct net *net, struct net_bridge *br,
921 struct net_bridge_port *p,
922 struct br_mdb_entry *entry,
923 struct nlattr **mdb_attrs,
924 struct netlink_ext_ack *extack)
925{
926 int ret;
927
928 spin_lock_bh(&br->multicast_lock);
929 ret = br_mdb_add_group(br, p, entry, mdb_attrs, extack);
930 spin_unlock_bh(&br->multicast_lock);
931
932 return ret;
933}
934
935static int br_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
936 struct netlink_ext_ack *extack)
937{
938 struct nlattr *mdb_attrs[MDBE_ATTR_MAX + 1];
939 struct net *net = sock_net(skb->sk);
940 struct net_bridge_vlan_group *vg;
941 struct net_bridge_port *p = NULL;
942 struct net_device *dev, *pdev;
943 struct br_mdb_entry *entry;
944 struct net_bridge_vlan *v;
945 struct net_bridge *br;
946 int err;
947
948 err = br_mdb_parse(skb, nlh, &dev, &entry, mdb_attrs, extack);
949 if (err < 0)
950 return err;
951
952 br = netdev_priv(dev);
953
954 if (!netif_running(br->dev)) {
955 NL_SET_ERR_MSG_MOD(extack, "Bridge device is not running");
956 return -EINVAL;
957 }
958
959 if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) {
960 NL_SET_ERR_MSG_MOD(extack, "Bridge's multicast processing is disabled");
961 return -EINVAL;
962 }
963
964 if (entry->ifindex != br->dev->ifindex) {
965 pdev = __dev_get_by_index(net, entry->ifindex);
966 if (!pdev) {
967 NL_SET_ERR_MSG_MOD(extack, "Port net device doesn't exist");
968 return -ENODEV;
969 }
970
971 p = br_port_get_rtnl(pdev);
972 if (!p) {
973 NL_SET_ERR_MSG_MOD(extack, "Net device is not a bridge port");
974 return -EINVAL;
975 }
976
977 if (p->br != br) {
978 NL_SET_ERR_MSG_MOD(extack, "Port belongs to a different bridge device");
979 return -EINVAL;
980 }
981 if (p->state == BR_STATE_DISABLED) {
982 NL_SET_ERR_MSG_MOD(extack, "Port is in disabled state");
983 return -EINVAL;
984 }
985 vg = nbp_vlan_group(p);
986 } else {
987 vg = br_vlan_group(br);
988 }
989
990
991
992
993 if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) {
994 list_for_each_entry(v, &vg->vlan_list, vlist) {
995 entry->vid = v->vid;
996 err = __br_mdb_add(net, br, p, entry, mdb_attrs, extack);
997 if (err)
998 break;
999 }
1000 } else {
1001 err = __br_mdb_add(net, br, p, entry, mdb_attrs, extack);
1002 }
1003
1004 return err;
1005}
1006
1007static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry,
1008 struct nlattr **mdb_attrs)
1009{
1010 struct net_bridge_mdb_entry *mp;
1011 struct net_bridge_port_group *p;
1012 struct net_bridge_port_group __rcu **pp;
1013 struct br_ip ip;
1014 int err = -EINVAL;
1015
1016 if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
1017 return -EINVAL;
1018
1019 __mdb_entry_to_br_ip(entry, &ip, mdb_attrs);
1020
1021 spin_lock_bh(&br->multicast_lock);
1022 mp = br_mdb_ip_get(br, &ip);
1023 if (!mp)
1024 goto unlock;
1025
1026
1027 if (entry->ifindex == mp->br->dev->ifindex && mp->host_joined) {
1028 br_multicast_host_leave(mp, false);
1029 err = 0;
1030 br_mdb_notify(br->dev, mp, NULL, RTM_DELMDB);
1031 if (!mp->ports && netif_running(br->dev))
1032 mod_timer(&mp->timer, jiffies);
1033 goto unlock;
1034 }
1035
1036 for (pp = &mp->ports;
1037 (p = mlock_dereference(*pp, br)) != NULL;
1038 pp = &p->next) {
1039 if (!p->key.port || p->key.port->dev->ifindex != entry->ifindex)
1040 continue;
1041
1042 if (p->key.port->state == BR_STATE_DISABLED)
1043 goto unlock;
1044
1045 br_multicast_del_pg(mp, p, pp);
1046 err = 0;
1047 break;
1048 }
1049
1050unlock:
1051 spin_unlock_bh(&br->multicast_lock);
1052 return err;
1053}
1054
1055static int br_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
1056 struct netlink_ext_ack *extack)
1057{
1058 struct nlattr *mdb_attrs[MDBE_ATTR_MAX + 1];
1059 struct net *net = sock_net(skb->sk);
1060 struct net_bridge_vlan_group *vg;
1061 struct net_bridge_port *p = NULL;
1062 struct net_device *dev, *pdev;
1063 struct br_mdb_entry *entry;
1064 struct net_bridge_vlan *v;
1065 struct net_bridge *br;
1066 int err;
1067
1068 err = br_mdb_parse(skb, nlh, &dev, &entry, mdb_attrs, extack);
1069 if (err < 0)
1070 return err;
1071
1072 br = netdev_priv(dev);
1073
1074 if (entry->ifindex != br->dev->ifindex) {
1075 pdev = __dev_get_by_index(net, entry->ifindex);
1076 if (!pdev)
1077 return -ENODEV;
1078
1079 p = br_port_get_rtnl(pdev);
1080 if (!p || p->br != br || p->state == BR_STATE_DISABLED)
1081 return -EINVAL;
1082 vg = nbp_vlan_group(p);
1083 } else {
1084 vg = br_vlan_group(br);
1085 }
1086
1087
1088
1089
1090 if (br_vlan_enabled(br->dev) && vg && entry->vid == 0) {
1091 list_for_each_entry(v, &vg->vlan_list, vlist) {
1092 entry->vid = v->vid;
1093 err = __br_mdb_del(br, entry, mdb_attrs);
1094 }
1095 } else {
1096 err = __br_mdb_del(br, entry, mdb_attrs);
1097 }
1098
1099 return err;
1100}
1101
1102void br_mdb_init(void)
1103{
1104 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_GETMDB, NULL, br_mdb_dump, 0);
1105 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_NEWMDB, br_mdb_add, NULL, 0);
1106 rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_DELMDB, br_mdb_del, NULL, 0);
1107}
1108
1109void br_mdb_uninit(void)
1110{
1111 rtnl_unregister(PF_BRIDGE, RTM_GETMDB);
1112 rtnl_unregister(PF_BRIDGE, RTM_NEWMDB);
1113 rtnl_unregister(PF_BRIDGE, RTM_DELMDB);
1114}
1115
