net/batman-adv/multicast.c

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