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