/* Copyright (C) 2007-2014 B.A.T.M.A.N. contributors:

   *

   * Marek Lindner, Simon Wunderlich, Antonio Quartulli

   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of version 2 of the GNU General Public
   * License as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License

   * along with this program; if not, see <http://www.gnu.org/licenses/>.

   */
  
  #include "main.h"
  #include "translation-table.h"
  #include "soft-interface.h"

  #include "hard-interface.h"

  #include "send.h"

  #include "hash.h"
  #include "originator.h"

  #include "routing.h"

  #include "bridge_loop_avoidance.h"

  #include "multicast.h"

  #include <linux/crc32c.h>

  /* hash class keys */
  static struct lock_class_key batadv_tt_local_hash_lock_class_key;
  static struct lock_class_key batadv_tt_global_hash_lock_class_key;

  static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client,

  				 unsigned short vid,

  				 struct batadv_orig_node *orig_node);

  static void batadv_tt_purge(struct work_struct *work);
  static void

  batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);

  static void batadv_tt_global_del(struct batadv_priv *bat_priv,
  				 struct batadv_orig_node *orig_node,
  				 const unsigned char *addr,

  				 unsigned short vid, const char *message,
  				 bool roaming);

  /* returns 1 if they are the same mac addr */

  static int batadv_compare_tt(const struct hlist_node *node, const void *data2)

  {

  	const void *data1 = container_of(node, struct batadv_tt_common_entry,

  					 hash_entry);

  	return batadv_compare_eth(data1, data2);

  }

  /**
   * batadv_choose_tt - return the index of the tt entry in the hash table
   * @data: pointer to the tt_common_entry object to map
   * @size: the size of the hash table
   *
   * Returns the hash index where the object represented by 'data' should be
   * stored at.
   */
  static inline uint32_t batadv_choose_tt(const void *data, uint32_t size)
  {
  	struct batadv_tt_common_entry *tt;
  	uint32_t hash = 0;
  
  	tt = (struct batadv_tt_common_entry *)data;
  	hash = batadv_hash_bytes(hash, &tt->addr, ETH_ALEN);
  	hash = batadv_hash_bytes(hash, &tt->vid, sizeof(tt->vid));
  
  	hash += (hash << 3);
  	hash ^= (hash >> 11);
  	hash += (hash << 15);
  
  	return hash % size;
  }
  
  /**
   * batadv_tt_hash_find - look for a client in the given hash table
   * @hash: the hash table to search
   * @addr: the mac address of the client to look for
   * @vid: VLAN identifier
   *
   * Returns a pointer to the tt_common struct belonging to the searched client if
   * found, NULL otherwise.
   */

  static struct batadv_tt_common_entry *

  batadv_tt_hash_find(struct batadv_hashtable *hash, const uint8_t *addr,
  		    unsigned short vid)

  {

  	struct hlist_head *head;

  	struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;

  	uint32_t index;

  
  	if (!hash)
  		return NULL;

  	ether_addr_copy(to_search.addr, addr);

  	to_search.vid = vid;
  
  	index = batadv_choose_tt(&to_search, hash->size);

  	head = &hash->table[index];
  
  	rcu_read_lock();

  	hlist_for_each_entry_rcu(tt, head, hash_entry) {
  		if (!batadv_compare_eth(tt, addr))
  			continue;
  
  		if (tt->vid != vid)

  			continue;

  		if (!atomic_inc_not_zero(&tt->refcount))

  			continue;

  		tt_tmp = tt;

  		break;
  	}
  	rcu_read_unlock();

  	return tt_tmp;

  }

  /**
   * batadv_tt_local_hash_find - search the local table for a given client
   * @bat_priv: the bat priv with all the soft interface information
   * @addr: the mac address of the client to look for
   * @vid: VLAN identifier
   *
   * Returns a pointer to the corresponding tt_local_entry struct if the client is
   * found, NULL otherwise.
   */

  static struct batadv_tt_local_entry *

  batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const uint8_t *addr,
  			  unsigned short vid)

  {

  	struct batadv_tt_common_entry *tt_common_entry;
  	struct batadv_tt_local_entry *tt_local_entry = NULL;

  	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
  					      vid);

  	if (tt_common_entry)
  		tt_local_entry = container_of(tt_common_entry,

  					      struct batadv_tt_local_entry,
  					      common);

  	return tt_local_entry;
  }

  /**
   * batadv_tt_global_hash_find - search the global table for a given client
   * @bat_priv: the bat priv with all the soft interface information
   * @addr: the mac address of the client to look for
   * @vid: VLAN identifier
   *
   * Returns a pointer to the corresponding tt_global_entry struct if the client
   * is found, NULL otherwise.
   */

  static struct batadv_tt_global_entry *

  batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const uint8_t *addr,
  			   unsigned short vid)

  {

  	struct batadv_tt_common_entry *tt_common_entry;
  	struct batadv_tt_global_entry *tt_global_entry = NULL;

  	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
  					      vid);

  	if (tt_common_entry)
  		tt_global_entry = container_of(tt_common_entry,

  					       struct batadv_tt_global_entry,
  					       common);

  	return tt_global_entry;

  }

  static void

  batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)

  {

  	if (atomic_dec_and_test(&tt_local_entry->common.refcount))
  		kfree_rcu(tt_local_entry, common.rcu);

  }

  /**
   * batadv_tt_global_entry_free_ref - decrement the refcounter for a
   *  tt_global_entry and possibly free it
   * @tt_global_entry: the object to free
   */

  static void

  batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)

  {

  	if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {

  		batadv_tt_global_del_orig_list(tt_global_entry);

  		kfree_rcu(tt_global_entry, common.rcu);

  	}
  }

  /**
   * batadv_tt_global_hash_count - count the number of orig entries
   * @hash: hash table containing the tt entries
   * @addr: the mac address of the client to count entries for
   * @vid: VLAN identifier
   *
   * Return the number of originators advertising the given address/data
   * (excluding ourself).
   */
  int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
  				const uint8_t *addr, unsigned short vid)
  {
  	struct batadv_tt_global_entry *tt_global_entry;
  	int count;
  
  	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
  	if (!tt_global_entry)
  		return 0;
  
  	count = atomic_read(&tt_global_entry->orig_list_count);
  	batadv_tt_global_entry_free_ref(tt_global_entry);
  
  	return count;
  }

  static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)

  {

  	struct batadv_tt_orig_list_entry *orig_entry;

  	orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);

  
  	/* We are in an rcu callback here, therefore we cannot use
  	 * batadv_orig_node_free_ref() and its call_rcu():
  	 * An rcu_barrier() wouldn't wait for that to finish
  	 */
  	batadv_orig_node_free_ref_now(orig_entry->orig_node);

  	kfree(orig_entry);
  }

  /**
   * batadv_tt_local_size_mod - change the size by v of the local table identified
   *  by vid
   * @bat_priv: the bat priv with all the soft interface information
   * @vid: the VLAN identifier of the sub-table to change
   * @v: the amount to sum to the local table size
   */
  static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,
  				     unsigned short vid, int v)
  {
  	struct batadv_softif_vlan *vlan;
  
  	vlan = batadv_softif_vlan_get(bat_priv, vid);
  	if (!vlan)
  		return;
  
  	atomic_add(v, &vlan->tt.num_entries);
  
  	batadv_softif_vlan_free_ref(vlan);
  }
  
  /**
   * batadv_tt_local_size_inc - increase by one the local table size for the given
   *  vid
   * @bat_priv: the bat priv with all the soft interface information
   * @vid: the VLAN identifier
   */
  static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,
  				     unsigned short vid)
  {
  	batadv_tt_local_size_mod(bat_priv, vid, 1);
  }
  
  /**
   * batadv_tt_local_size_dec - decrease by one the local table size for the given
   *  vid
   * @bat_priv: the bat priv with all the soft interface information
   * @vid: the VLAN identifier
   */
  static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,
  				     unsigned short vid)
  {
  	batadv_tt_local_size_mod(bat_priv, vid, -1);
  }
  
  /**
   * batadv_tt_global_size_mod - change the size by v of the local table
   *  identified by vid
   * @bat_priv: the bat priv with all the soft interface information
   * @vid: the VLAN identifier
   * @v: the amount to sum to the global table size
   */
  static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,
  				      unsigned short vid, int v)
  {
  	struct batadv_orig_node_vlan *vlan;
  
  	vlan = batadv_orig_node_vlan_new(orig_node, vid);
  	if (!vlan)
  		return;
  
  	if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {
  		spin_lock_bh(&orig_node->vlan_list_lock);
  		list_del_rcu(&vlan->list);
  		spin_unlock_bh(&orig_node->vlan_list_lock);
  		batadv_orig_node_vlan_free_ref(vlan);
  	}
  
  	batadv_orig_node_vlan_free_ref(vlan);
  }
  
  /**
   * batadv_tt_global_size_inc - increase by one the global table size for the
   *  given vid
   * @orig_node: the originator which global table size has to be decreased
   * @vid: the vlan identifier
   */
  static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,
  				      unsigned short vid)
  {
  	batadv_tt_global_size_mod(orig_node, vid, 1);
  }
  
  /**
   * batadv_tt_global_size_dec - decrease by one the global table size for the
   *  given vid
   * @orig_node: the originator which global table size has to be decreased
   * @vid: the vlan identifier
   */
  static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,
  				      unsigned short vid)
  {
  	batadv_tt_global_size_mod(orig_node, vid, -1);
  }

  static void

  batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)

  {

  	if (!atomic_dec_and_test(&orig_entry->refcount))
  		return;

  	call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);

  }

  /**
   * batadv_tt_local_event - store a local TT event (ADD/DEL)
   * @bat_priv: the bat priv with all the soft interface information
   * @tt_local_entry: the TT entry involved in the event
   * @event_flags: flags to store in the event structure
   */

  static void batadv_tt_local_event(struct batadv_priv *bat_priv,

  				  struct batadv_tt_local_entry *tt_local_entry,
  				  uint8_t event_flags)

  {

  	struct batadv_tt_change_node *tt_change_node, *entry, *safe;

  	struct batadv_tt_common_entry *common = &tt_local_entry->common;
  	uint8_t flags = common->flags | event_flags;

  	bool event_removed = false;
  	bool del_op_requested, del_op_entry;

  
  	tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);

  	if (!tt_change_node)
  		return;

  	tt_change_node->change.flags = flags;

  	memset(tt_change_node->change.reserved, 0,
  	       sizeof(tt_change_node->change.reserved));

  	ether_addr_copy(tt_change_node->change.addr, common->addr);

  	tt_change_node->change.vid = htons(common->vid);

  	del_op_requested = flags & BATADV_TT_CLIENT_DEL;

  
  	/* check for ADD+DEL or DEL+ADD events */

  	spin_lock_bh(&bat_priv->tt.changes_list_lock);
  	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

  				 list) {

  		if (!batadv_compare_eth(entry->change.addr, common->addr))

  			continue;
  
  		/* DEL+ADD in the same orig interval have no effect and can be
  		 * removed to avoid silly behaviour on the receiver side. The
  		 * other way around (ADD+DEL) can happen in case of roaming of
  		 * a client still in the NEW state. Roaming of NEW clients is
  		 * now possible due to automatically recognition of "temporary"
  		 * clients
  		 */

  		del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;

  		if (!del_op_requested && del_op_entry)
  			goto del;
  		if (del_op_requested && !del_op_entry)
  			goto del;

  
  		/* this is a second add in the same originator interval. It
  		 * means that flags have been changed: update them!
  		 */
  		if (!del_op_requested && !del_op_entry)
  			entry->change.flags = flags;

  		continue;
  del:
  		list_del(&entry->list);
  		kfree(entry);

  		kfree(tt_change_node);

  		event_removed = true;
  		goto unlock;
  	}

  	/* track the change in the OGMinterval list */

  	list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);

  
  unlock:

  	spin_unlock_bh(&bat_priv->tt.changes_list_lock);

  	if (event_removed)

  		atomic_dec(&bat_priv->tt.local_changes);

  	else

  		atomic_inc(&bat_priv->tt.local_changes);

  }

  /**
   * batadv_tt_len - compute length in bytes of given number of tt changes
   * @changes_num: number of tt changes
   *
   * Returns computed length in bytes.
   */
  static int batadv_tt_len(int changes_num)

  {

  	return changes_num * sizeof(struct batadv_tvlv_tt_change);

  }

  /**
   * batadv_tt_entries - compute the number of entries fitting in tt_len bytes
   * @tt_len: available space
   *
   * Returns the number of entries.
   */
  static uint16_t batadv_tt_entries(uint16_t tt_len)
  {
  	return tt_len / batadv_tt_len(1);
  }

  /**
   * batadv_tt_local_table_transmit_size - calculates the local translation table
   *  size when transmitted over the air
   * @bat_priv: the bat priv with all the soft interface information
   *
   * Returns local translation table size in bytes.
   */
  static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
  {
  	uint16_t num_vlan = 0, tt_local_entries = 0;
  	struct batadv_softif_vlan *vlan;
  	int hdr_size;
  
  	rcu_read_lock();
  	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
  		num_vlan++;
  		tt_local_entries += atomic_read(&vlan->tt.num_entries);
  	}
  	rcu_read_unlock();
  
  	/* header size of tvlv encapsulated tt response payload */
  	hdr_size = sizeof(struct batadv_unicast_tvlv_packet);
  	hdr_size += sizeof(struct batadv_tvlv_hdr);
  	hdr_size += sizeof(struct batadv_tvlv_tt_data);
  	hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);
  
  	return hdr_size + batadv_tt_len(tt_local_entries);
  }

  static int batadv_tt_local_init(struct batadv_priv *bat_priv)

  {

  	if (bat_priv->tt.local_hash)

  		return 0;

  	bat_priv->tt.local_hash = batadv_hash_new(1024);

  	if (!bat_priv->tt.local_hash)

  		return -ENOMEM;

  	batadv_hash_set_lock_class(bat_priv->tt.local_hash,
  				   &batadv_tt_local_hash_lock_class_key);

  	return 0;

  }

  static void batadv_tt_global_free(struct batadv_priv *bat_priv,
  				  struct batadv_tt_global_entry *tt_global,
  				  const char *message)
  {
  	batadv_dbg(BATADV_DBG_TT, bat_priv,

  		   "Deleting global tt entry %pM (vid: %d): %s
  ",
  		   tt_global->common.addr,
  		   BATADV_PRINT_VID(tt_global->common.vid), message);

  
  	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,

  			   batadv_choose_tt, &tt_global->common);

  	batadv_tt_global_entry_free_ref(tt_global);

  }

  /**
   * batadv_tt_local_add - add a new client to the local table or update an
   *  existing client
   * @soft_iface: netdev struct of the mesh interface
   * @addr: the mac address of the client to add
   * @vid: VLAN identifier
   * @ifindex: index of the interface where the client is connected to (useful to
   *  identify wireless clients)

   * @mark: the value contained in the skb->mark field of the received packet (if
   *  any)

   *
   * Returns true if the client was successfully added, false otherwise.

   */

  bool batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,

  			 unsigned short vid, int ifindex, uint32_t mark)

  {

  	struct batadv_priv *bat_priv = netdev_priv(soft_iface);

  	struct batadv_tt_local_entry *tt_local;

  	struct batadv_tt_global_entry *tt_global = NULL;

  	struct net_device *in_dev = NULL;

  	struct hlist_head *head;

  	struct batadv_tt_orig_list_entry *orig_entry;

  	int hash_added, table_size, packet_size_max;
  	bool ret = false, roamed_back = false;

  	uint8_t remote_flags;

  	uint32_t match_mark;

  	if (ifindex != BATADV_NULL_IFINDEX)
  		in_dev = dev_get_by_index(&init_net, ifindex);

  	tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);

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

  	if (tt_local) {
  		tt_local->last_seen = jiffies;

  		if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
  			batadv_dbg(BATADV_DBG_TT, bat_priv,

  				   "Re-adding pending client %pM (vid: %d)
  ",
  				   addr, BATADV_PRINT_VID(vid));

  			/* whatever the reason why the PENDING flag was set,
  			 * this is a client which was enqueued to be removed in
  			 * this orig_interval. Since it popped up again, the
  			 * flag can be reset like it was never enqueued
  			 */
  			tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;
  			goto add_event;
  		}
  
  		if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {
  			batadv_dbg(BATADV_DBG_TT, bat_priv,

  				   "Roaming client %pM (vid: %d) came back to its original location
  ",
  				   addr, BATADV_PRINT_VID(vid));

  			/* the ROAM flag is set because this client roamed away
  			 * and the node got a roaming_advertisement message. Now
  			 * that the client popped up again at its original
  			 * location such flag can be unset
  			 */
  			tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;
  			roamed_back = true;
  		}
  		goto check_roaming;

  	}

  	/* Ignore the client if we cannot send it in a full table response. */
  	table_size = batadv_tt_local_table_transmit_size(bat_priv);
  	table_size += batadv_tt_len(1);
  	packet_size_max = atomic_read(&bat_priv->packet_size_max);
  	if (table_size > packet_size_max) {
  		net_ratelimited_function(batadv_info, soft_iface,
  					 "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM
  ",
  					 table_size, packet_size_max, addr);
  		goto out;
  	}

  	tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);
  	if (!tt_local)

  		goto out;

  	batadv_dbg(BATADV_DBG_TT, bat_priv,

  		   "Creating new local tt entry: %pM (vid: %d, ttvn: %d)
  ",
  		   addr, BATADV_PRINT_VID(vid),

  		   (uint8_t)atomic_read(&bat_priv->tt.vn));

  	ether_addr_copy(tt_local->common.addr, addr);

  	/* The local entry has to be marked as NEW to avoid to send it in
  	 * a full table response going out before the next ttvn increment
  	 * (consistency check)
  	 */
  	tt_local->common.flags = BATADV_TT_CLIENT_NEW;

  	tt_local->common.vid = vid;

  	if (batadv_is_wifi_netdev(in_dev))

  		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
  	atomic_set(&tt_local->common.refcount, 2);
  	tt_local->last_seen = jiffies;
  	tt_local->common.added_at = tt_local->last_seen;

  	/* the batman interface mac and multicast addresses should never be
  	 * purged
  	 */
  	if (batadv_compare_eth(addr, soft_iface->dev_addr) ||
  	    is_multicast_ether_addr(addr))

  		tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;

  	hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,

  				     batadv_choose_tt, &tt_local->common,

  				     &tt_local->common.hash_entry);

  
  	if (unlikely(hash_added != 0)) {
  		/* remove the reference for the hash */

  		batadv_tt_local_entry_free_ref(tt_local);

  		goto out;
  	}

  add_event:

  	batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);

  check_roaming:
  	/* Check whether it is a roaming, but don't do anything if the roaming
  	 * process has already been handled
  	 */
  	if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {

  		/* These node are probably going to update their tt table */

  		head = &tt_global->orig_list;

  		rcu_read_lock();

  		hlist_for_each_entry_rcu(orig_entry, head, list) {

  			batadv_send_roam_adv(bat_priv, tt_global->common.addr,

  					     tt_global->common.vid,

  					     orig_entry->orig_node);

  		}
  		rcu_read_unlock();

  		if (roamed_back) {
  			batadv_tt_global_free(bat_priv, tt_global,
  					      "Roaming canceled");
  			tt_global = NULL;
  		} else {
  			/* The global entry has to be marked as ROAMING and
  			 * has to be kept for consistency purpose
  			 */
  			tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;
  			tt_global->roam_at = jiffies;
  		}

  	}

  	/* store the current remote flags before altering them. This helps
  	 * understanding is flags are changing or not
  	 */
  	remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;
  
  	if (batadv_is_wifi_netdev(in_dev))
  		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
  	else
  		tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;

  	/* check the mark in the skb: if it's equal to the configured
  	 * isolation_mark, it means the packet is coming from an isolated
  	 * non-mesh client
  	 */
  	match_mark = (mark & bat_priv->isolation_mark_mask);
  	if (bat_priv->isolation_mark_mask &&
  	    match_mark == bat_priv->isolation_mark)
  		tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;
  	else
  		tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;

  	/* if any "dynamic" flag has been modified, resend an ADD event for this
  	 * entry so that all the nodes can get the new flags
  	 */
  	if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))
  		batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
  
  	ret = true;

  out:

  	if (in_dev)
  		dev_put(in_dev);

  	if (tt_local)
  		batadv_tt_local_entry_free_ref(tt_local);
  	if (tt_global)
  		batadv_tt_global_entry_free_ref(tt_global);

  	return ret;

  }

  /**

   * batadv_tt_prepare_tvlv_global_data - prepare the TVLV TT header to send
   *  within a TT Response directed to another node
   * @orig_node: originator for which the TT data has to be prepared
   * @tt_data: uninitialised pointer to the address of the TVLV buffer
   * @tt_change: uninitialised pointer to the address of the area where the TT
   *  changed can be stored
   * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
   *  function reserves the amount of space needed to send the entire global TT
   *  table. In case of success the value is updated with the real amount of
   *  reserved bytes
  
   * Allocate the needed amount of memory for the entire TT TVLV and write its
   * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
   * objects, one per active VLAN served by the originator node.
   *
   * Return the size of the allocated buffer or 0 in case of failure.
   */
  static uint16_t
  batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,
  				   struct batadv_tvlv_tt_data **tt_data,
  				   struct batadv_tvlv_tt_change **tt_change,
  				   int32_t *tt_len)
  {
  	uint16_t num_vlan = 0, num_entries = 0, change_offset, tvlv_len;
  	struct batadv_tvlv_tt_vlan_data *tt_vlan;
  	struct batadv_orig_node_vlan *vlan;
  	uint8_t *tt_change_ptr;
  
  	rcu_read_lock();
  	list_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
  		num_vlan++;
  		num_entries += atomic_read(&vlan->tt.num_entries);
  	}
  
  	change_offset = sizeof(**tt_data);
  	change_offset += num_vlan * sizeof(*tt_vlan);
  
  	/* if tt_len is negative, allocate the space needed by the full table */
  	if (*tt_len < 0)
  		*tt_len = batadv_tt_len(num_entries);
  
  	tvlv_len = *tt_len;
  	tvlv_len += change_offset;
  
  	*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
  	if (!*tt_data) {
  		*tt_len = 0;
  		goto out;
  	}
  
  	(*tt_data)->flags = BATADV_NO_FLAGS;
  	(*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);
  	(*tt_data)->num_vlan = htons(num_vlan);
  
  	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
  	list_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
  		tt_vlan->vid = htons(vlan->vid);
  		tt_vlan->crc = htonl(vlan->tt.crc);
  
  		tt_vlan++;
  	}
  
  	tt_change_ptr = (uint8_t *)*tt_data + change_offset;
  	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
  
  out:
  	rcu_read_unlock();
  	return tvlv_len;
  }
  
  /**
   * batadv_tt_prepare_tvlv_local_data - allocate and prepare the TT TVLV for this
   *  node
   * @bat_priv: the bat priv with all the soft interface information
   * @tt_data: uninitialised pointer to the address of the TVLV buffer
   * @tt_change: uninitialised pointer to the address of the area where the TT
   *  changes can be stored
   * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
   *  function reserves the amount of space needed to send the entire local TT
   *  table. In case of success the value is updated with the real amount of
   *  reserved bytes
   *
   * Allocate the needed amount of memory for the entire TT TVLV and write its
   * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
   * objects, one per active VLAN.
   *
   * Return the size of the allocated buffer or 0 in case of failure.
   */
  static uint16_t
  batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,
  				  struct batadv_tvlv_tt_data **tt_data,
  				  struct batadv_tvlv_tt_change **tt_change,
  				  int32_t *tt_len)
  {
  	struct batadv_tvlv_tt_vlan_data *tt_vlan;
  	struct batadv_softif_vlan *vlan;
  	uint16_t num_vlan = 0, num_entries = 0, tvlv_len;
  	uint8_t *tt_change_ptr;
  	int change_offset;
  
  	rcu_read_lock();
  	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
  		num_vlan++;
  		num_entries += atomic_read(&vlan->tt.num_entries);
  	}
  
  	change_offset = sizeof(**tt_data);
  	change_offset += num_vlan * sizeof(*tt_vlan);
  
  	/* if tt_len is negative, allocate the space needed by the full table */
  	if (*tt_len < 0)
  		*tt_len = batadv_tt_len(num_entries);
  
  	tvlv_len = *tt_len;
  	tvlv_len += change_offset;
  
  	*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
  	if (!*tt_data) {
  		tvlv_len = 0;
  		goto out;
  	}
  
  	(*tt_data)->flags = BATADV_NO_FLAGS;
  	(*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);
  	(*tt_data)->num_vlan = htons(num_vlan);
  
  	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
  	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
  		tt_vlan->vid = htons(vlan->vid);
  		tt_vlan->crc = htonl(vlan->tt.crc);
  
  		tt_vlan++;
  	}
  
  	tt_change_ptr = (uint8_t *)*tt_data + change_offset;
  	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
  
  out:
  	rcu_read_unlock();
  	return tvlv_len;
  }
  
  /**

   * batadv_tt_tvlv_container_update - update the translation table tvlv container
   *  after local tt changes have been committed
   * @bat_priv: the bat priv with all the soft interface information
   */
  static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)

  {

  	struct batadv_tt_change_node *entry, *safe;
  	struct batadv_tvlv_tt_data *tt_data;
  	struct batadv_tvlv_tt_change *tt_change;

  	int tt_diff_len, tt_change_len = 0;

  	int tt_diff_entries_num = 0, tt_diff_entries_count = 0;

  	uint16_t tvlv_len;

  	tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
  	tt_diff_len = batadv_tt_len(tt_diff_entries_num);

  
  	/* if we have too many changes for one packet don't send any
  	 * and wait for the tt table request which will be fragmented
  	 */

  	if (tt_diff_len > bat_priv->soft_iface->mtu)
  		tt_diff_len = 0;

  	tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
  						     &tt_change, &tt_diff_len);
  	if (!tvlv_len)

  		return;

  	tt_data->flags = BATADV_TT_OGM_DIFF;

  	if (tt_diff_len == 0)
  		goto container_register;

  	spin_lock_bh(&bat_priv->tt.changes_list_lock);
  	atomic_set(&bat_priv->tt.local_changes, 0);

  	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

  				 list) {

  		if (tt_diff_entries_count < tt_diff_entries_num) {
  			memcpy(tt_change + tt_diff_entries_count,
  			       &entry->change,
  			       sizeof(struct batadv_tvlv_tt_change));
  			tt_diff_entries_count++;

  		}

  		list_del(&entry->list);
  		kfree(entry);

  	}

  	spin_unlock_bh(&bat_priv->tt.changes_list_lock);

  
  	/* Keep the buffer for possible tt_request */

  	spin_lock_bh(&bat_priv->tt.last_changeset_lock);
  	kfree(bat_priv->tt.last_changeset);
  	bat_priv->tt.last_changeset_len = 0;
  	bat_priv->tt.last_changeset = NULL;

  	tt_change_len = batadv_tt_len(tt_diff_entries_count);

  	/* check whether this new OGM has no changes due to size problems */

  	if (tt_diff_entries_count > 0) {

  		/* if kmalloc() fails we will reply with the full table

  		 * instead of providing the diff
  		 */

  		bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);

  		if (bat_priv->tt.last_changeset) {

  			memcpy(bat_priv->tt.last_changeset,
  			       tt_change, tt_change_len);
  			bat_priv->tt.last_changeset_len = tt_diff_len;

  		}
  	}

  	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

  container_register:
  	batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,

  				       tvlv_len);

  	kfree(tt_data);

  }

  int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)

  {
  	struct net_device *net_dev = (struct net_device *)seq->private;

  	struct batadv_priv *bat_priv = netdev_priv(net_dev);

  	struct batadv_hashtable *hash = bat_priv->tt.local_hash;

  	struct batadv_tt_common_entry *tt_common_entry;

  	struct batadv_tt_local_entry *tt_local;

  	struct batadv_hard_iface *primary_if;

  	struct batadv_softif_vlan *vlan;

  	struct hlist_head *head;

  	unsigned short vid;

  	uint32_t i;

  	int last_seen_secs;
  	int last_seen_msecs;
  	unsigned long last_seen_jiffies;
  	bool no_purge;
  	uint16_t np_flag = BATADV_TT_CLIENT_NOPURGE;

  	primary_if = batadv_seq_print_text_primary_if_get(seq);
  	if (!primary_if)

  		goto out;

  	seq_printf(seq,

  		   "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):
  ",
  		   net_dev->name, (uint8_t)atomic_read(&bat_priv->tt.vn));

  	seq_printf(seq, "       %-13s  %s %-8s %-9s (%-10s)
  ", "Client", "VID",

  		   "Flags", "Last seen", "CRC");

  	for (i = 0; i < hash->size; i++) {
  		head = &hash->table[i];

  		rcu_read_lock();

  		hlist_for_each_entry_rcu(tt_common_entry,

  					 head, hash_entry) {

  			tt_local = container_of(tt_common_entry,
  						struct batadv_tt_local_entry,
  						common);

  			vid = tt_common_entry->vid;

  			last_seen_jiffies = jiffies - tt_local->last_seen;
  			last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
  			last_seen_secs = last_seen_msecs / 1000;
  			last_seen_msecs = last_seen_msecs % 1000;
  
  			no_purge = tt_common_entry->flags & np_flag;

  			vlan = batadv_softif_vlan_get(bat_priv, vid);
  			if (!vlan) {
  				seq_printf(seq, "Cannot retrieve VLAN %d
  ",
  					   BATADV_PRINT_VID(vid));
  				continue;
  			}
  
  			seq_printf(seq,

  				   " * %pM %4i [%c%c%c%c%c%c] %3u.%03u   (%#.8x)
  ",

  				   tt_common_entry->addr,

  				   BATADV_PRINT_VID(tt_common_entry->vid),

  				   (tt_common_entry->flags &

  				    BATADV_TT_CLIENT_ROAM ? 'R' : '.'),

  				   no_purge ? 'P' : '.',

  				   (tt_common_entry->flags &

  				    BATADV_TT_CLIENT_NEW ? 'N' : '.'),

  				   (tt_common_entry->flags &

  				    BATADV_TT_CLIENT_PENDING ? 'X' : '.'),

  				   (tt_common_entry->flags &

  				    BATADV_TT_CLIENT_WIFI ? 'W' : '.'),

  				   (tt_common_entry->flags &
  				    BATADV_TT_CLIENT_ISOLA ? 'I' : '.'),

  				   no_purge ? 0 : last_seen_secs,

  				   no_purge ? 0 : last_seen_msecs,
  				   vlan->tt.crc);
  
  			batadv_softif_vlan_free_ref(vlan);

  		}

  		rcu_read_unlock();

  	}

  out:
  	if (primary_if)

  		batadv_hardif_free_ref(primary_if);

  	return 0;

  }

  static void
  batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
  			    struct batadv_tt_local_entry *tt_local_entry,
  			    uint16_t flags, const char *message)

  {

  	batadv_tt_local_event(bat_priv, tt_local_entry, flags);

  	/* The local client has to be marked as "pending to be removed" but has
  	 * to be kept in the table in order to send it in a full table

  	 * response issued before the net ttvn increment (consistency check)
  	 */

  	tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;

  	batadv_dbg(BATADV_DBG_TT, bat_priv,

  		   "Local tt entry (%pM, vid: %d) pending to be removed: %s
  ",
  		   tt_local_entry->common.addr,
  		   BATADV_PRINT_VID(tt_local_entry->common.vid), message);

  }

  /**
   * batadv_tt_local_remove - logically remove an entry from the local table
   * @bat_priv: the bat priv with all the soft interface information
   * @addr: the MAC address of the client to remove

   * @vid: VLAN identifier

   * @message: message to append to the log on deletion
   * @roaming: true if the deletion is due to a roaming event
   *
   * Returns the flags assigned to the local entry before being deleted
   */
  uint16_t batadv_tt_local_remove(struct batadv_priv *bat_priv,

  				const uint8_t *addr, unsigned short vid,
  				const char *message, bool roaming)

  {

  	struct batadv_tt_local_entry *tt_local_entry;

  	uint16_t flags, curr_flags = BATADV_NO_FLAGS;

  	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);

  	if (!tt_local_entry)
  		goto out;

  	curr_flags = tt_local_entry->common.flags;

  	flags = BATADV_TT_CLIENT_DEL;

  	/* if this global entry addition is due to a roaming, the node has to
  	 * mark the local entry as "roamed" in order to correctly reroute
  	 * packets later
  	 */

  	if (roaming) {

  		flags |= BATADV_TT_CLIENT_ROAM;

  		/* mark the local client as ROAMed */
  		tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
  	}

  	if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {
  		batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,
  					    message);
  		goto out;
  	}
  	/* if this client has been added right now, it is possible to
  	 * immediately purge it
  	 */

  	batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);

  	hlist_del_rcu(&tt_local_entry->common.hash_entry);
  	batadv_tt_local_entry_free_ref(tt_local_entry);

  out:
  	if (tt_local_entry)

  		batadv_tt_local_entry_free_ref(tt_local_entry);

  
  	return curr_flags;

  }

  /**
   * batadv_tt_local_purge_list - purge inactive tt local entries
   * @bat_priv: the bat priv with all the soft interface information
   * @head: pointer to the list containing the local tt entries
   * @timeout: parameter deciding whether a given tt local entry is considered
   *  inactive or not
   */

  static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,

  				       struct hlist_head *head,
  				       int timeout)

  {

  	struct batadv_tt_local_entry *tt_local_entry;
  	struct batadv_tt_common_entry *tt_common_entry;

  	struct hlist_node *node_tmp;

  	hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,

  				  hash_entry) {
  		tt_local_entry = container_of(tt_common_entry,

  					      struct batadv_tt_local_entry,
  					      common);

  		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
  			continue;
  
  		/* entry already marked for deletion */
  		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
  			continue;

  		if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))

  			continue;
  
  		batadv_tt_local_set_pending(bat_priv, tt_local_entry,
  					    BATADV_TT_CLIENT_DEL, "timed out");
  	}
  }

  /**
   * batadv_tt_local_purge - purge inactive tt local entries
   * @bat_priv: the bat priv with all the soft interface information
   * @timeout: parameter deciding whether a given tt local entry is considered
   *  inactive or not
   */
  static void batadv_tt_local_purge(struct batadv_priv *bat_priv,
  				  int timeout)

  {

  	struct batadv_hashtable *hash = bat_priv->tt.local_hash;

  	struct hlist_head *head;

  	spinlock_t *list_lock; /* protects write access to the hash lists */

  	uint32_t i;

  	for (i = 0; i < hash->size; i++) {
  		head = &hash->table[i];

  		list_lock = &hash->list_locks[i];

  		spin_lock_bh(list_lock);

  		batadv_tt_local_purge_list(bat_priv, head, timeout);

  		spin_unlock_bh(list_lock);

  	}

  }

  static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)

  {

  	struct batadv_hashtable *hash;

  	spinlock_t *list_lock; /* protects write access to the hash lists */

  	struct batadv_tt_common_entry *tt_common_entry;
  	struct batadv_tt_local_entry *tt_local;

  	struct hlist_node *node_tmp;

  	struct hlist_head *head;

  	uint32_t i;

  	if (!bat_priv->tt.local_hash)

  		return;

  	hash = bat_priv->tt.local_hash;

  
  	for (i = 0; i < hash->size; i++) {
  		head = &hash->table[i];
  		list_lock = &hash->list_locks[i];
  
  		spin_lock_bh(list_lock);

  		hlist_for_each_entry_safe(tt_common_entry, node_tmp,

  					  head, hash_entry) {

  			hlist_del_rcu(&tt_common_entry->hash_entry);

  			tt_local = container_of(tt_common_entry,
  						struct batadv_tt_local_entry,
  						common);
  			batadv_tt_local_entry_free_ref(tt_local);

  		}
  		spin_unlock_bh(list_lock);
  	}

  	batadv_hash_destroy(hash);

  	bat_priv->tt.local_hash = NULL;

  }

  static int batadv_tt_global_init(struct batadv_priv *bat_priv)

  {

  	if (bat_priv->tt.global_hash)

  		return 0;

  	bat_priv->tt.global_hash = batadv_hash_new(1024);

  	if (!bat_priv->tt.global_hash)

  		return -ENOMEM;

  	batadv_hash_set_lock_class(bat_priv->tt.global_hash,
  				   &batadv_tt_global_hash_lock_class_key);

  	return 0;

  }

  static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)

  {

  	struct batadv_tt_change_node *entry, *safe;

  	spin_lock_bh(&bat_priv->tt.changes_list_lock);

  	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,

  				 list) {
  		list_del(&entry->list);
  		kfree(entry);
  	}

  	atomic_set(&bat_priv->tt.local_changes, 0);
  	spin_unlock_bh(&bat_priv->tt.changes_list_lock);

  }

  /* retrieves the orig_tt_list_entry belonging to orig_node from the
   * batadv_tt_global_entry list
   *
   * returns it with an increased refcounter, NULL if not found

   */

  static struct batadv_tt_orig_list_entry *
  batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
  				 const struct batadv_orig_node *orig_node)

  {

  	struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;

  	const struct hlist_head *head;

  
  	rcu_read_lock();
  	head = &entry->orig_list;

  	hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {

  		if (tmp_orig_entry->orig_node != orig_node)
  			continue;
  		if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))
  			continue;
  
  		orig_entry = tmp_orig_entry;
  		break;

  	}
  	rcu_read_unlock();

  
  	return orig_entry;
  }
  
  /* find out if an orig_node is already in the list of a tt_global_entry.
   * returns true if found, false otherwise
   */
  static bool
  batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
  				const struct batadv_orig_node *orig_node)
  {
  	struct batadv_tt_orig_list_entry *orig_entry;
  	bool found = false;
  
  	orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);
  	if (orig_entry) {
  		found = true;
  		batadv_tt_orig_list_entry_free_ref(orig_entry);
  	}

  	return found;
  }

  static void

  batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,

  				struct batadv_orig_node *orig_node, int ttvn)

  {

  	struct batadv_tt_orig_list_entry *orig_entry;

  	orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);

  	if (orig_entry) {
  		/* refresh the ttvn: the current value could be a bogus one that
  		 * was added during a "temporary client detection"
  		 */
  		orig_entry->ttvn = ttvn;

  		goto out;

  	}

  	orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
  	if (!orig_entry)

  		goto out;

  
  	INIT_HLIST_NODE(&orig_entry->list);
  	atomic_inc(&orig_node->refcount);

  	batadv_tt_global_size_inc(orig_node, tt_global->common.vid);

  	orig_entry->orig_node = orig_node;
  	orig_entry->ttvn = ttvn;

  	atomic_set(&orig_entry->refcount, 2);

  	spin_lock_bh(&tt_global->list_lock);

  	hlist_add_head_rcu(&orig_entry->list,

  			   &tt_global->orig_list);
  	spin_unlock_bh(&tt_global->list_lock);

  	atomic_inc(&tt_global->orig_list_count);

  out:
  	if (orig_entry)
  		batadv_tt_orig_list_entry_free_ref(orig_entry);

  }

  /**
   * batadv_tt_global_add - add a new TT global entry or update an existing one
   * @bat_priv: the bat priv with all the soft interface information
   * @orig_node: the originator announcing the client
   * @tt_addr: the mac address of the non-mesh client

   * @vid: VLAN identifier

   * @flags: TT flags that have to be set for this non-mesh client
   * @ttvn: the tt version number ever announcing this non-mesh client
   *
   * Add a new TT global entry for the given originator. If the entry already
   * exists add a new reference to the given originator (a global entry can have
   * references to multiple originators) and adjust the flags attribute to reflect
   * the function argument.
   * If a TT local entry exists for this non-mesh client remove it.
   *
   * The caller must hold orig_node refcount.

   *
   * Return true if the new entry has been added, false otherwise

   */

  static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
  				 struct batadv_orig_node *orig_node,

  				 const unsigned char *tt_addr,
  				 unsigned short vid, uint16_t flags,

  				 uint8_t ttvn)

  {

  	struct batadv_tt_global_entry *tt_global_entry;
  	struct batadv_tt_local_entry *tt_local_entry;

  	bool ret = false;

  	int hash_added;

  	struct batadv_tt_common_entry *common;

  	uint16_t local_flags;

  	/* ignore global entries from backbone nodes */
  	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
  		return true;

  	tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);
  	tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);

  
  	/* if the node already has a local client for this entry, it has to wait
  	 * for a roaming advertisement instead of manually messing up the global
  	 * table
  	 */
  	if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&
  	    !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))
  		goto out;

  
  	if (!tt_global_entry) {

  		tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);

  		if (!tt_global_entry)

  			goto out;

  		common = &tt_global_entry->common;

  		ether_addr_copy(common->addr, tt_addr);

  		common->vid = vid;

  		common->flags = flags;

  		tt_global_entry->roam_at = 0;

  		/* node must store current time in case of roaming. This is
  		 * needed to purge this entry out on timeout (if nobody claims
  		 * it)
  		 */
  		if (flags & BATADV_TT_CLIENT_ROAM)
  			tt_global_entry->roam_at = jiffies;

  		atomic_set(&common->refcount, 2);

  		common->added_at = jiffies;

  
  		INIT_HLIST_HEAD(&tt_global_entry->orig_list);

  		atomic_set(&tt_global_entry->orig_list_count, 0);

  		spin_lock_init(&tt_global_entry->list_lock);

  		hash_added = batadv_hash_add(bat_priv->tt.global_hash,

  					     batadv_compare_tt,

  					     batadv_choose_tt, common,

  					     &common->hash_entry);

  
  		if (unlikely(hash_added != 0)) {
  			/* remove the reference for the hash */

  			batadv_tt_global_entry_free_ref(tt_global_entry);

  			goto out_remove;
  		}

  	} else {

  		common = &tt_global_entry->common;

  		/* If there is already a global entry, we can use this one for
  		 * our processing.

  		 * But if we are trying to add a temporary client then here are
  		 * two options at this point:
  		 * 1) the global client is not a temporary client: the global
  		 *    client has to be left as it is, temporary information
  		 *    should never override any already known client state
  		 * 2) the global client is a temporary client: purge the
  		 *    originator list and add the new one orig_entry

  		 */

  		if (flags & BATADV_TT_CLIENT_TEMP) {
  			if (!(common->flags & BATADV_TT_CLIENT_TEMP))
  				goto out;
  			if (batadv_tt_global_entry_has_orig(tt_global_entry,
  							    orig_node))
  				goto out_remove;
  			batadv_tt_global_del_orig_list(tt_global_entry);
  			goto add_orig_entry;
  		}

  
  		/* if the client was temporary added before receiving the first
  		 * OGM announcing it, we have to clear the TEMP flag
  		 */

  		common->flags &= ~BATADV_TT_CLIENT_TEMP;

  		/* the change can carry possible "attribute" flags like the
  		 * TT_CLIENT_WIFI, therefore they have to be copied in the
  		 * client entry
  		 */
  		tt_global_entry->common.flags |= flags;

  		/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
  		 * one originator left in the list and we previously received a

  		 * delete + roaming change for this originator.
  		 *
  		 * We should first delete the old originator before adding the
  		 * new one.
  		 */

  		if (common->flags & BATADV_TT_CLIENT_ROAM) {

  			batadv_tt_global_del_orig_list(tt_global_entry);

  			common->flags &= ~BATADV_TT_CLIENT_ROAM;

  			tt_global_entry->roam_at = 0;

  		}
  	}

  add_orig_entry:

  	/* add the new orig_entry (if needed) or update it */

  	batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);

  	batadv_dbg(BATADV_DBG_TT, bat_priv,

  		   "Creating new global tt entry: %pM (vid: %d, via %pM)
  ",
  		   common->addr, BATADV_PRINT_VID(common->vid),
  		   orig_node->orig);

  	ret = true;

  out_remove:

  	/* Do not remove multicast addresses from the local hash on
  	 * global additions
  	 */
  	if (is_multicast_ether_addr(tt_addr))
  		goto out;

  	/* remove address from local hash if present */

  	local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,

  					     "global tt received",

  					     flags & BATADV_TT_CLIENT_ROAM);

  	tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;

  	if (!(flags & BATADV_TT_CLIENT_ROAM))
  		/* this is a normal global add. Therefore the client is not in a
  		 * roaming state anymore.
  		 */
  		tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;

  out:
  	if (tt_global_entry)

  		batadv_tt_global_entry_free_ref(tt_global_entry);

  	if (tt_local_entry)
  		batadv_tt_local_entry_free_ref(tt_local_entry);

  	return ret;

  }

  /**
   * batadv_transtable_best_orig - Get best originator list entry from tt entry

   * @bat_priv: the bat priv with all the soft interface information

   * @tt_global_entry: global translation table entry to be analyzed
   *
   * This functon assumes the caller holds rcu_read_lock().
   * Returns best originator list entry or NULL on errors.
   */
  static struct batadv_tt_orig_list_entry *

  batadv_transtable_best_orig(struct batadv_priv *bat_priv,
  			    struct batadv_tt_global_entry *tt_global_entry)

  {

  	struct batadv_neigh_node *router, *best_router = NULL;
  	struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;

  	struct hlist_head *head;

  	struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;

  
  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_rcu(orig_entry, head, list) {

  		router = batadv_orig_router_get(orig_entry->orig_node,
  						BATADV_IF_DEFAULT);

  		if (!router)
  			continue;

  		if (best_router &&

  		    bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT,
  				       best_router, BATADV_IF_DEFAULT) <= 0) {

  			batadv_neigh_node_free_ref(router);
  			continue;

  		}

  		/* release the refcount for the "old" best */
  		if (best_router)
  			batadv_neigh_node_free_ref(best_router);
  
  		best_entry = orig_entry;
  		best_router = router;

  	}

  	if (best_router)
  		batadv_neigh_node_free_ref(best_router);

  	return best_entry;
  }

  /**
   * batadv_tt_global_print_entry - print all orig nodes who announce the address
   *  for this global entry

   * @bat_priv: the bat priv with all the soft interface information

   * @tt_global_entry: global translation table entry to be printed
   * @seq: debugfs table seq_file struct
   *
   * This functon assumes the caller holds rcu_read_lock().

   */

  static void

  batadv_tt_global_print_entry(struct batadv_priv *bat_priv,
  			     struct batadv_tt_global_entry *tt_global_entry,

  			     struct seq_file *seq)

  {

  	struct batadv_tt_orig_list_entry *orig_entry, *best_entry;

  	struct batadv_tt_common_entry *tt_common_entry;

  	struct batadv_orig_node_vlan *vlan;
  	struct hlist_head *head;

  	uint8_t last_ttvn;

  	uint16_t flags;

  
  	tt_common_entry = &tt_global_entry->common;

  	flags = tt_common_entry->flags;

  	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);

  	if (best_entry) {

  		vlan = batadv_orig_node_vlan_get(best_entry->orig_node,
  						 tt_common_entry->vid);
  		if (!vlan) {
  			seq_printf(seq,
  				   " * Cannot retrieve VLAN %d for originator %pM
  ",
  				   BATADV_PRINT_VID(tt_common_entry->vid),
  				   best_entry->orig_node->orig);
  			goto print_list;
  		}

  		last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);

  		seq_printf(seq,

  			   " %c %pM %4i   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]
  ",

  			   '*', tt_global_entry->common.addr,

  			   BATADV_PRINT_VID(tt_global_entry->common.vid),

  			   best_entry->ttvn, best_entry->orig_node->orig,

  			   last_ttvn, vlan->tt.crc,

  			   (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
  			   (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'),

  			   (flags & BATADV_TT_CLIENT_ISOLA ? 'I' : '.'),

  			   (flags & BATADV_TT_CLIENT_TEMP ? 'T' : '.'));

  
  		batadv_orig_node_vlan_free_ref(vlan);

  	}

  print_list:

  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_rcu(orig_entry, head, list) {

  		if (best_entry == orig_entry)
  			continue;

  		vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,
  						 tt_common_entry->vid);
  		if (!vlan) {
  			seq_printf(seq,
  				   " + Cannot retrieve VLAN %d for originator %pM
  ",
  				   BATADV_PRINT_VID(tt_common_entry->vid),
  				   orig_entry->orig_node->orig);
  			continue;
  		}

  		last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);

  		seq_printf(seq,

  			   " %c %pM %4d   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]
  ",

  			   '+', tt_global_entry->common.addr,

  			   BATADV_PRINT_VID(tt_global_entry->common.vid),

  			   orig_entry->ttvn, orig_entry->orig_node->orig,

  			   last_ttvn, vlan->tt.crc,

  			   (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'),

  			   (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'),

  			   (flags & BATADV_TT_CLIENT_ISOLA ? 'I' : '.'),

  			   (flags & BATADV_TT_CLIENT_TEMP ? 'T' : '.'));

  
  		batadv_orig_node_vlan_free_ref(vlan);

  	}
  }

  int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)

  {
  	struct net_device *net_dev = (struct net_device *)seq->private;

  	struct batadv_priv *bat_priv = netdev_priv(net_dev);

  	struct batadv_hashtable *hash = bat_priv->tt.global_hash;

  	struct batadv_tt_common_entry *tt_common_entry;
  	struct batadv_tt_global_entry *tt_global;
  	struct batadv_hard_iface *primary_if;

  	struct hlist_head *head;

  	uint32_t i;

  	primary_if = batadv_seq_print_text_primary_if_get(seq);
  	if (!primary_if)

  		goto out;

  	seq_printf(seq,
  		   "Globally announced TT entries received via the mesh %s
  ",

  		   net_dev->name);

  	seq_printf(seq, "       %-13s  %s  %s       %-15s %s (%-10s) %s
  ",
  		   "Client", "VID", "(TTVN)", "Originator", "(Curr TTVN)",
  		   "CRC", "Flags");

  	for (i = 0; i < hash->size; i++) {
  		head = &hash->table[i];

  		rcu_read_lock();

  		hlist_for_each_entry_rcu(tt_common_entry,

  					 head, hash_entry) {

  			tt_global = container_of(tt_common_entry,
  						 struct batadv_tt_global_entry,
  						 common);

  			batadv_tt_global_print_entry(bat_priv, tt_global, seq);

  		}

  		rcu_read_unlock();

  	}

  out:
  	if (primary_if)

  		batadv_hardif_free_ref(primary_if);

  	return 0;

  }

  /**
   * batadv_tt_global_del_orig_entry - remove and free an orig_entry
   * @tt_global_entry: the global entry to remove the orig_entry from
   * @orig_entry: the orig entry to remove and free
   *
   * Remove an orig_entry from its list in the given tt_global_entry and
   * free this orig_entry afterwards.
   */
  static void
  batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
  				struct batadv_tt_orig_list_entry *orig_entry)
  {
  	batadv_tt_global_size_dec(orig_entry->orig_node,
  				  tt_global_entry->common.vid);
  	atomic_dec(&tt_global_entry->orig_list_count);
  	hlist_del_rcu(&orig_entry->list);
  	batadv_tt_orig_list_entry_free_ref(orig_entry);
  }

  /* deletes the orig list of a tt_global_entry */

  static void