drm/amdgpu/vg20:Restruct uvd to support multiple uvds
[muen/linux.git] / net / batman-adv / multicast.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2014-2018  B.A.T.M.A.N. contributors:
3  *
4  * Linus Lüssing
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of version 2 of the GNU General Public
8  * License as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include "multicast.h"
20 #include "main.h"
21
22 #include <linux/atomic.h>
23 #include <linux/bitops.h>
24 #include <linux/bug.h>
25 #include <linux/byteorder/generic.h>
26 #include <linux/errno.h>
27 #include <linux/etherdevice.h>
28 #include <linux/gfp.h>
29 #include <linux/icmpv6.h>
30 #include <linux/if_bridge.h>
31 #include <linux/if_ether.h>
32 #include <linux/igmp.h>
33 #include <linux/in.h>
34 #include <linux/in6.h>
35 #include <linux/ip.h>
36 #include <linux/ipv6.h>
37 #include <linux/jiffies.h>
38 #include <linux/kernel.h>
39 #include <linux/kref.h>
40 #include <linux/list.h>
41 #include <linux/lockdep.h>
42 #include <linux/netdevice.h>
43 #include <linux/netlink.h>
44 #include <linux/printk.h>
45 #include <linux/rculist.h>
46 #include <linux/rcupdate.h>
47 #include <linux/seq_file.h>
48 #include <linux/skbuff.h>
49 #include <linux/slab.h>
50 #include <linux/spinlock.h>
51 #include <linux/stddef.h>
52 #include <linux/string.h>
53 #include <linux/types.h>
54 #include <linux/workqueue.h>
55 #include <net/addrconf.h>
56 #include <net/genetlink.h>
57 #include <net/if_inet6.h>
58 #include <net/ip.h>
59 #include <net/ipv6.h>
60 #include <net/netlink.h>
61 #include <net/sock.h>
62 #include <uapi/linux/batadv_packet.h>
63 #include <uapi/linux/batman_adv.h>
64
65 #include "hard-interface.h"
66 #include "hash.h"
67 #include "log.h"
68 #include "netlink.h"
69 #include "soft-interface.h"
70 #include "translation-table.h"
71 #include "tvlv.h"
72
73 static void batadv_mcast_mla_update(struct work_struct *work);
74
75 /**
76  * batadv_mcast_start_timer() - schedule the multicast periodic worker
77  * @bat_priv: the bat priv with all the soft interface information
78  */
79 static void batadv_mcast_start_timer(struct batadv_priv *bat_priv)
80 {
81         queue_delayed_work(batadv_event_workqueue, &bat_priv->mcast.work,
82                            msecs_to_jiffies(BATADV_MCAST_WORK_PERIOD));
83 }
84
85 /**
86  * batadv_mcast_get_bridge() - get the bridge on top of the softif if it exists
87  * @soft_iface: netdev struct of the mesh interface
88  *
89  * If the given soft interface has a bridge on top then the refcount
90  * of the according net device is increased.
91  *
92  * Return: NULL if no such bridge exists. Otherwise the net device of the
93  * bridge.
94  */
95 static struct net_device *batadv_mcast_get_bridge(struct net_device *soft_iface)
96 {
97         struct net_device *upper = soft_iface;
98
99         rcu_read_lock();
100         do {
101                 upper = netdev_master_upper_dev_get_rcu(upper);
102         } while (upper && !(upper->priv_flags & IFF_EBRIDGE));
103
104         if (upper)
105                 dev_hold(upper);
106         rcu_read_unlock();
107
108         return upper;
109 }
110
111 /**
112  * batadv_mcast_addr_is_ipv4() - check if multicast MAC is IPv4
113  * @addr: the MAC address to check
114  *
115  * Return: True, if MAC address is one reserved for IPv4 multicast, false
116  * otherwise.
117  */
118 static bool batadv_mcast_addr_is_ipv4(const u8 *addr)
119 {
120         static const u8 prefix[] = {0x01, 0x00, 0x5E};
121
122         return memcmp(prefix, addr, sizeof(prefix)) == 0;
123 }
124
125 /**
126  * batadv_mcast_addr_is_ipv6() - check if multicast MAC is IPv6
127  * @addr: the MAC address to check
128  *
129  * Return: True, if MAC address is one reserved for IPv6 multicast, false
130  * otherwise.
131  */
132 static bool batadv_mcast_addr_is_ipv6(const u8 *addr)
133 {
134         static const u8 prefix[] = {0x33, 0x33};
135
136         return memcmp(prefix, addr, sizeof(prefix)) == 0;
137 }
138
139 /**
140  * batadv_mcast_mla_softif_get() - get softif multicast listeners
141  * @bat_priv: the bat priv with all the soft interface information
142  * @dev: the device to collect multicast addresses from
143  * @mcast_list: a list to put found addresses into
144  *
145  * Collects multicast addresses of multicast listeners residing
146  * on this kernel on the given soft interface, dev, in
147  * the given mcast_list. In general, multicast listeners provided by
148  * your multicast receiving applications run directly on this node.
149  *
150  * If there is a bridge interface on top of dev, collects from that one
151  * instead. Just like with IP addresses and routes, multicast listeners
152  * will(/should) register to the bridge interface instead of an
153  * enslaved bat0.
154  *
155  * Return: -ENOMEM on memory allocation error or the number of
156  * items added to the mcast_list otherwise.
157  */
158 static int batadv_mcast_mla_softif_get(struct batadv_priv *bat_priv,
159                                        struct net_device *dev,
160                                        struct hlist_head *mcast_list)
161 {
162         bool all_ipv4 = bat_priv->mcast.flags & BATADV_MCAST_WANT_ALL_IPV4;
163         bool all_ipv6 = bat_priv->mcast.flags & BATADV_MCAST_WANT_ALL_IPV6;
164         struct net_device *bridge = batadv_mcast_get_bridge(dev);
165         struct netdev_hw_addr *mc_list_entry;
166         struct batadv_hw_addr *new;
167         int ret = 0;
168
169         netif_addr_lock_bh(bridge ? bridge : dev);
170         netdev_for_each_mc_addr(mc_list_entry, bridge ? bridge : dev) {
171                 if (all_ipv4 && batadv_mcast_addr_is_ipv4(mc_list_entry->addr))
172                         continue;
173
174                 if (all_ipv6 && batadv_mcast_addr_is_ipv6(mc_list_entry->addr))
175                         continue;
176
177                 new = kmalloc(sizeof(*new), GFP_ATOMIC);
178                 if (!new) {
179                         ret = -ENOMEM;
180                         break;
181                 }
182
183                 ether_addr_copy(new->addr, mc_list_entry->addr);
184                 hlist_add_head(&new->list, mcast_list);
185                 ret++;
186         }
187         netif_addr_unlock_bh(bridge ? bridge : dev);
188
189         if (bridge)
190                 dev_put(bridge);
191
192         return ret;
193 }
194
195 /**
196  * batadv_mcast_mla_is_duplicate() - check whether an address is in a list
197  * @mcast_addr: the multicast address to check
198  * @mcast_list: the list with multicast addresses to search in
199  *
200  * Return: true if the given address is already in the given list.
201  * Otherwise returns false.
202  */
203 static bool batadv_mcast_mla_is_duplicate(u8 *mcast_addr,
204                                           struct hlist_head *mcast_list)
205 {
206         struct batadv_hw_addr *mcast_entry;
207
208         hlist_for_each_entry(mcast_entry, mcast_list, list)
209                 if (batadv_compare_eth(mcast_entry->addr, mcast_addr))
210                         return true;
211
212         return false;
213 }
214
215 /**
216  * batadv_mcast_mla_br_addr_cpy() - copy a bridge multicast address
217  * @dst: destination to write to - a multicast MAC address
218  * @src: source to read from - a multicast IP address
219  *
220  * Converts a given multicast IPv4/IPv6 address from a bridge
221  * to its matching multicast MAC address and copies it into the given
222  * destination buffer.
223  *
224  * Caller needs to make sure the destination buffer can hold
225  * at least ETH_ALEN bytes.
226  */
227 static void batadv_mcast_mla_br_addr_cpy(char *dst, const struct br_ip *src)
228 {
229         if (src->proto == htons(ETH_P_IP))
230                 ip_eth_mc_map(src->u.ip4, dst);
231 #if IS_ENABLED(CONFIG_IPV6)
232         else if (src->proto == htons(ETH_P_IPV6))
233                 ipv6_eth_mc_map(&src->u.ip6, dst);
234 #endif
235         else
236                 eth_zero_addr(dst);
237 }
238
239 /**
240  * batadv_mcast_mla_bridge_get() - get bridged-in multicast listeners
241  * @bat_priv: the bat priv with all the soft interface information
242  * @dev: a bridge slave whose bridge to collect multicast addresses from
243  * @mcast_list: a list to put found addresses into
244  *
245  * Collects multicast addresses of multicast listeners residing
246  * on foreign, non-mesh devices which we gave access to our mesh via
247  * a bridge on top of the given soft interface, dev, in the given
248  * mcast_list.
249  *
250  * Return: -ENOMEM on memory allocation error or the number of
251  * items added to the mcast_list otherwise.
252  */
253 static int batadv_mcast_mla_bridge_get(struct batadv_priv *bat_priv,
254                                        struct net_device *dev,
255                                        struct hlist_head *mcast_list)
256 {
257         struct list_head bridge_mcast_list = LIST_HEAD_INIT(bridge_mcast_list);
258         bool all_ipv4 = bat_priv->mcast.flags & BATADV_MCAST_WANT_ALL_IPV4;
259         bool all_ipv6 = bat_priv->mcast.flags & BATADV_MCAST_WANT_ALL_IPV6;
260         struct br_ip_list *br_ip_entry, *tmp;
261         struct batadv_hw_addr *new;
262         u8 mcast_addr[ETH_ALEN];
263         int ret;
264
265         /* we don't need to detect these devices/listeners, the IGMP/MLD
266          * snooping code of the Linux bridge already does that for us
267          */
268         ret = br_multicast_list_adjacent(dev, &bridge_mcast_list);
269         if (ret < 0)
270                 goto out;
271
272         list_for_each_entry(br_ip_entry, &bridge_mcast_list, list) {
273                 if (all_ipv4 && br_ip_entry->addr.proto == htons(ETH_P_IP))
274                         continue;
275
276                 if (all_ipv6 && br_ip_entry->addr.proto == htons(ETH_P_IPV6))
277                         continue;
278
279                 batadv_mcast_mla_br_addr_cpy(mcast_addr, &br_ip_entry->addr);
280                 if (batadv_mcast_mla_is_duplicate(mcast_addr, mcast_list))
281                         continue;
282
283                 new = kmalloc(sizeof(*new), GFP_ATOMIC);
284                 if (!new) {
285                         ret = -ENOMEM;
286                         break;
287                 }
288
289                 ether_addr_copy(new->addr, mcast_addr);
290                 hlist_add_head(&new->list, mcast_list);
291         }
292
293 out:
294         list_for_each_entry_safe(br_ip_entry, tmp, &bridge_mcast_list, list) {
295                 list_del(&br_ip_entry->list);
296                 kfree(br_ip_entry);
297         }
298
299         return ret;
300 }
301
302 /**
303  * batadv_mcast_mla_list_free() - free a list of multicast addresses
304  * @mcast_list: the list to free
305  *
306  * Removes and frees all items in the given mcast_list.
307  */
308 static void batadv_mcast_mla_list_free(struct hlist_head *mcast_list)
309 {
310         struct batadv_hw_addr *mcast_entry;
311         struct hlist_node *tmp;
312
313         hlist_for_each_entry_safe(mcast_entry, tmp, mcast_list, list) {
314                 hlist_del(&mcast_entry->list);
315                 kfree(mcast_entry);
316         }
317 }
318
319 /**
320  * batadv_mcast_mla_tt_retract() - clean up multicast listener announcements
321  * @bat_priv: the bat priv with all the soft interface information
322  * @mcast_list: a list of addresses which should _not_ be removed
323  *
324  * Retracts the announcement of any multicast listener from the
325  * translation table except the ones listed in the given mcast_list.
326  *
327  * If mcast_list is NULL then all are retracted.
328  *
329  * Do not call outside of the mcast worker! (or cancel mcast worker first)
330  */
331 static void batadv_mcast_mla_tt_retract(struct batadv_priv *bat_priv,
332                                         struct hlist_head *mcast_list)
333 {
334         struct batadv_hw_addr *mcast_entry;
335         struct hlist_node *tmp;
336
337         WARN_ON(delayed_work_pending(&bat_priv->mcast.work));
338
339         hlist_for_each_entry_safe(mcast_entry, tmp, &bat_priv->mcast.mla_list,
340                                   list) {
341                 if (mcast_list &&
342                     batadv_mcast_mla_is_duplicate(mcast_entry->addr,
343                                                   mcast_list))
344                         continue;
345
346                 batadv_tt_local_remove(bat_priv, mcast_entry->addr,
347                                        BATADV_NO_FLAGS,
348                                        "mcast TT outdated", false);
349
350                 hlist_del(&mcast_entry->list);
351                 kfree(mcast_entry);
352         }
353 }
354
355 /**
356  * batadv_mcast_mla_tt_add() - add multicast listener announcements
357  * @bat_priv: the bat priv with all the soft interface information
358  * @mcast_list: a list of addresses which are going to get added
359  *
360  * Adds multicast listener announcements from the given mcast_list to the
361  * translation table if they have not been added yet.
362  *
363  * Do not call outside of the mcast worker! (or cancel mcast worker first)
364  */
365 static void batadv_mcast_mla_tt_add(struct batadv_priv *bat_priv,
366                                     struct hlist_head *mcast_list)
367 {
368         struct batadv_hw_addr *mcast_entry;
369         struct hlist_node *tmp;
370
371         WARN_ON(delayed_work_pending(&bat_priv->mcast.work));
372
373         if (!mcast_list)
374                 return;
375
376         hlist_for_each_entry_safe(mcast_entry, tmp, mcast_list, list) {
377                 if (batadv_mcast_mla_is_duplicate(mcast_entry->addr,
378                                                   &bat_priv->mcast.mla_list))
379                         continue;
380
381                 if (!batadv_tt_local_add(bat_priv->soft_iface,
382                                          mcast_entry->addr, BATADV_NO_FLAGS,
383                                          BATADV_NULL_IFINDEX, BATADV_NO_MARK))
384                         continue;
385
386                 hlist_del(&mcast_entry->list);
387                 hlist_add_head(&mcast_entry->list, &bat_priv->mcast.mla_list);
388         }
389 }
390
391 /**
392  * batadv_mcast_has_bridge() - check whether the soft-iface is bridged
393  * @bat_priv: the bat priv with all the soft interface information
394  *
395  * Checks whether there is a bridge on top of our soft interface.
396  *
397  * Return: true if there is a bridge, false otherwise.
398  */
399 static bool batadv_mcast_has_bridge(struct batadv_priv *bat_priv)
400 {
401         struct net_device *upper = bat_priv->soft_iface;
402
403         rcu_read_lock();
404         do {
405                 upper = netdev_master_upper_dev_get_rcu(upper);
406         } while (upper && !(upper->priv_flags & IFF_EBRIDGE));
407         rcu_read_unlock();
408
409         return upper;
410 }
411
412 /**
413  * batadv_mcast_querier_log() - debug output regarding the querier status on
414  *  link
415  * @bat_priv: the bat priv with all the soft interface information
416  * @str_proto: a string for the querier protocol (e.g. "IGMP" or "MLD")
417  * @old_state: the previous querier state on our link
418  * @new_state: the new querier state on our link
419  *
420  * Outputs debug messages to the logging facility with log level 'mcast'
421  * regarding changes to the querier status on the link which are relevant
422  * to our multicast optimizations.
423  *
424  * Usually this is about whether a querier appeared or vanished in
425  * our mesh or whether the querier is in the suboptimal position of being
426  * behind our local bridge segment: Snooping switches will directly
427  * forward listener reports to the querier, therefore batman-adv and
428  * the bridge will potentially not see these listeners - the querier is
429  * potentially shadowing listeners from us then.
430  *
431  * This is only interesting for nodes with a bridge on top of their
432  * soft interface.
433  */
434 static void
435 batadv_mcast_querier_log(struct batadv_priv *bat_priv, char *str_proto,
436                          struct batadv_mcast_querier_state *old_state,
437                          struct batadv_mcast_querier_state *new_state)
438 {
439         if (!old_state->exists && new_state->exists)
440                 batadv_info(bat_priv->soft_iface, "%s Querier appeared\n",
441                             str_proto);
442         else if (old_state->exists && !new_state->exists)
443                 batadv_info(bat_priv->soft_iface,
444                             "%s Querier disappeared - multicast optimizations disabled\n",
445                             str_proto);
446         else if (!bat_priv->mcast.bridged && !new_state->exists)
447                 batadv_info(bat_priv->soft_iface,
448                             "No %s Querier present - multicast optimizations disabled\n",
449                             str_proto);
450
451         if (new_state->exists) {
452                 if ((!old_state->shadowing && new_state->shadowing) ||
453                     (!old_state->exists && new_state->shadowing))
454                         batadv_dbg(BATADV_DBG_MCAST, bat_priv,
455                                    "%s Querier is behind our bridged segment: Might shadow listeners\n",
456                                    str_proto);
457                 else if (old_state->shadowing && !new_state->shadowing)
458                         batadv_dbg(BATADV_DBG_MCAST, bat_priv,
459                                    "%s Querier is not behind our bridged segment\n",
460                                    str_proto);
461         }
462 }
463
464 /**
465  * batadv_mcast_bridge_log() - debug output for topology changes in bridged
466  *  setups
467  * @bat_priv: the bat priv with all the soft interface information
468  * @bridged: a flag about whether the soft interface is currently bridged or not
469  * @querier_ipv4: (maybe) new status of a potential, selected IGMP querier
470  * @querier_ipv6: (maybe) new status of a potential, selected MLD querier
471  *
472  * If no bridges are ever used on this node, then this function does nothing.
473  *
474  * Otherwise this function outputs debug information to the 'mcast' log level
475  * which might be relevant to our multicast optimizations.
476  *
477  * More precisely, it outputs information when a bridge interface is added or
478  * removed from a soft interface. And when a bridge is present, it further
479  * outputs information about the querier state which is relevant for the
480  * multicast flags this node is going to set.
481  */
482 static void
483 batadv_mcast_bridge_log(struct batadv_priv *bat_priv, bool bridged,
484                         struct batadv_mcast_querier_state *querier_ipv4,
485                         struct batadv_mcast_querier_state *querier_ipv6)
486 {
487         if (!bat_priv->mcast.bridged && bridged)
488                 batadv_dbg(BATADV_DBG_MCAST, bat_priv,
489                            "Bridge added: Setting Unsnoopables(U)-flag\n");
490         else if (bat_priv->mcast.bridged && !bridged)
491                 batadv_dbg(BATADV_DBG_MCAST, bat_priv,
492                            "Bridge removed: Unsetting Unsnoopables(U)-flag\n");
493
494         if (bridged) {
495                 batadv_mcast_querier_log(bat_priv, "IGMP",
496                                          &bat_priv->mcast.querier_ipv4,
497                                          querier_ipv4);
498                 batadv_mcast_querier_log(bat_priv, "MLD",
499                                          &bat_priv->mcast.querier_ipv6,
500                                          querier_ipv6);
501         }
502 }
503
504 /**
505  * batadv_mcast_flags_logs() - output debug information about mcast flag changes
506  * @bat_priv: the bat priv with all the soft interface information
507  * @flags: flags indicating the new multicast state
508  *
509  * Whenever the multicast flags this nodes announces changes (@mcast_flags vs.
510  * bat_priv->mcast.flags), this notifies userspace via the 'mcast' log level.
511  */
512 static void batadv_mcast_flags_log(struct batadv_priv *bat_priv, u8 flags)
513 {
514         u8 old_flags = bat_priv->mcast.flags;
515         char str_old_flags[] = "[...]";
516
517         sprintf(str_old_flags, "[%c%c%c]",
518                 (old_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) ? 'U' : '.',
519                 (old_flags & BATADV_MCAST_WANT_ALL_IPV4) ? '4' : '.',
520                 (old_flags & BATADV_MCAST_WANT_ALL_IPV6) ? '6' : '.');
521
522         batadv_dbg(BATADV_DBG_MCAST, bat_priv,
523                    "Changing multicast flags from '%s' to '[%c%c%c]'\n",
524                    bat_priv->mcast.enabled ? str_old_flags : "<undefined>",
525                    (flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) ? 'U' : '.',
526                    (flags & BATADV_MCAST_WANT_ALL_IPV4) ? '4' : '.',
527                    (flags & BATADV_MCAST_WANT_ALL_IPV6) ? '6' : '.');
528 }
529
530 /**
531  * batadv_mcast_mla_tvlv_update() - update multicast tvlv
532  * @bat_priv: the bat priv with all the soft interface information
533  *
534  * Updates the own multicast tvlv with our current multicast related settings,
535  * capabilities and inabilities.
536  *
537  * Return: false if we want all IPv4 && IPv6 multicast traffic and true
538  * otherwise.
539  */
540 static bool batadv_mcast_mla_tvlv_update(struct batadv_priv *bat_priv)
541 {
542         struct batadv_tvlv_mcast_data mcast_data;
543         struct batadv_mcast_querier_state querier4 = {false, false};
544         struct batadv_mcast_querier_state querier6 = {false, false};
545         struct net_device *dev = bat_priv->soft_iface;
546         bool bridged;
547
548         mcast_data.flags = BATADV_NO_FLAGS;
549         memset(mcast_data.reserved, 0, sizeof(mcast_data.reserved));
550
551         bridged = batadv_mcast_has_bridge(bat_priv);
552         if (!bridged)
553                 goto update;
554
555         if (!IS_ENABLED(CONFIG_BRIDGE_IGMP_SNOOPING))
556                 pr_warn_once("No bridge IGMP snooping compiled - multicast optimizations disabled\n");
557
558         querier4.exists = br_multicast_has_querier_anywhere(dev, ETH_P_IP);
559         querier4.shadowing = br_multicast_has_querier_adjacent(dev, ETH_P_IP);
560
561         querier6.exists = br_multicast_has_querier_anywhere(dev, ETH_P_IPV6);
562         querier6.shadowing = br_multicast_has_querier_adjacent(dev, ETH_P_IPV6);
563
564         mcast_data.flags |= BATADV_MCAST_WANT_ALL_UNSNOOPABLES;
565
566         /* 1) If no querier exists at all, then multicast listeners on
567          *    our local TT clients behind the bridge will keep silent.
568          * 2) If the selected querier is on one of our local TT clients,
569          *    behind the bridge, then this querier might shadow multicast
570          *    listeners on our local TT clients, behind this bridge.
571          *
572          * In both cases, we will signalize other batman nodes that
573          * we need all multicast traffic of the according protocol.
574          */
575         if (!querier4.exists || querier4.shadowing)
576                 mcast_data.flags |= BATADV_MCAST_WANT_ALL_IPV4;
577
578         if (!querier6.exists || querier6.shadowing)
579                 mcast_data.flags |= BATADV_MCAST_WANT_ALL_IPV6;
580
581 update:
582         batadv_mcast_bridge_log(bat_priv, bridged, &querier4, &querier6);
583
584         bat_priv->mcast.querier_ipv4.exists = querier4.exists;
585         bat_priv->mcast.querier_ipv4.shadowing = querier4.shadowing;
586
587         bat_priv->mcast.querier_ipv6.exists = querier6.exists;
588         bat_priv->mcast.querier_ipv6.shadowing = querier6.shadowing;
589
590         bat_priv->mcast.bridged = bridged;
591
592         if (!bat_priv->mcast.enabled ||
593             mcast_data.flags != bat_priv->mcast.flags) {
594                 batadv_mcast_flags_log(bat_priv, mcast_data.flags);
595                 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_MCAST, 2,
596                                                &mcast_data, sizeof(mcast_data));
597                 bat_priv->mcast.flags = mcast_data.flags;
598                 bat_priv->mcast.enabled = true;
599         }
600
601         return !(mcast_data.flags & BATADV_MCAST_WANT_ALL_IPV4 &&
602                  mcast_data.flags & BATADV_MCAST_WANT_ALL_IPV6);
603 }
604
605 /**
606  * __batadv_mcast_mla_update() - update the own MLAs
607  * @bat_priv: the bat priv with all the soft interface information
608  *
609  * Updates the own multicast listener announcements in the translation
610  * table as well as the own, announced multicast tvlv container.
611  *
612  * Note that non-conflicting reads and writes to bat_priv->mcast.mla_list
613  * in batadv_mcast_mla_tt_retract() and batadv_mcast_mla_tt_add() are
614  * ensured by the non-parallel execution of the worker this function
615  * belongs to.
616  */
617 static void __batadv_mcast_mla_update(struct batadv_priv *bat_priv)
618 {
619         struct net_device *soft_iface = bat_priv->soft_iface;
620         struct hlist_head mcast_list = HLIST_HEAD_INIT;
621         int ret;
622
623         if (!batadv_mcast_mla_tvlv_update(bat_priv))
624                 goto update;
625
626         ret = batadv_mcast_mla_softif_get(bat_priv, soft_iface, &mcast_list);
627         if (ret < 0)
628                 goto out;
629
630         ret = batadv_mcast_mla_bridge_get(bat_priv, soft_iface, &mcast_list);
631         if (ret < 0)
632                 goto out;
633
634 update:
635         batadv_mcast_mla_tt_retract(bat_priv, &mcast_list);
636         batadv_mcast_mla_tt_add(bat_priv, &mcast_list);
637
638 out:
639         batadv_mcast_mla_list_free(&mcast_list);
640 }
641
642 /**
643  * batadv_mcast_mla_update() - update the own MLAs
644  * @work: kernel work struct
645  *
646  * Updates the own multicast listener announcements in the translation
647  * table as well as the own, announced multicast tvlv container.
648  *
649  * In the end, reschedules the work timer.
650  */
651 static void batadv_mcast_mla_update(struct work_struct *work)
652 {
653         struct delayed_work *delayed_work;
654         struct batadv_priv_mcast *priv_mcast;
655         struct batadv_priv *bat_priv;
656
657         delayed_work = to_delayed_work(work);
658         priv_mcast = container_of(delayed_work, struct batadv_priv_mcast, work);
659         bat_priv = container_of(priv_mcast, struct batadv_priv, mcast);
660
661         __batadv_mcast_mla_update(bat_priv);
662         batadv_mcast_start_timer(bat_priv);
663 }
664
665 /**
666  * batadv_mcast_is_report_ipv4() - check for IGMP reports
667  * @skb: the ethernet frame destined for the mesh
668  *
669  * This call might reallocate skb data.
670  *
671  * Checks whether the given frame is a valid IGMP report.
672  *
673  * Return: If so then true, otherwise false.
674  */
675 static bool batadv_mcast_is_report_ipv4(struct sk_buff *skb)
676 {
677         if (ip_mc_check_igmp(skb, NULL) < 0)
678                 return false;
679
680         switch (igmp_hdr(skb)->type) {
681         case IGMP_HOST_MEMBERSHIP_REPORT:
682         case IGMPV2_HOST_MEMBERSHIP_REPORT:
683         case IGMPV3_HOST_MEMBERSHIP_REPORT:
684                 return true;
685         }
686
687         return false;
688 }
689
690 /**
691  * batadv_mcast_forw_mode_check_ipv4() - check for optimized forwarding
692  *  potential
693  * @bat_priv: the bat priv with all the soft interface information
694  * @skb: the IPv4 packet to check
695  * @is_unsnoopable: stores whether the destination is snoopable
696  *
697  * Checks whether the given IPv4 packet has the potential to be forwarded with a
698  * mode more optimal than classic flooding.
699  *
700  * Return: If so then 0. Otherwise -EINVAL or -ENOMEM in case of memory
701  * allocation failure.
702  */
703 static int batadv_mcast_forw_mode_check_ipv4(struct batadv_priv *bat_priv,
704                                              struct sk_buff *skb,
705                                              bool *is_unsnoopable)
706 {
707         struct iphdr *iphdr;
708
709         /* We might fail due to out-of-memory -> drop it */
710         if (!pskb_may_pull(skb, sizeof(struct ethhdr) + sizeof(*iphdr)))
711                 return -ENOMEM;
712
713         if (batadv_mcast_is_report_ipv4(skb))
714                 return -EINVAL;
715
716         iphdr = ip_hdr(skb);
717
718         /* TODO: Implement Multicast Router Discovery (RFC4286),
719          * then allow scope > link local, too
720          */
721         if (!ipv4_is_local_multicast(iphdr->daddr))
722                 return -EINVAL;
723
724         /* link-local multicast listeners behind a bridge are
725          * not snoopable (see RFC4541, section 2.1.2.2)
726          */
727         *is_unsnoopable = true;
728
729         return 0;
730 }
731
732 /**
733  * batadv_mcast_is_report_ipv6() - check for MLD reports
734  * @skb: the ethernet frame destined for the mesh
735  *
736  * This call might reallocate skb data.
737  *
738  * Checks whether the given frame is a valid MLD report.
739  *
740  * Return: If so then true, otherwise false.
741  */
742 static bool batadv_mcast_is_report_ipv6(struct sk_buff *skb)
743 {
744         if (ipv6_mc_check_mld(skb, NULL) < 0)
745                 return false;
746
747         switch (icmp6_hdr(skb)->icmp6_type) {
748         case ICMPV6_MGM_REPORT:
749         case ICMPV6_MLD2_REPORT:
750                 return true;
751         }
752
753         return false;
754 }
755
756 /**
757  * batadv_mcast_forw_mode_check_ipv6() - check for optimized forwarding
758  *  potential
759  * @bat_priv: the bat priv with all the soft interface information
760  * @skb: the IPv6 packet to check
761  * @is_unsnoopable: stores whether the destination is snoopable
762  *
763  * Checks whether the given IPv6 packet has the potential to be forwarded with a
764  * mode more optimal than classic flooding.
765  *
766  * Return: If so then 0. Otherwise -EINVAL is or -ENOMEM if we are out of memory
767  */
768 static int batadv_mcast_forw_mode_check_ipv6(struct batadv_priv *bat_priv,
769                                              struct sk_buff *skb,
770                                              bool *is_unsnoopable)
771 {
772         struct ipv6hdr *ip6hdr;
773
774         /* We might fail due to out-of-memory -> drop it */
775         if (!pskb_may_pull(skb, sizeof(struct ethhdr) + sizeof(*ip6hdr)))
776                 return -ENOMEM;
777
778         if (batadv_mcast_is_report_ipv6(skb))
779                 return -EINVAL;
780
781         ip6hdr = ipv6_hdr(skb);
782
783         /* TODO: Implement Multicast Router Discovery (RFC4286),
784          * then allow scope > link local, too
785          */
786         if (IPV6_ADDR_MC_SCOPE(&ip6hdr->daddr) != IPV6_ADDR_SCOPE_LINKLOCAL)
787                 return -EINVAL;
788
789         /* link-local-all-nodes multicast listeners behind a bridge are
790          * not snoopable (see RFC4541, section 3, paragraph 3)
791          */
792         if (ipv6_addr_is_ll_all_nodes(&ip6hdr->daddr))
793                 *is_unsnoopable = true;
794
795         return 0;
796 }
797
798 /**
799  * batadv_mcast_forw_mode_check() - check for optimized forwarding potential
800  * @bat_priv: the bat priv with all the soft interface information
801  * @skb: the multicast frame to check
802  * @is_unsnoopable: stores whether the destination is snoopable
803  *
804  * Checks whether the given multicast ethernet frame has the potential to be
805  * forwarded with a mode more optimal than classic flooding.
806  *
807  * Return: If so then 0. Otherwise -EINVAL is or -ENOMEM if we are out of memory
808  */
809 static int batadv_mcast_forw_mode_check(struct batadv_priv *bat_priv,
810                                         struct sk_buff *skb,
811                                         bool *is_unsnoopable)
812 {
813         struct ethhdr *ethhdr = eth_hdr(skb);
814
815         if (!atomic_read(&bat_priv->multicast_mode))
816                 return -EINVAL;
817
818         if (atomic_read(&bat_priv->mcast.num_disabled))
819                 return -EINVAL;
820
821         switch (ntohs(ethhdr->h_proto)) {
822         case ETH_P_IP:
823                 return batadv_mcast_forw_mode_check_ipv4(bat_priv, skb,
824                                                          is_unsnoopable);
825         case ETH_P_IPV6:
826                 if (!IS_ENABLED(CONFIG_IPV6))
827                         return -EINVAL;
828
829                 return batadv_mcast_forw_mode_check_ipv6(bat_priv, skb,
830                                                          is_unsnoopable);
831         default:
832                 return -EINVAL;
833         }
834 }
835
836 /**
837  * batadv_mcast_forw_want_all_ip_count() - count nodes with unspecific mcast
838  *  interest
839  * @bat_priv: the bat priv with all the soft interface information
840  * @ethhdr: ethernet header of a packet
841  *
842  * Return: the number of nodes which want all IPv4 multicast traffic if the
843  * given ethhdr is from an IPv4 packet or the number of nodes which want all
844  * IPv6 traffic if it matches an IPv6 packet.
845  */
846 static int batadv_mcast_forw_want_all_ip_count(struct batadv_priv *bat_priv,
847                                                struct ethhdr *ethhdr)
848 {
849         switch (ntohs(ethhdr->h_proto)) {
850         case ETH_P_IP:
851                 return atomic_read(&bat_priv->mcast.num_want_all_ipv4);
852         case ETH_P_IPV6:
853                 return atomic_read(&bat_priv->mcast.num_want_all_ipv6);
854         default:
855                 /* we shouldn't be here... */
856                 return 0;
857         }
858 }
859
860 /**
861  * batadv_mcast_forw_tt_node_get() - get a multicast tt node
862  * @bat_priv: the bat priv with all the soft interface information
863  * @ethhdr: the ether header containing the multicast destination
864  *
865  * Return: an orig_node matching the multicast address provided by ethhdr
866  * via a translation table lookup. This increases the returned nodes refcount.
867  */
868 static struct batadv_orig_node *
869 batadv_mcast_forw_tt_node_get(struct batadv_priv *bat_priv,
870                               struct ethhdr *ethhdr)
871 {
872         return batadv_transtable_search(bat_priv, NULL, ethhdr->h_dest,
873                                         BATADV_NO_FLAGS);
874 }
875
876 /**
877  * batadv_mcast_forw_ipv4_node_get() - get a node with an ipv4 flag
878  * @bat_priv: the bat priv with all the soft interface information
879  *
880  * Return: an orig_node which has the BATADV_MCAST_WANT_ALL_IPV4 flag set and
881  * increases its refcount.
882  */
883 static struct batadv_orig_node *
884 batadv_mcast_forw_ipv4_node_get(struct batadv_priv *bat_priv)
885 {
886         struct batadv_orig_node *tmp_orig_node, *orig_node = NULL;
887
888         rcu_read_lock();
889         hlist_for_each_entry_rcu(tmp_orig_node,
890                                  &bat_priv->mcast.want_all_ipv4_list,
891                                  mcast_want_all_ipv4_node) {
892                 if (!kref_get_unless_zero(&tmp_orig_node->refcount))
893                         continue;
894
895                 orig_node = tmp_orig_node;
896                 break;
897         }
898         rcu_read_unlock();
899
900         return orig_node;
901 }
902
903 /**
904  * batadv_mcast_forw_ipv6_node_get() - get a node with an ipv6 flag
905  * @bat_priv: the bat priv with all the soft interface information
906  *
907  * Return: an orig_node which has the BATADV_MCAST_WANT_ALL_IPV6 flag set
908  * and increases its refcount.
909  */
910 static struct batadv_orig_node *
911 batadv_mcast_forw_ipv6_node_get(struct batadv_priv *bat_priv)
912 {
913         struct batadv_orig_node *tmp_orig_node, *orig_node = NULL;
914
915         rcu_read_lock();
916         hlist_for_each_entry_rcu(tmp_orig_node,
917                                  &bat_priv->mcast.want_all_ipv6_list,
918                                  mcast_want_all_ipv6_node) {
919                 if (!kref_get_unless_zero(&tmp_orig_node->refcount))
920                         continue;
921
922                 orig_node = tmp_orig_node;
923                 break;
924         }
925         rcu_read_unlock();
926
927         return orig_node;
928 }
929
930 /**
931  * batadv_mcast_forw_ip_node_get() - get a node with an ipv4/ipv6 flag
932  * @bat_priv: the bat priv with all the soft interface information
933  * @ethhdr: an ethernet header to determine the protocol family from
934  *
935  * Return: an orig_node which has the BATADV_MCAST_WANT_ALL_IPV4 or
936  * BATADV_MCAST_WANT_ALL_IPV6 flag, depending on the provided ethhdr, set and
937  * increases its refcount.
938  */
939 static struct batadv_orig_node *
940 batadv_mcast_forw_ip_node_get(struct batadv_priv *bat_priv,
941                               struct ethhdr *ethhdr)
942 {
943         switch (ntohs(ethhdr->h_proto)) {
944         case ETH_P_IP:
945                 return batadv_mcast_forw_ipv4_node_get(bat_priv);
946         case ETH_P_IPV6:
947                 return batadv_mcast_forw_ipv6_node_get(bat_priv);
948         default:
949                 /* we shouldn't be here... */
950                 return NULL;
951         }
952 }
953
954 /**
955  * batadv_mcast_forw_unsnoop_node_get() - get a node with an unsnoopable flag
956  * @bat_priv: the bat priv with all the soft interface information
957  *
958  * Return: an orig_node which has the BATADV_MCAST_WANT_ALL_UNSNOOPABLES flag
959  * set and increases its refcount.
960  */
961 static struct batadv_orig_node *
962 batadv_mcast_forw_unsnoop_node_get(struct batadv_priv *bat_priv)
963 {
964         struct batadv_orig_node *tmp_orig_node, *orig_node = NULL;
965
966         rcu_read_lock();
967         hlist_for_each_entry_rcu(tmp_orig_node,
968                                  &bat_priv->mcast.want_all_unsnoopables_list,
969                                  mcast_want_all_unsnoopables_node) {
970                 if (!kref_get_unless_zero(&tmp_orig_node->refcount))
971                         continue;
972
973                 orig_node = tmp_orig_node;
974                 break;
975         }
976         rcu_read_unlock();
977
978         return orig_node;
979 }
980
981 /**
982  * batadv_mcast_forw_mode() - check on how to forward a multicast packet
983  * @bat_priv: the bat priv with all the soft interface information
984  * @skb: The multicast packet to check
985  * @orig: an originator to be set to forward the skb to
986  *
987  * Return: the forwarding mode as enum batadv_forw_mode and in case of
988  * BATADV_FORW_SINGLE set the orig to the single originator the skb
989  * should be forwarded to.
990  */
991 enum batadv_forw_mode
992 batadv_mcast_forw_mode(struct batadv_priv *bat_priv, struct sk_buff *skb,
993                        struct batadv_orig_node **orig)
994 {
995         int ret, tt_count, ip_count, unsnoop_count, total_count;
996         bool is_unsnoopable = false;
997         struct ethhdr *ethhdr;
998
999         ret = batadv_mcast_forw_mode_check(bat_priv, skb, &is_unsnoopable);
1000         if (ret == -ENOMEM)
1001                 return BATADV_FORW_NONE;
1002         else if (ret < 0)
1003                 return BATADV_FORW_ALL;
1004
1005         ethhdr = eth_hdr(skb);
1006
1007         tt_count = batadv_tt_global_hash_count(bat_priv, ethhdr->h_dest,
1008                                                BATADV_NO_FLAGS);
1009         ip_count = batadv_mcast_forw_want_all_ip_count(bat_priv, ethhdr);
1010         unsnoop_count = !is_unsnoopable ? 0 :
1011                         atomic_read(&bat_priv->mcast.num_want_all_unsnoopables);
1012
1013         total_count = tt_count + ip_count + unsnoop_count;
1014
1015         switch (total_count) {
1016         case 1:
1017                 if (tt_count)
1018                         *orig = batadv_mcast_forw_tt_node_get(bat_priv, ethhdr);
1019                 else if (ip_count)
1020                         *orig = batadv_mcast_forw_ip_node_get(bat_priv, ethhdr);
1021                 else if (unsnoop_count)
1022                         *orig = batadv_mcast_forw_unsnoop_node_get(bat_priv);
1023
1024                 if (*orig)
1025                         return BATADV_FORW_SINGLE;
1026
1027                 /* fall through */
1028         case 0:
1029                 return BATADV_FORW_NONE;
1030         default:
1031                 return BATADV_FORW_ALL;
1032         }
1033 }
1034
1035 /**
1036  * batadv_mcast_want_unsnoop_update() - update unsnoop counter and list
1037  * @bat_priv: the bat priv with all the soft interface information
1038  * @orig: the orig_node which multicast state might have changed of
1039  * @mcast_flags: flags indicating the new multicast state
1040  *
1041  * If the BATADV_MCAST_WANT_ALL_UNSNOOPABLES flag of this originator,
1042  * orig, has toggled then this method updates counter and list accordingly.
1043  *
1044  * Caller needs to hold orig->mcast_handler_lock.
1045  */
1046 static void batadv_mcast_want_unsnoop_update(struct batadv_priv *bat_priv,
1047                                              struct batadv_orig_node *orig,
1048                                              u8 mcast_flags)
1049 {
1050         struct hlist_node *node = &orig->mcast_want_all_unsnoopables_node;
1051         struct hlist_head *head = &bat_priv->mcast.want_all_unsnoopables_list;
1052
1053         lockdep_assert_held(&orig->mcast_handler_lock);
1054
1055         /* switched from flag unset to set */
1056         if (mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES &&
1057             !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES)) {
1058                 atomic_inc(&bat_priv->mcast.num_want_all_unsnoopables);
1059
1060                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
1061                 /* flag checks above + mcast_handler_lock prevents this */
1062                 WARN_ON(!hlist_unhashed(node));
1063
1064                 hlist_add_head_rcu(node, head);
1065                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
1066         /* switched from flag set to unset */
1067         } else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) &&
1068                    orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) {
1069                 atomic_dec(&bat_priv->mcast.num_want_all_unsnoopables);
1070
1071                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
1072                 /* flag checks above + mcast_handler_lock prevents this */
1073                 WARN_ON(hlist_unhashed(node));
1074
1075                 hlist_del_init_rcu(node);
1076                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
1077         }
1078 }
1079
1080 /**
1081  * batadv_mcast_want_ipv4_update() - update want-all-ipv4 counter and list
1082  * @bat_priv: the bat priv with all the soft interface information
1083  * @orig: the orig_node which multicast state might have changed of
1084  * @mcast_flags: flags indicating the new multicast state
1085  *
1086  * If the BATADV_MCAST_WANT_ALL_IPV4 flag of this originator, orig, has
1087  * toggled then this method updates counter and list accordingly.
1088  *
1089  * Caller needs to hold orig->mcast_handler_lock.
1090  */
1091 static void batadv_mcast_want_ipv4_update(struct batadv_priv *bat_priv,
1092                                           struct batadv_orig_node *orig,
1093                                           u8 mcast_flags)
1094 {
1095         struct hlist_node *node = &orig->mcast_want_all_ipv4_node;
1096         struct hlist_head *head = &bat_priv->mcast.want_all_ipv4_list;
1097
1098         lockdep_assert_held(&orig->mcast_handler_lock);
1099
1100         /* switched from flag unset to set */
1101         if (mcast_flags & BATADV_MCAST_WANT_ALL_IPV4 &&
1102             !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV4)) {
1103                 atomic_inc(&bat_priv->mcast.num_want_all_ipv4);
1104
1105                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
1106                 /* flag checks above + mcast_handler_lock prevents this */
1107                 WARN_ON(!hlist_unhashed(node));
1108
1109                 hlist_add_head_rcu(node, head);
1110                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
1111         /* switched from flag set to unset */
1112         } else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_IPV4) &&
1113                    orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV4) {
1114                 atomic_dec(&bat_priv->mcast.num_want_all_ipv4);
1115
1116                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
1117                 /* flag checks above + mcast_handler_lock prevents this */
1118                 WARN_ON(hlist_unhashed(node));
1119
1120                 hlist_del_init_rcu(node);
1121                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
1122         }
1123 }
1124
1125 /**
1126  * batadv_mcast_want_ipv6_update() - update want-all-ipv6 counter and list
1127  * @bat_priv: the bat priv with all the soft interface information
1128  * @orig: the orig_node which multicast state might have changed of
1129  * @mcast_flags: flags indicating the new multicast state
1130  *
1131  * If the BATADV_MCAST_WANT_ALL_IPV6 flag of this originator, orig, has
1132  * toggled then this method updates counter and list accordingly.
1133  *
1134  * Caller needs to hold orig->mcast_handler_lock.
1135  */
1136 static void batadv_mcast_want_ipv6_update(struct batadv_priv *bat_priv,
1137                                           struct batadv_orig_node *orig,
1138                                           u8 mcast_flags)
1139 {
1140         struct hlist_node *node = &orig->mcast_want_all_ipv6_node;
1141         struct hlist_head *head = &bat_priv->mcast.want_all_ipv6_list;
1142
1143         lockdep_assert_held(&orig->mcast_handler_lock);
1144
1145         /* switched from flag unset to set */
1146         if (mcast_flags & BATADV_MCAST_WANT_ALL_IPV6 &&
1147             !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV6)) {
1148                 atomic_inc(&bat_priv->mcast.num_want_all_ipv6);
1149
1150                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
1151                 /* flag checks above + mcast_handler_lock prevents this */
1152                 WARN_ON(!hlist_unhashed(node));
1153
1154                 hlist_add_head_rcu(node, head);
1155                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
1156         /* switched from flag set to unset */
1157         } else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_IPV6) &&
1158                    orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV6) {
1159                 atomic_dec(&bat_priv->mcast.num_want_all_ipv6);
1160
1161                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
1162                 /* flag checks above + mcast_handler_lock prevents this */
1163                 WARN_ON(hlist_unhashed(node));
1164
1165                 hlist_del_init_rcu(node);
1166                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
1167         }
1168 }
1169
1170 /**
1171  * batadv_mcast_tvlv_ogm_handler() - process incoming multicast tvlv container
1172  * @bat_priv: the bat priv with all the soft interface information
1173  * @orig: the orig_node of the ogm
1174  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
1175  * @tvlv_value: tvlv buffer containing the multicast data
1176  * @tvlv_value_len: tvlv buffer length
1177  */
1178 static void batadv_mcast_tvlv_ogm_handler(struct batadv_priv *bat_priv,
1179                                           struct batadv_orig_node *orig,
1180                                           u8 flags,
1181                                           void *tvlv_value,
1182                                           u16 tvlv_value_len)
1183 {
1184         bool orig_mcast_enabled = !(flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
1185         u8 mcast_flags = BATADV_NO_FLAGS;
1186         bool orig_initialized;
1187
1188         if (orig_mcast_enabled && tvlv_value &&
1189             tvlv_value_len >= sizeof(mcast_flags))
1190                 mcast_flags = *(u8 *)tvlv_value;
1191
1192         spin_lock_bh(&orig->mcast_handler_lock);
1193         orig_initialized = test_bit(BATADV_ORIG_CAPA_HAS_MCAST,
1194                                     &orig->capa_initialized);
1195
1196         /* If mcast support is turned on decrease the disabled mcast node
1197          * counter only if we had increased it for this node before. If this
1198          * is a completely new orig_node no need to decrease the counter.
1199          */
1200         if (orig_mcast_enabled &&
1201             !test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities)) {
1202                 if (orig_initialized)
1203                         atomic_dec(&bat_priv->mcast.num_disabled);
1204                 set_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities);
1205         /* If mcast support is being switched off or if this is an initial
1206          * OGM without mcast support then increase the disabled mcast
1207          * node counter.
1208          */
1209         } else if (!orig_mcast_enabled &&
1210                    (test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities) ||
1211                     !orig_initialized)) {
1212                 atomic_inc(&bat_priv->mcast.num_disabled);
1213                 clear_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities);
1214         }
1215
1216         set_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capa_initialized);
1217
1218         batadv_mcast_want_unsnoop_update(bat_priv, orig, mcast_flags);
1219         batadv_mcast_want_ipv4_update(bat_priv, orig, mcast_flags);
1220         batadv_mcast_want_ipv6_update(bat_priv, orig, mcast_flags);
1221
1222         orig->mcast_flags = mcast_flags;
1223         spin_unlock_bh(&orig->mcast_handler_lock);
1224 }
1225
1226 /**
1227  * batadv_mcast_init() - initialize the multicast optimizations structures
1228  * @bat_priv: the bat priv with all the soft interface information
1229  */
1230 void batadv_mcast_init(struct batadv_priv *bat_priv)
1231 {
1232         batadv_tvlv_handler_register(bat_priv, batadv_mcast_tvlv_ogm_handler,
1233                                      NULL, BATADV_TVLV_MCAST, 2,
1234                                      BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
1235
1236         INIT_DELAYED_WORK(&bat_priv->mcast.work, batadv_mcast_mla_update);
1237         batadv_mcast_start_timer(bat_priv);
1238 }
1239
1240 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
1241 /**
1242  * batadv_mcast_flags_print_header() - print own mcast flags to debugfs table
1243  * @bat_priv: the bat priv with all the soft interface information
1244  * @seq: debugfs table seq_file struct
1245  *
1246  * Prints our own multicast flags including a more specific reason why
1247  * they are set, that is prints the bridge and querier state too, to
1248  * the debugfs table specified via @seq.
1249  */
1250 static void batadv_mcast_flags_print_header(struct batadv_priv *bat_priv,
1251                                             struct seq_file *seq)
1252 {
1253         u8 flags = bat_priv->mcast.flags;
1254         char querier4, querier6, shadowing4, shadowing6;
1255         bool bridged = bat_priv->mcast.bridged;
1256
1257         if (bridged) {
1258                 querier4 = bat_priv->mcast.querier_ipv4.exists ? '.' : '4';
1259                 querier6 = bat_priv->mcast.querier_ipv6.exists ? '.' : '6';
1260                 shadowing4 = bat_priv->mcast.querier_ipv4.shadowing ? '4' : '.';
1261                 shadowing6 = bat_priv->mcast.querier_ipv6.shadowing ? '6' : '.';
1262         } else {
1263                 querier4 = '?';
1264                 querier6 = '?';
1265                 shadowing4 = '?';
1266                 shadowing6 = '?';
1267         }
1268
1269         seq_printf(seq, "Multicast flags (own flags: [%c%c%c])\n",
1270                    (flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) ? 'U' : '.',
1271                    (flags & BATADV_MCAST_WANT_ALL_IPV4) ? '4' : '.',
1272                    (flags & BATADV_MCAST_WANT_ALL_IPV6) ? '6' : '.');
1273         seq_printf(seq, "* Bridged [U]\t\t\t\t%c\n", bridged ? 'U' : '.');
1274         seq_printf(seq, "* No IGMP/MLD Querier [4/6]:\t\t%c/%c\n",
1275                    querier4, querier6);
1276         seq_printf(seq, "* Shadowing IGMP/MLD Querier [4/6]:\t%c/%c\n",
1277                    shadowing4, shadowing6);
1278         seq_puts(seq, "-------------------------------------------\n");
1279         seq_printf(seq, "       %-10s %s\n", "Originator", "Flags");
1280 }
1281
1282 /**
1283  * batadv_mcast_flags_seq_print_text() - print the mcast flags of other nodes
1284  * @seq: seq file to print on
1285  * @offset: not used
1286  *
1287  * This prints a table of (primary) originators and their according
1288  * multicast flags, including (in the header) our own.
1289  *
1290  * Return: always 0
1291  */
1292 int batadv_mcast_flags_seq_print_text(struct seq_file *seq, void *offset)
1293 {
1294         struct net_device *net_dev = (struct net_device *)seq->private;
1295         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1296         struct batadv_hard_iface *primary_if;
1297         struct batadv_hashtable *hash = bat_priv->orig_hash;
1298         struct batadv_orig_node *orig_node;
1299         struct hlist_head *head;
1300         u8 flags;
1301         u32 i;
1302
1303         primary_if = batadv_seq_print_text_primary_if_get(seq);
1304         if (!primary_if)
1305                 return 0;
1306
1307         batadv_mcast_flags_print_header(bat_priv, seq);
1308
1309         for (i = 0; i < hash->size; i++) {
1310                 head = &hash->table[i];
1311
1312                 rcu_read_lock();
1313                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1314                         if (!test_bit(BATADV_ORIG_CAPA_HAS_MCAST,
1315                                       &orig_node->capa_initialized))
1316                                 continue;
1317
1318                         if (!test_bit(BATADV_ORIG_CAPA_HAS_MCAST,
1319                                       &orig_node->capabilities)) {
1320                                 seq_printf(seq, "%pM -\n", orig_node->orig);
1321                                 continue;
1322                         }
1323
1324                         flags = orig_node->mcast_flags;
1325
1326                         seq_printf(seq, "%pM [%c%c%c]\n", orig_node->orig,
1327                                    (flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES)
1328                                    ? 'U' : '.',
1329                                    (flags & BATADV_MCAST_WANT_ALL_IPV4)
1330                                    ? '4' : '.',
1331                                    (flags & BATADV_MCAST_WANT_ALL_IPV6)
1332                                    ? '6' : '.');
1333                 }
1334                 rcu_read_unlock();
1335         }
1336
1337         batadv_hardif_put(primary_if);
1338
1339         return 0;
1340 }
1341 #endif
1342
1343 /**
1344  * batadv_mcast_mesh_info_put() - put multicast info into a netlink message
1345  * @msg: buffer for the message
1346  * @bat_priv: the bat priv with all the soft interface information
1347  *
1348  * Return: 0 or error code.
1349  */
1350 int batadv_mcast_mesh_info_put(struct sk_buff *msg,
1351                                struct batadv_priv *bat_priv)
1352 {
1353         u32 flags = bat_priv->mcast.flags;
1354         u32 flags_priv = BATADV_NO_FLAGS;
1355
1356         if (bat_priv->mcast.bridged) {
1357                 flags_priv |= BATADV_MCAST_FLAGS_BRIDGED;
1358
1359                 if (bat_priv->mcast.querier_ipv4.exists)
1360                         flags_priv |= BATADV_MCAST_FLAGS_QUERIER_IPV4_EXISTS;
1361                 if (bat_priv->mcast.querier_ipv6.exists)
1362                         flags_priv |= BATADV_MCAST_FLAGS_QUERIER_IPV6_EXISTS;
1363                 if (bat_priv->mcast.querier_ipv4.shadowing)
1364                         flags_priv |= BATADV_MCAST_FLAGS_QUERIER_IPV4_SHADOWING;
1365                 if (bat_priv->mcast.querier_ipv6.shadowing)
1366                         flags_priv |= BATADV_MCAST_FLAGS_QUERIER_IPV6_SHADOWING;
1367         }
1368
1369         if (nla_put_u32(msg, BATADV_ATTR_MCAST_FLAGS, flags) ||
1370             nla_put_u32(msg, BATADV_ATTR_MCAST_FLAGS_PRIV, flags_priv))
1371                 return -EMSGSIZE;
1372
1373         return 0;
1374 }
1375
1376 /**
1377  * batadv_mcast_flags_dump_entry() - dump one entry of the multicast flags table
1378  *  to a netlink socket
1379  * @msg: buffer for the message
1380  * @portid: netlink port
1381  * @seq: Sequence number of netlink message
1382  * @orig_node: originator to dump the multicast flags of
1383  *
1384  * Return: 0 or error code.
1385  */
1386 static int
1387 batadv_mcast_flags_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
1388                               struct batadv_orig_node *orig_node)
1389 {
1390         void *hdr;
1391
1392         hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
1393                           NLM_F_MULTI, BATADV_CMD_GET_MCAST_FLAGS);
1394         if (!hdr)
1395                 return -ENOBUFS;
1396
1397         if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
1398                     orig_node->orig)) {
1399                 genlmsg_cancel(msg, hdr);
1400                 return -EMSGSIZE;
1401         }
1402
1403         if (test_bit(BATADV_ORIG_CAPA_HAS_MCAST,
1404                      &orig_node->capabilities)) {
1405                 if (nla_put_u32(msg, BATADV_ATTR_MCAST_FLAGS,
1406                                 orig_node->mcast_flags)) {
1407                         genlmsg_cancel(msg, hdr);
1408                         return -EMSGSIZE;
1409                 }
1410         }
1411
1412         genlmsg_end(msg, hdr);
1413         return 0;
1414 }
1415
1416 /**
1417  * batadv_mcast_flags_dump_bucket() - dump one bucket of the multicast flags
1418  *  table to a netlink socket
1419  * @msg: buffer for the message
1420  * @portid: netlink port
1421  * @seq: Sequence number of netlink message
1422  * @head: bucket to dump
1423  * @idx_skip: How many entries to skip
1424  *
1425  * Return: 0 or error code.
1426  */
1427 static int
1428 batadv_mcast_flags_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
1429                                struct hlist_head *head, long *idx_skip)
1430 {
1431         struct batadv_orig_node *orig_node;
1432         long idx = 0;
1433
1434         rcu_read_lock();
1435         hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1436                 if (!test_bit(BATADV_ORIG_CAPA_HAS_MCAST,
1437                               &orig_node->capa_initialized))
1438                         continue;
1439
1440                 if (idx < *idx_skip)
1441                         goto skip;
1442
1443                 if (batadv_mcast_flags_dump_entry(msg, portid, seq,
1444                                                   orig_node)) {
1445                         rcu_read_unlock();
1446                         *idx_skip = idx;
1447
1448                         return -EMSGSIZE;
1449                 }
1450
1451 skip:
1452                 idx++;
1453         }
1454         rcu_read_unlock();
1455
1456         return 0;
1457 }
1458
1459 /**
1460  * __batadv_mcast_flags_dump() - dump multicast flags table to a netlink socket
1461  * @msg: buffer for the message
1462  * @portid: netlink port
1463  * @seq: Sequence number of netlink message
1464  * @bat_priv: the bat priv with all the soft interface information
1465  * @bucket: current bucket to dump
1466  * @idx: index in current bucket to the next entry to dump
1467  *
1468  * Return: 0 or error code.
1469  */
1470 static int
1471 __batadv_mcast_flags_dump(struct sk_buff *msg, u32 portid, u32 seq,
1472                           struct batadv_priv *bat_priv, long *bucket, long *idx)
1473 {
1474         struct batadv_hashtable *hash = bat_priv->orig_hash;
1475         long bucket_tmp = *bucket;
1476         struct hlist_head *head;
1477         long idx_tmp = *idx;
1478
1479         while (bucket_tmp < hash->size) {
1480                 head = &hash->table[bucket_tmp];
1481
1482                 if (batadv_mcast_flags_dump_bucket(msg, portid, seq, head,
1483                                                    &idx_tmp))
1484                         break;
1485
1486                 bucket_tmp++;
1487                 idx_tmp = 0;
1488         }
1489
1490         *bucket = bucket_tmp;
1491         *idx = idx_tmp;
1492
1493         return msg->len;
1494 }
1495
1496 /**
1497  * batadv_mcast_netlink_get_primary() - get primary interface from netlink
1498  *  callback
1499  * @cb: netlink callback structure
1500  * @primary_if: the primary interface pointer to return the result in
1501  *
1502  * Return: 0 or error code.
1503  */
1504 static int
1505 batadv_mcast_netlink_get_primary(struct netlink_callback *cb,
1506                                  struct batadv_hard_iface **primary_if)
1507 {
1508         struct batadv_hard_iface *hard_iface = NULL;
1509         struct net *net = sock_net(cb->skb->sk);
1510         struct net_device *soft_iface;
1511         struct batadv_priv *bat_priv;
1512         int ifindex;
1513         int ret = 0;
1514
1515         ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
1516         if (!ifindex)
1517                 return -EINVAL;
1518
1519         soft_iface = dev_get_by_index(net, ifindex);
1520         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1521                 ret = -ENODEV;
1522                 goto out;
1523         }
1524
1525         bat_priv = netdev_priv(soft_iface);
1526
1527         hard_iface = batadv_primary_if_get_selected(bat_priv);
1528         if (!hard_iface || hard_iface->if_status != BATADV_IF_ACTIVE) {
1529                 ret = -ENOENT;
1530                 goto out;
1531         }
1532
1533 out:
1534         if (soft_iface)
1535                 dev_put(soft_iface);
1536
1537         if (!ret && primary_if)
1538                 *primary_if = hard_iface;
1539         else
1540                 batadv_hardif_put(hard_iface);
1541
1542         return ret;
1543 }
1544
1545 /**
1546  * batadv_mcast_flags_dump() - dump multicast flags table to a netlink socket
1547  * @msg: buffer for the message
1548  * @cb: callback structure containing arguments
1549  *
1550  * Return: message length.
1551  */
1552 int batadv_mcast_flags_dump(struct sk_buff *msg, struct netlink_callback *cb)
1553 {
1554         struct batadv_hard_iface *primary_if = NULL;
1555         int portid = NETLINK_CB(cb->skb).portid;
1556         struct batadv_priv *bat_priv;
1557         long *bucket = &cb->args[0];
1558         long *idx = &cb->args[1];
1559         int ret;
1560
1561         ret = batadv_mcast_netlink_get_primary(cb, &primary_if);
1562         if (ret)
1563                 return ret;
1564
1565         bat_priv = netdev_priv(primary_if->soft_iface);
1566         ret = __batadv_mcast_flags_dump(msg, portid, cb->nlh->nlmsg_seq,
1567                                         bat_priv, bucket, idx);
1568
1569         batadv_hardif_put(primary_if);
1570         return ret;
1571 }
1572
1573 /**
1574  * batadv_mcast_free() - free the multicast optimizations structures
1575  * @bat_priv: the bat priv with all the soft interface information
1576  */
1577 void batadv_mcast_free(struct batadv_priv *bat_priv)
1578 {
1579         cancel_delayed_work_sync(&bat_priv->mcast.work);
1580
1581         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_MCAST, 2);
1582         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_MCAST, 2);
1583
1584         /* safely calling outside of worker, as worker was canceled above */
1585         batadv_mcast_mla_tt_retract(bat_priv, NULL);
1586 }
1587
1588 /**
1589  * batadv_mcast_purge_orig() - reset originator global mcast state modifications
1590  * @orig: the originator which is going to get purged
1591  */
1592 void batadv_mcast_purge_orig(struct batadv_orig_node *orig)
1593 {
1594         struct batadv_priv *bat_priv = orig->bat_priv;
1595
1596         spin_lock_bh(&orig->mcast_handler_lock);
1597
1598         if (!test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities) &&
1599             test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capa_initialized))
1600                 atomic_dec(&bat_priv->mcast.num_disabled);
1601
1602         batadv_mcast_want_unsnoop_update(bat_priv, orig, BATADV_NO_FLAGS);
1603         batadv_mcast_want_ipv4_update(bat_priv, orig, BATADV_NO_FLAGS);
1604         batadv_mcast_want_ipv6_update(bat_priv, orig, BATADV_NO_FLAGS);
1605
1606         spin_unlock_bh(&orig->mcast_handler_lock);
1607 }