2 #include <linux/igmp.h>
3 #include <linux/kernel.h>
4 #include <linux/netdevice.h>
5 #include <linux/rculist.h>
6 #include <linux/skbuff.h>
7 #include <linux/if_ether.h>
9 #include <net/netlink.h>
10 #if IS_ENABLED(CONFIG_IPV6)
14 #include "br_private.h"
16 static int br_rports_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
17 struct net_device *dev)
19 struct net_bridge *br = netdev_priv(dev);
20 struct net_bridge_port *p;
24 if (!br->multicast_router || hlist_empty(&br->router_list))
27 nest = nla_nest_start(skb, MDBA_ROUTER);
31 hlist_for_each_entry_rcu(p, n, &br->router_list, rlist) {
32 if (p && nla_put_u32(skb, MDBA_ROUTER_PORT, p->dev->ifindex))
36 nla_nest_end(skb, nest);
39 nla_nest_cancel(skb, nest);
43 static int br_mdb_fill_info(struct sk_buff *skb, struct netlink_callback *cb,
44 struct net_device *dev)
46 struct net_bridge *br = netdev_priv(dev);
47 struct net_bridge_mdb_htable *mdb;
48 struct nlattr *nest, *nest2;
50 int idx = 0, s_idx = cb->args[1];
52 if (br->multicast_disabled)
55 mdb = rcu_dereference(br->mdb);
59 nest = nla_nest_start(skb, MDBA_MDB);
63 for (i = 0; i < mdb->max; i++) {
65 struct net_bridge_mdb_entry *mp;
66 struct net_bridge_port_group *p, **pp;
67 struct net_bridge_port *port;
69 hlist_for_each_entry_rcu(mp, h, &mdb->mhash[i], hlist[mdb->ver]) {
73 nest2 = nla_nest_start(skb, MDBA_MDB_ENTRY);
80 (p = rcu_dereference(*pp)) != NULL;
84 struct br_mdb_entry e;
85 e.ifindex = port->dev->ifindex;
86 e.addr.u.ip4 = p->addr.u.ip4;
87 #if IS_ENABLED(CONFIG_IPV6)
88 e.addr.u.ip6 = p->addr.u.ip6;
90 e.addr.proto = p->addr.proto;
91 if (nla_put(skb, MDBA_MDB_ENTRY_INFO, sizeof(e), &e)) {
92 nla_nest_cancel(skb, nest2);
98 nla_nest_end(skb, nest2);
106 nla_nest_end(skb, nest);
110 static int br_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
112 struct net_device *dev;
113 struct net *net = sock_net(skb->sk);
114 struct nlmsghdr *nlh = NULL;
121 /* In theory this could be wrapped to 0... */
122 cb->seq = net->dev_base_seq + br_mdb_rehash_seq;
124 for_each_netdev_rcu(net, dev) {
125 if (dev->priv_flags & IFF_EBRIDGE) {
126 struct br_port_msg *bpm;
131 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
132 cb->nlh->nlmsg_seq, RTM_GETMDB,
133 sizeof(*bpm), NLM_F_MULTI);
137 bpm = nlmsg_data(nlh);
138 bpm->ifindex = dev->ifindex;
139 if (br_mdb_fill_info(skb, cb, dev) < 0)
141 if (br_rports_fill_info(skb, cb, dev) < 0)
159 static int nlmsg_populate_mdb_fill(struct sk_buff *skb,
160 struct net_device *dev,
161 struct br_mdb_entry *entry, u32 pid,
162 u32 seq, int type, unsigned int flags)
164 struct nlmsghdr *nlh;
165 struct br_port_msg *bpm;
166 struct nlattr *nest, *nest2;
168 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*bpm), NLM_F_MULTI);
172 bpm = nlmsg_data(nlh);
173 bpm->family = AF_BRIDGE;
174 bpm->ifindex = dev->ifindex;
175 nest = nla_nest_start(skb, MDBA_MDB);
178 nest2 = nla_nest_start(skb, MDBA_MDB_ENTRY);
182 if (nla_put(skb, MDBA_MDB_ENTRY_INFO, sizeof(*entry), entry))
185 nla_nest_end(skb, nest2);
186 nla_nest_end(skb, nest);
187 return nlmsg_end(skb, nlh);
190 nla_nest_end(skb, nest);
192 nlmsg_cancel(skb, nlh);
196 static inline size_t rtnl_mdb_nlmsg_size(void)
198 return NLMSG_ALIGN(sizeof(struct br_port_msg))
199 + nla_total_size(sizeof(struct br_mdb_entry));
202 static void __br_mdb_notify(struct net_device *dev, struct br_mdb_entry *entry,
205 struct net *net = dev_net(dev);
209 skb = nlmsg_new(rtnl_mdb_nlmsg_size(), GFP_ATOMIC);
213 err = nlmsg_populate_mdb_fill(skb, dev, entry, 0, 0, type, NTF_SELF);
219 rtnl_notify(skb, net, 0, RTNLGRP_MDB, NULL, GFP_ATOMIC);
222 rtnl_set_sk_err(net, RTNLGRP_MDB, err);
225 void br_mdb_notify(struct net_device *dev, struct net_bridge_port *port,
226 struct br_ip *group, int type)
228 struct br_mdb_entry entry;
230 entry.ifindex = port->dev->ifindex;
231 entry.addr.proto = group->proto;
232 entry.addr.u.ip4 = group->u.ip4;
233 #if IS_ENABLED(CONFIG_IPV6)
234 entry.addr.u.ip6 = group->u.ip6;
236 __br_mdb_notify(dev, &entry, type);
239 static bool is_valid_mdb_entry(struct br_mdb_entry *entry)
241 if (entry->ifindex == 0)
244 if (entry->addr.proto == htons(ETH_P_IP)) {
245 if (!ipv4_is_multicast(entry->addr.u.ip4))
247 if (ipv4_is_local_multicast(entry->addr.u.ip4))
249 #if IS_ENABLED(CONFIG_IPV6)
250 } else if (entry->addr.proto == htons(ETH_P_IPV6)) {
251 if (!ipv6_is_transient_multicast(&entry->addr.u.ip6))
260 static int br_mdb_parse(struct sk_buff *skb, struct nlmsghdr *nlh,
261 struct net_device **pdev, struct br_mdb_entry **pentry)
263 struct net *net = sock_net(skb->sk);
264 struct br_mdb_entry *entry;
265 struct br_port_msg *bpm;
266 struct nlattr *tb[MDBA_SET_ENTRY_MAX+1];
267 struct net_device *dev;
270 if (!capable(CAP_NET_ADMIN))
273 err = nlmsg_parse(nlh, sizeof(*bpm), tb, MDBA_SET_ENTRY, NULL);
277 bpm = nlmsg_data(nlh);
278 if (bpm->ifindex == 0) {
279 pr_info("PF_BRIDGE: br_mdb_parse() with invalid ifindex\n");
283 dev = __dev_get_by_index(net, bpm->ifindex);
285 pr_info("PF_BRIDGE: br_mdb_parse() with unknown ifindex\n");
289 if (!(dev->priv_flags & IFF_EBRIDGE)) {
290 pr_info("PF_BRIDGE: br_mdb_parse() with non-bridge\n");
296 if (!tb[MDBA_SET_ENTRY] ||
297 nla_len(tb[MDBA_SET_ENTRY]) != sizeof(struct br_mdb_entry)) {
298 pr_info("PF_BRIDGE: br_mdb_parse() with invalid attr\n");
302 entry = nla_data(tb[MDBA_SET_ENTRY]);
303 if (!is_valid_mdb_entry(entry)) {
304 pr_info("PF_BRIDGE: br_mdb_parse() with invalid entry\n");
312 static int br_mdb_add_group(struct net_bridge *br, struct net_bridge_port *port,
315 struct net_bridge_mdb_entry *mp;
316 struct net_bridge_port_group *p;
317 struct net_bridge_port_group __rcu **pp;
318 struct net_bridge_mdb_htable *mdb;
321 mdb = mlock_dereference(br->mdb, br);
322 mp = br_mdb_ip_get(mdb, group);
324 mp = br_multicast_new_group(br, port, group);
330 for (pp = &mp->ports;
331 (p = mlock_dereference(*pp, br)) != NULL;
335 if ((unsigned long)p->port < (unsigned long)port)
339 p = br_multicast_new_port_group(port, group, *pp);
342 rcu_assign_pointer(*pp, p);
344 br_mdb_notify(br->dev, port, group, RTM_NEWMDB);
348 static int __br_mdb_add(struct net *net, struct net_bridge *br,
349 struct br_mdb_entry *entry)
352 struct net_device *dev;
353 struct net_bridge_port *p;
356 if (!netif_running(br->dev) || br->multicast_disabled)
359 dev = __dev_get_by_index(net, entry->ifindex);
363 p = br_port_get_rtnl(dev);
364 if (!p || p->br != br || p->state == BR_STATE_DISABLED)
367 ip.proto = entry->addr.proto;
368 if (ip.proto == htons(ETH_P_IP))
369 ip.u.ip4 = entry->addr.u.ip4;
370 #if IS_ENABLED(CONFIG_IPV6)
372 ip.u.ip6 = entry->addr.u.ip6;
375 spin_lock_bh(&br->multicast_lock);
376 ret = br_mdb_add_group(br, p, &ip);
377 spin_unlock_bh(&br->multicast_lock);
381 static int br_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
383 struct net *net = sock_net(skb->sk);
384 struct br_mdb_entry *entry;
385 struct net_device *dev;
386 struct net_bridge *br;
389 err = br_mdb_parse(skb, nlh, &dev, &entry);
393 br = netdev_priv(dev);
395 err = __br_mdb_add(net, br, entry);
397 __br_mdb_notify(dev, entry, RTM_NEWMDB);
401 static int __br_mdb_del(struct net_bridge *br, struct br_mdb_entry *entry)
403 struct net_bridge_mdb_htable *mdb;
404 struct net_bridge_mdb_entry *mp;
405 struct net_bridge_port_group *p;
406 struct net_bridge_port_group __rcu **pp;
410 if (!netif_running(br->dev) || br->multicast_disabled)
413 if (timer_pending(&br->multicast_querier_timer))
416 ip.proto = entry->addr.proto;
417 if (ip.proto == htons(ETH_P_IP))
418 ip.u.ip4 = entry->addr.u.ip4;
419 #if IS_ENABLED(CONFIG_IPV6)
421 ip.u.ip6 = entry->addr.u.ip6;
424 spin_lock_bh(&br->multicast_lock);
425 mdb = mlock_dereference(br->mdb, br);
427 mp = br_mdb_ip_get(mdb, &ip);
431 for (pp = &mp->ports;
432 (p = mlock_dereference(*pp, br)) != NULL;
434 if (!p->port || p->port->dev->ifindex != entry->ifindex)
437 if (p->port->state == BR_STATE_DISABLED)
440 rcu_assign_pointer(*pp, p->next);
441 hlist_del_init(&p->mglist);
442 del_timer(&p->timer);
443 call_rcu_bh(&p->rcu, br_multicast_free_pg);
446 if (!mp->ports && !mp->mglist &&
447 netif_running(br->dev))
448 mod_timer(&mp->timer, jiffies);
453 spin_unlock_bh(&br->multicast_lock);
457 static int br_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
459 struct net_device *dev;
460 struct br_mdb_entry *entry;
461 struct net_bridge *br;
464 err = br_mdb_parse(skb, nlh, &dev, &entry);
468 br = netdev_priv(dev);
470 err = __br_mdb_del(br, entry);
472 __br_mdb_notify(dev, entry, RTM_DELMDB);
476 void br_mdb_init(void)
478 rtnl_register(PF_BRIDGE, RTM_GETMDB, NULL, br_mdb_dump, NULL);
479 rtnl_register(PF_BRIDGE, RTM_NEWMDB, br_mdb_add, NULL, NULL);
480 rtnl_register(PF_BRIDGE, RTM_DELMDB, br_mdb_del, NULL, NULL);