Quelle  multicast_forw.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) B.A.T.M.A.N. contributors:
 *
 * Linus Lüssing
 */

#include "multicast.h"
#include "main.h"

#include <linux/bug.h>
#include <linux/build_bug.h>
#include <linux/byteorder/generic.h>
#include <linux/compiler.h>
#include <linux/errno.h>
#include <linux/etherdevice.h>
#include <linux/gfp.h>
#include <linux/if_ether.h>
#include <linux/if_vlan.h>
#include <linux/ipv6.h>
#include <linux/limits.h>
#include <linux/netdevice.h>
#include <linux/rculist.h>
#include <linux/rcupdate.h>
#include <linux/skbuff.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/types.h>
#include <uapi/linux/batadv_packet.h>

#include "bridge_loop_avoidance.h"
#include "originator.h"
#include "send.h"
#include "translation-table.h"

#define batadv_mcast_forw_tracker_for_each_dest(dest, num_dests) \
 for (; num_dests; num_dests--, (dest) += ETH_ALEN)

#define batadv_mcast_forw_tracker_for_each_dest2(dest1, dest2, num_dests) \
 for (; num_dests; num_dests--, (dest1) += ETH_ALEN, (dest2) += ETH_ALEN)

/**
 * batadv_mcast_forw_skb_push() - skb_push and memorize amount of pushed bytes
 * @skb: the skb to push onto
 * @size: the amount of bytes to push
 * @len: stores the total amount of bytes pushed
 *
 * Performs an skb_push() onto the given skb and adds the amount of pushed bytes
 * to the given len pointer.
 *
 * Return: the return value of the skb_push() call.
 */
static void *batadv_mcast_forw_skb_push(struct sk_buff *skb, size_t size,
     unsigned short *len)
{
 *len += size;
 return skb_push(skb, size);
}

/**
 * batadv_mcast_forw_push_padding() - push 2 padding bytes to skb's front
 * @skb: the skb to push onto
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Pushes two padding bytes to the front of the given skb.
 *
 * Return: On success a pointer to the first byte of the two pushed padding
 * bytes within the skb. NULL otherwise.
 */
static char *
batadv_mcast_forw_push_padding(struct sk_buff *skb, unsigned short *tvlv_len)
{
 const int pad_len = 2;
 char *padding;

 if (skb_headroom(skb) < pad_len)
  return NULL;

 padding = batadv_mcast_forw_skb_push(skb, pad_len, tvlv_len);
 memset(padding, 0, pad_len);

 return padding;
}

/**
 * batadv_mcast_forw_push_est_padding() - push padding bytes if necessary
 * @skb: the skb to potentially push the padding onto
 * @count: the (estimated) number of originators the multicast packet needs to
 *  be sent to
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * If the number of destination entries is even then this adds two
 * padding bytes to the end of the tracker TVLV.
 *
 * Return: true on success or if no padding is needed, false otherwise.
 */
static bool
batadv_mcast_forw_push_est_padding(struct sk_buff *skb, int count,
       unsigned short *tvlv_len)
{
 if (!(count % 2) && !batadv_mcast_forw_push_padding(skb, tvlv_len))
  return false;

 return true;
}

/**
 * batadv_mcast_forw_orig_entry() - get orig_node from an hlist node
 * @node: the hlist node to get the orig_node from
 * @entry_offset: the offset of the hlist node within the orig_node struct
 *
 * Return: The orig_node containing the hlist node on success, NULL on error.
 */
static struct batadv_orig_node *
batadv_mcast_forw_orig_entry(struct hlist_node *node,
        size_t entry_offset)
{
 /* sanity check */
 switch (entry_offset) {
 case offsetof(struct batadv_orig_node, mcast_want_all_ipv4_node):
 case offsetof(struct batadv_orig_node, mcast_want_all_ipv6_node):
 case offsetof(struct batadv_orig_node, mcast_want_all_rtr4_node):
 case offsetof(struct batadv_orig_node, mcast_want_all_rtr6_node):
  break;
 default:
  WARN_ON(1);
  return NULL;
 }

 return (struct batadv_orig_node *)((void *)node - entry_offset);
}

/**
 * batadv_mcast_forw_push_dest() - push an originator MAC address onto an skb
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the destination address onto
 * @vid: the vlan identifier
 * @orig_node: the originator node to get the MAC address from
 * @num_dests: a pointer to store the number of pushed addresses in
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * If the orig_node is a BLA backbone gateway, if there is not enough skb
 * headroom available or if num_dests is already at its maximum (65535) then
 * neither the skb nor num_dests is changed. Otherwise the originator's MAC
 * address is pushed onto the given skb and num_dests incremented by one.
 *
 * Return: true if the orig_node is a backbone gateway or if an orig address
 *  was pushed successfully, false otherwise.
 */
static bool batadv_mcast_forw_push_dest(struct batadv_priv *bat_priv,
     struct sk_buff *skb, unsigned short vid,
     struct batadv_orig_node *orig_node,
     unsigned short *num_dests,
     unsigned short *tvlv_len)
{
 BUILD_BUG_ON(sizeof_field(struct batadv_tvlv_mcast_tracker, num_dests)
       != sizeof(__be16));

 /* Avoid sending to other BLA gateways - they already got the frame from
  * the LAN side we share with them.
  * TODO: Refactor to take BLA into account earlier in mode check.
 */
 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
  return true;

 if (skb_headroom(skb) < ETH_ALEN || *num_dests == U16_MAX)
  return false;

 batadv_mcast_forw_skb_push(skb, ETH_ALEN, tvlv_len);
 ether_addr_copy(skb->data, orig_node->orig);
 (*num_dests)++;

 return true;
}

/**
 * batadv_mcast_forw_push_dests_list() - push originators from list onto an skb
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the destination addresses onto
 * @vid: the vlan identifier
 * @head: the list to gather originators from
 * @entry_offset: offset of an hlist node in an orig_node structure
 * @num_dests: a pointer to store the number of pushed addresses in
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Push the MAC addresses of all originators in the given list onto the given
 * skb.
 *
 * Return: true on success, false otherwise.
 */
static int batadv_mcast_forw_push_dests_list(struct batadv_priv *bat_priv,
          struct sk_buff *skb,
          unsigned short vid,
          struct hlist_head *head,
          size_t entry_offset,
          unsigned short *num_dests,
          unsigned short *tvlv_len)
{
 struct hlist_node *node;
 struct batadv_orig_node *orig_node;

 rcu_read_lock();
 __hlist_for_each_rcu(node, head) {
  orig_node = batadv_mcast_forw_orig_entry(node, entry_offset);
  if (!orig_node ||
      !batadv_mcast_forw_push_dest(bat_priv, skb, vid, orig_node,
       num_dests, tvlv_len)) {
   rcu_read_unlock();
   return false;
  }
 }
 rcu_read_unlock();

 return true;
}

/**
 * batadv_mcast_forw_push_tt() - push originators with interest through TT
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the destination addresses onto
 * @vid: the vlan identifier
 * @num_dests: a pointer to store the number of pushed addresses in
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Push the MAC addresses of all originators which have indicated interest in
 * this multicast packet through the translation table onto the given skb.
 *
 * Return: true on success, false otherwise.
 */
static bool
batadv_mcast_forw_push_tt(struct batadv_priv *bat_priv, struct sk_buff *skb,
     unsigned short vid, unsigned short *num_dests,
     unsigned short *tvlv_len)
{
 struct batadv_tt_orig_list_entry *orig_entry;

 struct batadv_tt_global_entry *tt_global;
 const u8 *addr = eth_hdr(skb)->h_dest;

 /* ok */
 int ret = true;

 tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);
 if (!tt_global)
  goto out;

 rcu_read_lock();
 hlist_for_each_entry_rcu(orig_entry, &tt_global->orig_list, list) {
  if (!batadv_mcast_forw_push_dest(bat_priv, skb, vid,
       orig_entry->orig_node,
       num_dests, tvlv_len)) {
   ret = false;
   break;
  }
 }
 rcu_read_unlock();

 batadv_tt_global_entry_put(tt_global);

out:
 return ret;
}

/**
 * batadv_mcast_forw_push_want_all() - push originators with want-all flag
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the destination addresses onto
 * @vid: the vlan identifier
 * @num_dests: a pointer to store the number of pushed addresses in
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Push the MAC addresses of all originators which have indicated interest in
 * this multicast packet through the want-all flag onto the given skb.
 *
 * Return: true on success, false otherwise.
 */
static bool batadv_mcast_forw_push_want_all(struct batadv_priv *bat_priv,
         struct sk_buff *skb,
         unsigned short vid,
         unsigned short *num_dests,
         unsigned short *tvlv_len)
{
 struct hlist_head *head = NULL;
 size_t offset;
 int ret;

 switch (eth_hdr(skb)->h_proto) {
 case htons(ETH_P_IP):
  head = &bat_priv->mcast.want_all_ipv4_list;
  offset = offsetof(struct batadv_orig_node,
      mcast_want_all_ipv4_node);
  break;
 case htons(ETH_P_IPV6):
  head = &bat_priv->mcast.want_all_ipv6_list;
  offset = offsetof(struct batadv_orig_node,
      mcast_want_all_ipv6_node);
  break;
 default:
  return false;
 }

 ret = batadv_mcast_forw_push_dests_list(bat_priv, skb, vid, head,
      offset, num_dests, tvlv_len);
 if (!ret)
  return false;

 return true;
}

/**
 * batadv_mcast_forw_push_want_rtr() - push originators with want-router flag
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the destination addresses onto
 * @vid: the vlan identifier
 * @num_dests: a pointer to store the number of pushed addresses in
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Push the MAC addresses of all originators which have indicated interest in
 * this multicast packet through the want-all-rtr flag onto the given skb.
 *
 * Return: true on success, false otherwise.
 */
static bool batadv_mcast_forw_push_want_rtr(struct batadv_priv *bat_priv,
         struct sk_buff *skb,
         unsigned short vid,
         unsigned short *num_dests,
         unsigned short *tvlv_len)
{
 struct hlist_head *head = NULL;
 size_t offset;
 int ret;

 switch (eth_hdr(skb)->h_proto) {
 case htons(ETH_P_IP):
  head = &bat_priv->mcast.want_all_rtr4_list;
  offset = offsetof(struct batadv_orig_node,
      mcast_want_all_rtr4_node);
  break;
 case htons(ETH_P_IPV6):
  head = &bat_priv->mcast.want_all_rtr6_list;
  offset = offsetof(struct batadv_orig_node,
      mcast_want_all_rtr6_node);
  break;
 default:
  return false;
 }

 ret = batadv_mcast_forw_push_dests_list(bat_priv, skb, vid, head,
      offset, num_dests, tvlv_len);
 if (!ret)
  return false;

 return true;
}

/**
 * batadv_mcast_forw_scrape() - remove bytes within skb data
 * @skb: the skb to remove bytes from
 * @offset: the offset from the skb data from which to scrape
 * @len: the amount of bytes to scrape starting from the offset
 *
 * Scrapes/removes len bytes from the given skb at the given offset from the
 * skb data.
 *
 * Caller needs to ensure that the region from the skb data's start up
 * to/including the to be removed bytes are linearized.
 */
static void batadv_mcast_forw_scrape(struct sk_buff *skb,
         unsigned short offset,
         unsigned short len)
{
 char *to, *from;

 SKB_LINEAR_ASSERT(skb);

 to = skb_pull(skb, len);
 from = to - len;

 memmove(to, from, offset);
}

/**
 * batadv_mcast_forw_push_scrape_padding() - remove TVLV padding
 * @skb: the skb to potentially adjust the TVLV's padding on
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Remove two padding bytes from the end of the multicast tracker TVLV,
 * from before the payload data.
 *
 * Caller needs to ensure that the TVLV bytes are linearized.
 */
static void batadv_mcast_forw_push_scrape_padding(struct sk_buff *skb,
        unsigned short *tvlv_len)
{
 const int pad_len = 2;

 batadv_mcast_forw_scrape(skb, *tvlv_len - pad_len, pad_len);
 *tvlv_len -= pad_len;
}

/**
 * batadv_mcast_forw_push_insert_padding() - insert TVLV padding
 * @skb: the skb to potentially adjust the TVLV's padding on
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Inserts two padding bytes at the end of the multicast tracker TVLV,
 * before the payload data in the given skb.
 *
 * Return: true on success, false otherwise.
 */
static bool batadv_mcast_forw_push_insert_padding(struct sk_buff *skb,
        unsigned short *tvlv_len)
{
 unsigned short offset = *tvlv_len;
 char *to, *from = skb->data;

 to = batadv_mcast_forw_push_padding(skb, tvlv_len);
 if (!to)
  return false;

 memmove(to, from, offset);
 memset(to + offset, 0, *tvlv_len - offset);
 return true;
}

/**
 * batadv_mcast_forw_push_adjust_padding() - adjust padding if necessary
 * @skb: the skb to potentially adjust the TVLV's padding on
 * @count: the estimated number of originators the multicast packet needs to
 *  be sent to
 * @num_dests_pushed: the number of originators that were actually added to the
 *  multicast packet's tracker TVLV
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Adjusts the padding in the multicast packet's tracker TVLV depending on the
 * initially estimated amount of destinations versus the amount of destinations
 * that were actually added to the tracker TVLV.
 *
 * If the initial estimate was correct or at least the oddness was the same then
 * no padding adjustment is performed.
 * If the initially estimated number was even, so padding was initially added,
 * but it turned out to be odd then padding is removed.
 * If the initially estimated number was odd, so no padding was initially added,
 * but it turned out to be even then padding is added.
 *
 * Return: true if no padding adjustment is needed or the adjustment was
 * successful, false otherwise.
 */
static bool
batadv_mcast_forw_push_adjust_padding(struct sk_buff *skb, int *count,
          unsigned short num_dests_pushed,
          unsigned short *tvlv_len)
{
 int ret = true;

 if (likely((num_dests_pushed % 2) == (*count % 2)))
  goto out;

 /**
  * estimated even number of destinations, but turned out to be odd
  * -> remove padding
 */
 if (!(*count % 2) && (num_dests_pushed % 2))
  batadv_mcast_forw_push_scrape_padding(skb, tvlv_len);
 /**
  * estimated odd number of destinations, but turned out to be even
  * -> add padding
 */
 else if ((*count % 2) && (!(num_dests_pushed % 2)))
  ret = batadv_mcast_forw_push_insert_padding(skb, tvlv_len);

out:
 *count = num_dests_pushed;
 return ret;
}

/**
 * batadv_mcast_forw_push_dests() - push originator addresses onto an skb
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the destination addresses onto
 * @vid: the vlan identifier
 * @is_routable: indicates whether the destination is routable
 * @count: the number of originators the multicast packet needs to be sent to
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Push the MAC addresses of all originators which have indicated interest in
 * this multicast packet onto the given skb.
 *
 * Return: -ENOMEM if there is not enough skb headroom available. Otherwise, on
 * success 0.
 */
static int
batadv_mcast_forw_push_dests(struct batadv_priv *bat_priv, struct sk_buff *skb,
        unsigned short vid, int is_routable, int *count,
        unsigned short *tvlv_len)
{
 unsigned short num_dests = 0;

 if (!batadv_mcast_forw_push_est_padding(skb, *count, tvlv_len))
  goto err;

 if (!batadv_mcast_forw_push_tt(bat_priv, skb, vid, &num_dests,
           tvlv_len))
  goto err;

 if (!batadv_mcast_forw_push_want_all(bat_priv, skb, vid, &num_dests,
          tvlv_len))
  goto err;

 if (is_routable &&
     !batadv_mcast_forw_push_want_rtr(bat_priv, skb, vid, &num_dests,
          tvlv_len))
  goto err;

 if (!batadv_mcast_forw_push_adjust_padding(skb, count, num_dests,
         tvlv_len))
  goto err;

 return 0;
err:
 return -ENOMEM;
}

/**
 * batadv_mcast_forw_push_tracker() - push a multicast tracker TVLV header
 * @skb: the skb to push the tracker TVLV onto
 * @num_dests: the number of destination addresses to set in the header
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Pushes a multicast tracker TVLV header onto the given skb, including the
 * generic TVLV header but excluding the destination MAC addresses.
 *
 * The provided num_dests value is taken into consideration to set the
 * num_dests field in the tracker header and to set the appropriate TVLV length
 * value fields.
 *
 * Return: -ENOMEM if there is not enough skb headroom available. Otherwise, on
 * success 0.
 */
static int batadv_mcast_forw_push_tracker(struct sk_buff *skb, int num_dests,
       unsigned short *tvlv_len)
{
 struct batadv_tvlv_mcast_tracker *mcast_tracker;
 struct batadv_tvlv_hdr *tvlv_hdr;
 unsigned int tvlv_value_len;

 if (skb_headroom(skb) < sizeof(*mcast_tracker) + sizeof(*tvlv_hdr))
  return -ENOMEM;

 tvlv_value_len = sizeof(*mcast_tracker) + *tvlv_len;
 if (tvlv_value_len + sizeof(*tvlv_hdr) > U16_MAX)
  return -ENOMEM;

 batadv_mcast_forw_skb_push(skb, sizeof(*mcast_tracker), tvlv_len);
 mcast_tracker = (struct batadv_tvlv_mcast_tracker *)skb->data;
 mcast_tracker->num_dests = htons(num_dests);

 skb_reset_network_header(skb);

 batadv_mcast_forw_skb_push(skb, sizeof(*tvlv_hdr), tvlv_len);
 tvlv_hdr = (struct batadv_tvlv_hdr *)skb->data;
 tvlv_hdr->type = BATADV_TVLV_MCAST_TRACKER;
 tvlv_hdr->version = 1;
 tvlv_hdr->len = htons(tvlv_value_len);

 return 0;
}

/**
 * batadv_mcast_forw_push_tvlvs() - push a multicast tracker TVLV onto an skb
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the skb to push the tracker TVLV onto
 * @vid: the vlan identifier
 * @is_routable: indicates whether the destination is routable
 * @count: the number of originators the multicast packet needs to be sent to
 * @tvlv_len: stores the amount of currently pushed TVLV bytes
 *
 * Pushes a multicast tracker TVLV onto the given skb, including the collected
 * destination MAC addresses and the generic TVLV header.
 *
 * Return: -ENOMEM if there is not enough skb headroom available. Otherwise, on
 * success 0.
 */
static int
batadv_mcast_forw_push_tvlvs(struct batadv_priv *bat_priv, struct sk_buff *skb,
        unsigned short vid, int is_routable, int count,
        unsigned short *tvlv_len)
{
 int ret;

 ret = batadv_mcast_forw_push_dests(bat_priv, skb, vid, is_routable,
        &count, tvlv_len);
 if (ret < 0)
  return ret;

 ret = batadv_mcast_forw_push_tracker(skb, count, tvlv_len);
 if (ret < 0)
  return ret;

 return 0;
}

/**
 * batadv_mcast_forw_push_hdr() - push a multicast packet header onto an skb
 * @skb: the skb to push the header onto
 * @tvlv_len: the total TVLV length value to set in the header
 *
 * Pushes a batman-adv multicast packet header onto the given skb and sets
 * the provided total TVLV length value in it.
 *
 * Caller needs to ensure enough skb headroom is available.
 *
 * Return: -ENOMEM if there is not enough skb headroom available. Otherwise, on
 * success 0.
 */
static int
batadv_mcast_forw_push_hdr(struct sk_buff *skb, unsigned short tvlv_len)
{
 struct batadv_mcast_packet *mcast_packet;

 if (skb_headroom(skb) < sizeof(*mcast_packet))
  return -ENOMEM;

 skb_push(skb, sizeof(*mcast_packet));

 mcast_packet = (struct batadv_mcast_packet *)skb->data;
 mcast_packet->version = BATADV_COMPAT_VERSION;
 mcast_packet->ttl = BATADV_TTL;
 mcast_packet->packet_type = BATADV_MCAST;
 mcast_packet->reserved = 0;
 mcast_packet->tvlv_len = htons(tvlv_len);

 return 0;
}

/**
 * batadv_mcast_forw_scrub_dests() - scrub destinations in a tracker TVLV
 * @bat_priv: the bat priv with all the mesh interface information
 * @comp_neigh: next hop neighbor to scrub+collect destinations for
 * @dest: start MAC entry in original skb's tracker TVLV
 * @next_dest: start MAC entry in to be sent skb's tracker TVLV
 * @num_dests: number of remaining destination MAC entries to iterate over
 *
 * This sorts destination entries into either the original batman-adv
 * multicast packet or the skb (copy) that is going to be sent to comp_neigh
 * next.
 *
 * In preparation for the next, to be (unicast) transmitted batman-adv multicast
 * packet skb to be sent to the given neighbor node, tries to collect all
 * originator MAC addresses that have the given neighbor node as their next hop
 * in the to be transmitted skb (copy), which next_dest points into. That is we
 * zero all destination entries in next_dest which do not have comp_neigh as
 * their next hop. And zero all destination entries in the original skb that
 * would have comp_neigh as their next hop (to avoid redundant transmissions and
 * duplicated payload later).
 */
static void
batadv_mcast_forw_scrub_dests(struct batadv_priv *bat_priv,
         struct batadv_neigh_node *comp_neigh, u8 *dest,
         u8 *next_dest, u16 num_dests)
{
 struct batadv_neigh_node *next_neigh;

 /* skip first entry, this is what we are comparing with */
 eth_zero_addr(dest);
 dest += ETH_ALEN;
 next_dest += ETH_ALEN;
 num_dests--;

 batadv_mcast_forw_tracker_for_each_dest2(dest, next_dest, num_dests) {
  if (is_zero_ether_addr(next_dest))
   continue;

  /* sanity check, we expect unicast destinations */
  if (is_multicast_ether_addr(next_dest)) {
   eth_zero_addr(dest);
   eth_zero_addr(next_dest);
   continue;
  }

  next_neigh = batadv_orig_to_router(bat_priv, next_dest, NULL);
  if (!next_neigh) {
   eth_zero_addr(next_dest);
   continue;
  }

  if (!batadv_compare_eth(next_neigh->addr, comp_neigh->addr)) {
   eth_zero_addr(next_dest);
   batadv_neigh_node_put(next_neigh);
   continue;
  }

  /* found an entry for our next packet to transmit, so remove it
   * from the original packet
 */
  eth_zero_addr(dest);
  batadv_neigh_node_put(next_neigh);
 }
}

/**
 * batadv_mcast_forw_shrink_fill() - swap slot with next non-zero destination
 * @slot: the to be filled zero-MAC destination entry in a tracker TVLV
 * @num_dests_slot: remaining entries in tracker TVLV from/including slot
 *
 * Searches for the next non-zero-MAC destination entry in a tracker TVLV after
 * the given slot pointer. And if found, swaps it with the zero-MAC destination
 * entry which the slot points to.
 *
 * Return: true if slot was swapped/filled successfully, false otherwise.
 */
static bool batadv_mcast_forw_shrink_fill(u8 *slot, u16 num_dests_slot)
{
 u16 num_dests_filler;
 u8 *filler;

 /* sanity check, should not happen */
 if (!num_dests_slot)
  return false;

 num_dests_filler = num_dests_slot - 1;
 filler = slot + ETH_ALEN;

 /* find a candidate to fill the empty slot */
 batadv_mcast_forw_tracker_for_each_dest(filler, num_dests_filler) {
  if (is_zero_ether_addr(filler))
   continue;

  ether_addr_copy(slot, filler);
  eth_zero_addr(filler);
  return true;
 }

 return false;
}

/**
 * batadv_mcast_forw_shrink_pack_dests() - pack destinations of a tracker TVLV
 * @skb: the batman-adv multicast packet to compact destinations in
 *
 * Compacts the originator destination MAC addresses in the multicast tracker
 * TVLV of the given multicast packet. This is done by moving all non-zero
 * MAC addresses in direction of the skb head and all zero MAC addresses in skb
 * tail direction, within the multicast tracker TVLV.
 *
 * Return: The number of consecutive zero MAC address destinations which are
 * now at the end of the multicast tracker TVLV.
 */
static int batadv_mcast_forw_shrink_pack_dests(struct sk_buff *skb)
{
 struct batadv_tvlv_mcast_tracker *mcast_tracker;
 unsigned char *skb_net_hdr;
 u16 num_dests_slot;
 u8 *slot;

 skb_net_hdr = skb_network_header(skb);
 mcast_tracker = (struct batadv_tvlv_mcast_tracker *)skb_net_hdr;
 num_dests_slot = ntohs(mcast_tracker->num_dests);

 slot = (u8 *)mcast_tracker + sizeof(*mcast_tracker);

 batadv_mcast_forw_tracker_for_each_dest(slot, num_dests_slot) {
  /* find an empty slot */
  if (!is_zero_ether_addr(slot))
   continue;

  if (!batadv_mcast_forw_shrink_fill(slot, num_dests_slot))
   /* could not find a filler, so we successfully packed
    * and can stop - and must not reduce num_dests_slot!
 */
   break;
 }

 /* num_dests_slot is now the amount of reduced, zeroed
  * destinations at the end of the tracker TVLV
 */
 return num_dests_slot;
}

/**
 * batadv_mcast_forw_shrink_align_offset() - get new alignment offset
 * @num_dests_old: the old, to be updated amount of destination nodes
 * @num_dests_reduce: the number of destinations that were removed
 *
 * Calculates the amount of potential extra alignment offset that is needed to
 * adjust the TVLV padding after the change in destination nodes.
 *
 * Return:
 * 0: If no change to padding is needed.
 * 2: If padding needs to be removed.
 * -2: If padding needs to be added.
 */
static short
batadv_mcast_forw_shrink_align_offset(unsigned int num_dests_old,
          unsigned int num_dests_reduce)
{
 /* even amount of removed destinations -> no alignment change */
 if (!(num_dests_reduce % 2))
  return 0;

 /* even to odd amount of destinations -> remove padding */
 if (!(num_dests_old % 2))
  return 2;

 /* odd to even amount of destinations -> add padding */
 return -2;
}

/**
 * batadv_mcast_forw_shrink_update_headers() - update shrunk mc packet headers
 * @skb: the batman-adv multicast packet to update headers of
 * @num_dests_reduce: the number of destinations that were removed
 *
 * This updates any fields of a batman-adv multicast packet that are affected
 * by the reduced number of destinations in the multicast tracket TVLV. In
 * particular this updates:
 *
 * The num_dest field of the multicast tracker TVLV.
 * The TVLV length field of the according generic TVLV header.
 * The batman-adv multicast packet's total TVLV length field.
 *
 * Return: The offset in skb's tail direction at which the new batman-adv
 * multicast packet header needs to start.
 */
static unsigned int
batadv_mcast_forw_shrink_update_headers(struct sk_buff *skb,
     unsigned int num_dests_reduce)
{
 struct batadv_tvlv_mcast_tracker *mcast_tracker;
 struct batadv_mcast_packet *mcast_packet;
 struct batadv_tvlv_hdr *tvlv_hdr;
 unsigned char *skb_net_hdr;
 unsigned int offset;
 short align_offset;
 u16 num_dests;

 skb_net_hdr = skb_network_header(skb);
 mcast_tracker = (struct batadv_tvlv_mcast_tracker *)skb_net_hdr;
 num_dests = ntohs(mcast_tracker->num_dests);

 align_offset = batadv_mcast_forw_shrink_align_offset(num_dests,
            num_dests_reduce);
 offset = ETH_ALEN * num_dests_reduce + align_offset;
 num_dests -= num_dests_reduce;

 /* update tracker header */
 mcast_tracker->num_dests = htons(num_dests);

 /* update tracker's tvlv header's length field */
 tvlv_hdr = (struct batadv_tvlv_hdr *)(skb_network_header(skb) -
           sizeof(*tvlv_hdr));
 tvlv_hdr->len = htons(ntohs(tvlv_hdr->len) - offset);

 /* update multicast packet header's tvlv length field */
 mcast_packet = (struct batadv_mcast_packet *)skb->data;
 mcast_packet->tvlv_len = htons(ntohs(mcast_packet->tvlv_len) - offset);

 return offset;
}

/**
 * batadv_mcast_forw_shrink_move_headers() - move multicast headers by offset
 * @skb: the batman-adv multicast packet to move headers for
 * @offset: a non-negative offset to move headers by, towards the skb tail
 *
 * Moves the batman-adv multicast packet header, its multicast tracker TVLV and
 * any TVLVs in between by the given offset in direction towards the tail.
 */
static void
batadv_mcast_forw_shrink_move_headers(struct sk_buff *skb, unsigned int offset)
{
 struct batadv_tvlv_mcast_tracker *mcast_tracker;
 unsigned char *skb_net_hdr;
 unsigned int len;
 u16 num_dests;

 skb_net_hdr = skb_network_header(skb);
 mcast_tracker = (struct batadv_tvlv_mcast_tracker *)skb_net_hdr;
 num_dests = ntohs(mcast_tracker->num_dests);
 len = skb_network_offset(skb) + sizeof(*mcast_tracker);
 len += num_dests * ETH_ALEN;

 batadv_mcast_forw_scrape(skb, len, offset);
}

/**
 * batadv_mcast_forw_shrink_tracker() - remove zero addresses in a tracker tvlv
 * @skb: the batman-adv multicast packet to (potentially) shrink
 *
 * Removes all destinations with a zero MAC addresses (00:00:00:00:00:00) from
 * the given batman-adv multicast packet's tracker TVLV and updates headers
 * accordingly to maintain a valid batman-adv multicast packet.
 */
static void batadv_mcast_forw_shrink_tracker(struct sk_buff *skb)
{
 unsigned int offset;
 u16 dests_reduced;

 dests_reduced = batadv_mcast_forw_shrink_pack_dests(skb);
 if (!dests_reduced)
  return;

 offset = batadv_mcast_forw_shrink_update_headers(skb, dests_reduced);
 batadv_mcast_forw_shrink_move_headers(skb, offset);
}

/**
 * batadv_mcast_forw_packet() - forward a batman-adv multicast packet
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the received or locally generated batman-adv multicast packet
 * @local_xmit: indicates that the packet was locally generated and not received
 *
 * Parses the tracker TVLV of a batman-adv multicast packet and forwards the
 * packet as indicated in this TVLV.
 *
 * Caller needs to set the skb network header to the start of the multicast
 * tracker TVLV (excluding the generic TVLV header) and the skb transport header
 * to the next byte after this multicast tracker TVLV.
 *
 * Caller needs to free the skb.
 *
 * Return: NET_RX_SUCCESS or NET_RX_DROP on success or a negative error
 * code on failure. NET_RX_SUCCESS if the received packet is supposed to be
 * decapsulated and forwarded to the own mesh interface, NET_RX_DROP otherwise.
 */
static int batadv_mcast_forw_packet(struct batadv_priv *bat_priv,
        struct sk_buff *skb, bool local_xmit)
{
 struct batadv_tvlv_mcast_tracker *mcast_tracker;
 struct batadv_neigh_node *neigh_node;
 unsigned long offset, num_dests_off;
 struct sk_buff *nexthop_skb;
 unsigned char *skb_net_hdr;
 bool local_recv = false;
 unsigned int tvlv_len;
 bool xmitted = false;
 u8 *dest, *next_dest;
 u16 num_dests;
 int ret;

 /* (at least) TVLV part needs to be linearized */
 SKB_LINEAR_ASSERT(skb);

 /* check if num_dests is within skb length */
 num_dests_off = offsetof(struct batadv_tvlv_mcast_tracker, num_dests);
 if (num_dests_off > skb_network_header_len(skb))
  return -EINVAL;

 skb_net_hdr = skb_network_header(skb);
 mcast_tracker = (struct batadv_tvlv_mcast_tracker *)skb_net_hdr;
 num_dests = ntohs(mcast_tracker->num_dests);

 dest = (u8 *)mcast_tracker + sizeof(*mcast_tracker);

 /* check if full tracker tvlv is within skb length */
 tvlv_len = sizeof(*mcast_tracker) + ETH_ALEN * num_dests;
 if (tvlv_len > skb_network_header_len(skb))
  return -EINVAL;

 /* invalidate checksum: */
 skb->ip_summed = CHECKSUM_NONE;

 batadv_mcast_forw_tracker_for_each_dest(dest, num_dests) {
  if (is_zero_ether_addr(dest))
   continue;

  /* only unicast originator addresses supported */
  if (is_multicast_ether_addr(dest)) {
   eth_zero_addr(dest);
   continue;
  }

  if (batadv_is_my_mac(bat_priv, dest)) {
   eth_zero_addr(dest);
   local_recv = true;
   continue;
  }

  neigh_node = batadv_orig_to_router(bat_priv, dest, NULL);
  if (!neigh_node) {
   eth_zero_addr(dest);
   continue;
  }

  nexthop_skb = skb_copy(skb, GFP_ATOMIC);
  if (!nexthop_skb) {
   batadv_neigh_node_put(neigh_node);
   return -ENOMEM;
  }

  offset = dest - skb->data;
  next_dest = nexthop_skb->data + offset;

  batadv_mcast_forw_scrub_dests(bat_priv, neigh_node, dest,
           next_dest, num_dests);
  batadv_mcast_forw_shrink_tracker(nexthop_skb);

  batadv_inc_counter(bat_priv, BATADV_CNT_MCAST_TX);
  batadv_add_counter(bat_priv, BATADV_CNT_MCAST_TX_BYTES,
       nexthop_skb->len + ETH_HLEN);
  xmitted = true;
  ret = batadv_send_unicast_skb(nexthop_skb, neigh_node);

  batadv_neigh_node_put(neigh_node);

  if (ret < 0)
   return ret;
 }

 if (xmitted) {
  if (local_xmit) {
   batadv_inc_counter(bat_priv, BATADV_CNT_MCAST_TX_LOCAL);
   batadv_add_counter(bat_priv,
        BATADV_CNT_MCAST_TX_LOCAL_BYTES,
        skb->len -
        skb_transport_offset(skb));
  } else {
   batadv_inc_counter(bat_priv, BATADV_CNT_MCAST_FWD);
   batadv_add_counter(bat_priv, BATADV_CNT_MCAST_FWD_BYTES,
        skb->len + ETH_HLEN);
  }
 }

 if (local_recv)
  return NET_RX_SUCCESS;
 else
  return NET_RX_DROP;
}

/**
 * batadv_mcast_forw_tracker_tvlv_handler() - handle an mcast tracker tvlv
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the received batman-adv multicast packet
 *
 * Parses the tracker TVLV of an incoming batman-adv multicast packet and
 * forwards the packet as indicated in this TVLV.
 *
 * Caller needs to set the skb network header to the start of the multicast
 * tracker TVLV (excluding the generic TVLV header) and the skb transport header
 * to the next byte after this multicast tracker TVLV.
 *
 * Caller needs to free the skb.
 *
 * Return: NET_RX_SUCCESS or NET_RX_DROP on success or a negative error
 * code on failure. NET_RX_SUCCESS if the received packet is supposed to be
 * decapsulated and forwarded to the own mesh interface, NET_RX_DROP otherwise.
 */
int batadv_mcast_forw_tracker_tvlv_handler(struct batadv_priv *bat_priv,
        struct sk_buff *skb)
{
 return batadv_mcast_forw_packet(bat_priv, skb, false);
}

/**
 * batadv_mcast_forw_packet_hdrlen() - multicast packet header length
 * @num_dests: number of destination nodes
 *
 * Calculates the total batman-adv multicast packet header length for a given
 * number of destination nodes (excluding the outer ethernet frame).
 *
 * Return: The calculated total batman-adv multicast packet header length.
 */
unsigned int batadv_mcast_forw_packet_hdrlen(unsigned int num_dests)
{
 /**
  * If the number of destination entries is even then we need to add
  * two byte padding to the tracker TVLV.
 */
 int padding = (!(num_dests % 2)) ? 2 : 0;

 return padding + num_dests * ETH_ALEN +
        sizeof(struct batadv_tvlv_mcast_tracker) +
        sizeof(struct batadv_tvlv_hdr) +
        sizeof(struct batadv_mcast_packet);
}

/**
 * batadv_mcast_forw_expand_head() - expand headroom for an mcast packet
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the multicast packet to send
 *
 * Tries to expand an skb's headroom so that its head to tail is 1298
 * bytes (minimum IPv6 MTU + vlan ethernet header size) large.
 *
 * Return: -EINVAL if the given skb's length is too large or -ENOMEM on memory
 * allocation failure. Otherwise, on success, zero is returned.
 */
static int batadv_mcast_forw_expand_head(struct batadv_priv *bat_priv,
      struct sk_buff *skb)
{
 int hdr_size = VLAN_ETH_HLEN + IPV6_MIN_MTU - skb->len;

  /* TODO: Could be tightened to actual number of destination nodes?
   * But it's tricky, number of destinations might have increased since
   * we last checked.
  */
 if (hdr_size < 0) {
  /* batadv_mcast_forw_mode_check_count() should ensure we do not
   * end up here
 */
  WARN_ON(1);
  return -EINVAL;
 }

 if (skb_headroom(skb) < hdr_size &&
     pskb_expand_head(skb, hdr_size, 0, GFP_ATOMIC) < 0)
  return -ENOMEM;

 return 0;
}

/**
 * batadv_mcast_forw_push() - encapsulate skb in a batman-adv multicast packet
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the multicast packet to encapsulate and send
 * @vid: the vlan identifier
 * @is_routable: indicates whether the destination is routable
 * @count: the number of originators the multicast packet needs to be sent to
 *
 * Encapsulates the given multicast packet in a batman-adv multicast packet.
 * A multicast tracker TVLV with destination originator addresses for any node
 * that signaled interest in it, that is either via the translation table or the
 * according want-all flags, is attached accordingly.
 *
 * Return: true on success, false otherwise.
 */
bool batadv_mcast_forw_push(struct batadv_priv *bat_priv, struct sk_buff *skb,
       unsigned short vid, int is_routable, int count)
{
 unsigned short tvlv_len = 0;
 int ret;

 if (batadv_mcast_forw_expand_head(bat_priv, skb) < 0)
  goto err;

 skb_reset_transport_header(skb);

 ret = batadv_mcast_forw_push_tvlvs(bat_priv, skb, vid, is_routable,
        count, &tvlv_len);
 if (ret < 0)
  goto err;

 ret = batadv_mcast_forw_push_hdr(skb, tvlv_len);
 if (ret < 0)
  goto err;

 return true;

err:
 if (tvlv_len)
  skb_pull(skb, tvlv_len);

 return false;
}

/**
 * batadv_mcast_forw_mcsend() - send a self prepared batman-adv multicast packet
 * @bat_priv: the bat priv with all the mesh interface information
 * @skb: the multicast packet to encapsulate and send
 *
 * Transmits a batman-adv multicast packet that was locally prepared and
 * consumes/frees it.
 *
 * Return: NET_XMIT_DROP on memory allocation failure. NET_XMIT_SUCCESS
 * otherwise.
 */
int batadv_mcast_forw_mcsend(struct batadv_priv *bat_priv,
        struct sk_buff *skb)
{
 int ret = batadv_mcast_forw_packet(bat_priv, skb, true);

 if (ret < 0) {
  kfree_skb(skb);
  return NET_XMIT_DROP;
 }

 consume_skb(skb);
 return NET_XMIT_SUCCESS;
}