/* Copyright (C) 2007-2013 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, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   * 02110-1301, USA

   */
  
  #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 <linux/crc16.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,
  				 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,
  				 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 (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
  }

  static struct batadv_tt_common_entry *

  batadv_tt_hash_find(struct batadv_hashtable *hash, const void *data)

  {

  	struct hlist_head *head;

  	struct batadv_tt_common_entry *tt_common_entry;
  	struct batadv_tt_common_entry *tt_common_entry_tmp = NULL;

  	uint32_t index;

  
  	if (!hash)
  		return NULL;

  	index = batadv_choose_orig(data, hash->size);

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

  	hlist_for_each_entry_rcu(tt_common_entry, head, hash_entry) {

  		if (!batadv_compare_eth(tt_common_entry, data))

  			continue;

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

  			continue;

  		tt_common_entry_tmp = tt_common_entry;

  		break;
  	}
  	rcu_read_unlock();

  	return tt_common_entry_tmp;

  }

  static struct batadv_tt_local_entry *
  batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const void *data)

  {

  	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, data);

  	if (tt_common_entry)
  		tt_local_entry = container_of(tt_common_entry,

  					      struct batadv_tt_local_entry,
  					      common);

  	return tt_local_entry;
  }

  static struct batadv_tt_global_entry *
  batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const void *data)

  {

  	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, data);

  	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);

  }

  static void batadv_tt_global_entry_free_rcu(struct rcu_head *rcu)

  {

  	struct batadv_tt_common_entry *tt_common_entry;
  	struct batadv_tt_global_entry *tt_global_entry;

  	tt_common_entry = container_of(rcu, struct batadv_tt_common_entry, rcu);
  	tt_global_entry = container_of(tt_common_entry,
  				       struct batadv_tt_global_entry, common);

  	kfree(tt_global_entry);
  }

  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);

  		call_rcu(&tt_global_entry->common.rcu,

  			 batadv_tt_global_entry_free_rcu);

  	}
  }

  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);
  }

  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;

  	/* to avoid race conditions, immediately decrease the tt counter */
  	atomic_dec(&orig_entry->orig_node->tt_size);

  	call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);

  }

  static void batadv_tt_local_event(struct batadv_priv *bat_priv,

  				  const uint8_t *addr, uint8_t flags)

  {

  	struct batadv_tt_change_node *tt_change_node, *entry, *safe;

  	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;

  	memcpy(tt_change_node->change.addr, addr, ETH_ALEN);

  	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, 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;
  		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);

  }

  int batadv_tt_len(int changes_num)

  {

  	return changes_num * sizeof(struct batadv_tt_change);

  }

  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: %s
  ",
  		   tt_global->common.addr, message);
  
  	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
  			   batadv_choose_orig, tt_global->common.addr);
  	batadv_tt_global_entry_free_ref(tt_global);

  }

  void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
  			 int ifindex)

  {

  	struct batadv_priv *bat_priv = netdev_priv(soft_iface);

  	struct batadv_tt_local_entry *tt_local;
  	struct batadv_tt_global_entry *tt_global;

  	struct hlist_head *head;

  	struct batadv_tt_orig_list_entry *orig_entry;

  	int hash_added;

  	bool roamed_back = false;

  	tt_local = batadv_tt_local_hash_find(bat_priv, addr);

  	tt_global = batadv_tt_global_hash_find(bat_priv, addr);

  	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
  ", addr);
  			/* 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 came back to its original location
  ",
  				   addr);
  			/* 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;

  	}

  	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 (ttvn: %d)
  ", addr,

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

  	memcpy(tt_local->common.addr, addr, ETH_ALEN);

  	/* 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;

  	if (batadv_is_wifi_iface(ifindex))

  		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 address should never be purged */

  	if (batadv_compare_eth(addr, soft_iface->dev_addr))

  		tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;

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

  				     batadv_choose_orig, &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, addr, tt_local->common.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,

  					     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;
  		}

  	}

  out:

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

  }

  static void batadv_tt_realloc_packet_buff(unsigned char **packet_buff,
  					  int *packet_buff_len,
  					  int min_packet_len,
  					  int new_packet_len)

  {
  	unsigned char *new_buff;
  
  	new_buff = kmalloc(new_packet_len, GFP_ATOMIC);
  
  	/* keep old buffer if kmalloc should fail */
  	if (new_buff) {
  		memcpy(new_buff, *packet_buff, min_packet_len);
  		kfree(*packet_buff);
  		*packet_buff = new_buff;
  		*packet_buff_len = new_packet_len;
  	}
  }

  static void batadv_tt_prepare_packet_buff(struct batadv_priv *bat_priv,

  					  unsigned char **packet_buff,
  					  int *packet_buff_len,
  					  int min_packet_len)

  {

  	int req_len;

  	req_len = min_packet_len;

  	req_len += batadv_tt_len(atomic_read(&bat_priv->tt.local_changes));

  
  	/* 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 (req_len > bat_priv->soft_iface->mtu)

  		req_len = min_packet_len;

  	batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
  				      min_packet_len, req_len);

  }

  static int batadv_tt_changes_fill_buff(struct batadv_priv *bat_priv,

  				       unsigned char **packet_buff,
  				       int *packet_buff_len,
  				       int min_packet_len)

  {

  	struct batadv_tt_change_node *entry, *safe;

  	int count = 0, tot_changes = 0, new_len;
  	unsigned char *tt_buff;

  	batadv_tt_prepare_packet_buff(bat_priv, packet_buff,
  				      packet_buff_len, min_packet_len);

  	new_len = *packet_buff_len - min_packet_len;
  	tt_buff = *packet_buff + min_packet_len;
  
  	if (new_len > 0)

  		tot_changes = new_len / batadv_tt_len(1);

  	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 (count < tot_changes) {

  			memcpy(tt_buff + batadv_tt_len(count),

  			       &entry->change, sizeof(struct batadv_tt_change));

  			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;

  	/* check whether this new OGM has no changes due to size problems */
  	if (new_len > 0) {
  		/* if kmalloc() fails we will reply with the full table

  		 * instead of providing the diff
  		 */

  		bat_priv->tt.last_changeset = kmalloc(new_len, GFP_ATOMIC);
  		if (bat_priv->tt.last_changeset) {
  			memcpy(bat_priv->tt.last_changeset, tt_buff, new_len);
  			bat_priv->tt.last_changeset_len = new_len;

  		}
  	}

  	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);

  	return count;

  }

  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 hlist_head *head;

  	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 CRC: %#.4x):
  ",
  		   net_dev->name, (uint8_t)atomic_read(&bat_priv->tt.vn),
  		   bat_priv->tt.local_crc);

  	seq_printf(seq, "       %-13s %-7s %-10s
  ", "Client", "Flags",
  		   "Last seen");

  	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);
  			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;
  
  			seq_printf(seq, " * %pM [%c%c%c%c%c] %3u.%03u
  ",

  				   tt_common_entry->addr,
  				   (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' : '.'),

  				   no_purge ? 0 : last_seen_secs,
  				   no_purge ? 0 : last_seen_msecs);

  		}

  		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->common.addr,
  			      tt_local_entry->common.flags | 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) pending to be removed: %s
  ",
  		   tt_local_entry->common.addr, 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
   * @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, 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);

  	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->common.addr,
  			      curr_flags | 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;

  }

  static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,

  				       struct hlist_head *head)

  {

  	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,
  					  BATADV_TT_LOCAL_TIMEOUT))
  			continue;
  
  		batadv_tt_local_set_pending(bat_priv, tt_local_entry,
  					    BATADV_TT_CLIENT_DEL, "timed out");
  	}
  }

  static void batadv_tt_local_purge(struct batadv_priv *bat_priv)

  {

  	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);

  		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);
  	atomic_inc(&orig_node->tt_size);
  	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);
  out:
  	if (orig_entry)
  		batadv_tt_orig_list_entry_free_ref(orig_entry);

  }

  /* caller must hold orig_node refcount */

  int batadv_tt_global_add(struct batadv_priv *bat_priv,
  			 struct batadv_orig_node *orig_node,

  			 const unsigned char *tt_addr, uint8_t flags,
  			 uint8_t ttvn)

  {

  	struct batadv_tt_global_entry *tt_global_entry;
  	struct batadv_tt_local_entry *tt_local_entry;

  	int ret = 0;

  	int hash_added;

  	struct batadv_tt_common_entry *common;

  	uint16_t local_flags;

  	tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr);

  	tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr);
  
  	/* 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;
  		memcpy(common->addr, tt_addr, ETH_ALEN);

  		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);
  		spin_lock_init(&tt_global_entry->list_lock);

  		hash_added = batadv_hash_add(bat_priv->tt.global_hash,

  					     batadv_compare_tt,
  					     batadv_choose_orig, 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 (via %pM)
  ",

  		   common->addr, orig_node->orig);

  	ret = 1;

  out_remove:

  	/* remove address from local hash if present */

  	local_flags = batadv_tt_local_remove(bat_priv, tt_addr,
  					     "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
   * @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_tt_global_entry *tt_global_entry)
  {
  	struct batadv_neigh_node *router = NULL;
  	struct hlist_head *head;

  	struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;
  	int best_tq = 0;
  
  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_rcu(orig_entry, head, list) {

  		router = batadv_orig_node_get_router(orig_entry->orig_node);
  		if (!router)
  			continue;
  
  		if (router->tq_avg > best_tq) {
  			best_entry = orig_entry;
  			best_tq = router->tq_avg;
  		}
  
  		batadv_neigh_node_free_ref(router);
  	}
  
  	return best_entry;
  }
  
  /* batadv_tt_global_print_entry - print all orig nodes who announce the address
   * for this global entry
   * @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_tt_global_entry *tt_global_entry,

  			     struct seq_file *seq)

  {
  	struct hlist_head *head;

  	struct batadv_tt_orig_list_entry *orig_entry, *best_entry;

  	struct batadv_tt_common_entry *tt_common_entry;

  	uint16_t flags;
  	uint8_t last_ttvn;
  
  	tt_common_entry = &tt_global_entry->common;

  	flags = tt_common_entry->flags;
  
  	best_entry = batadv_transtable_best_orig(tt_global_entry);
  	if (best_entry) {
  		last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);

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

  			   '*', tt_global_entry->common.addr,
  			   best_entry->ttvn, best_entry->orig_node->orig,

  			   last_ttvn, best_entry->orig_node->tt_crc,

  			   (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
  			   (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'),
  			   (flags & BATADV_TT_CLIENT_TEMP ? 'T' : '.'));
  	}

  
  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_rcu(orig_entry, head, list) {

  		if (best_entry == orig_entry)
  			continue;

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

  		seq_printf(seq,	" %c %pM  (%3u) via %pM     (%3u)   [%c%c%c]
  ",
  			   '+', tt_global_entry->common.addr,
  			   orig_entry->ttvn, orig_entry->orig_node->orig,
  			   last_ttvn,

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

  			   (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'),
  			   (flags & BATADV_TT_CLIENT_TEMP ? 'T' : '.'));

  	}
  }

  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       %-15s %s (%-6s) %s
  ",
  		   "Client", "(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(tt_global, seq);

  		}

  		rcu_read_unlock();

  	}

  out:
  	if (primary_if)

  		batadv_hardif_free_ref(primary_if);

  	return 0;

  }

  /* deletes the orig list of a tt_global_entry */

  static void

  batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)

  {

  	struct hlist_head *head;

  	struct hlist_node *safe;

  	struct batadv_tt_orig_list_entry *orig_entry;

  	spin_lock_bh(&tt_global_entry->list_lock);
  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_safe(orig_entry, safe, head, list) {
  		hlist_del_rcu(&orig_entry->list);

  		batadv_tt_orig_list_entry_free_ref(orig_entry);

  	}
  	spin_unlock_bh(&tt_global_entry->list_lock);

  }

  static void

  batadv_tt_global_del_orig_entry(struct batadv_priv *bat_priv,
  				struct batadv_tt_global_entry *tt_global_entry,
  				struct batadv_orig_node *orig_node,

  				const char *message)

  {
  	struct hlist_head *head;

  	struct hlist_node *safe;

  	struct batadv_tt_orig_list_entry *orig_entry;

  
  	spin_lock_bh(&tt_global_entry->list_lock);
  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_safe(orig_entry, safe, head, list) {

  		if (orig_entry->orig_node == orig_node) {

  			batadv_dbg(BATADV_DBG_TT, bat_priv,

  				   "Deleting %pM from global tt entry %pM: %s
  ",
  				   orig_node->orig,
  				   tt_global_entry->common.addr, message);

  			hlist_del_rcu(&orig_entry->list);

  			batadv_tt_orig_list_entry_free_ref(orig_entry);

  		}
  	}
  	spin_unlock_bh(&tt_global_entry->list_lock);
  }

  /* If the client is to be deleted, we check if it is the last origantor entry

   * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the
   * timer, otherwise we simply remove the originator scheduled for deletion.

   */

  static void

  batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
  			     struct batadv_tt_global_entry *tt_global_entry,
  			     struct batadv_orig_node *orig_node,
  			     const char *message)

  {
  	bool last_entry = true;
  	struct hlist_head *head;

  	struct batadv_tt_orig_list_entry *orig_entry;

  
  	/* no local entry exists, case 1:
  	 * Check if this is the last one or if other entries exist.
  	 */
  
  	rcu_read_lock();
  	head = &tt_global_entry->orig_list;

  	hlist_for_each_entry_rcu(orig_entry, head, list) {

  		if (orig_entry->orig_node != orig_node) {
  			last_entry = false;
  			break;
  		}
  	}
  	rcu_read_unlock();
  
  	if (last_entry) {
  		/* its the last one, mark for roaming. */

  		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;

  		tt_global_entry->roam_at = jiffies;
  	} else
  		/* there is another entry, we can simply delete this
  		 * one and can still use the other one.
  		 */

  		batadv_tt_global_del_orig_entry(bat_priv, tt_global_entry,
  						orig_node, message);

  }

  static void batadv_tt_global_del(struct batadv_priv *bat_priv,
  				 struct batadv_orig_node *orig_node,

  				 const unsigned char *addr,
  				 const char *message, bool roaming)

  {

  	struct batadv_tt_global_entry *tt_global_entry;

  	struct batadv_tt_local_entry *local_entry = NULL;

  	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);

  	if (!tt_global_entry)

  		goto out;

  	if (!roaming) {

  		batadv_tt_global_del_orig_entry(bat_priv, tt_global_entry,
  						orig_node, message);

  
  		if (hlist_empty(&tt_global_entry->orig_list))

  			batadv_tt_global_free(bat_priv, tt_global_entry,
  					      message);

  
  		goto out;
  	}

  
  	/* if we are deleting a global entry due to a roam
  	 * event, there are two possibilities:

  	 * 1) the client roamed from node A to node B => if there
  	 *    is only one originator left for this client, we mark

  	 *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we

  	 *    wait for node B to claim it. In case of timeout
  	 *    the entry is purged.

  	 *
  	 *    If there are other originators left, we directly delete
  	 *    the originator.

  	 * 2) the client roamed to us => we can directly delete

  	 *    the global entry, since it is useless now.
  	 */

  	local_entry = batadv_tt_local_hash_find(bat_priv,
  						tt_global_entry->common.addr);
  	if (local_entry) {

  		/* local entry exists, case 2: client roamed to us. */

  		batadv_tt_global_del_orig_list(tt_global_entry);

  		batadv_tt_global_free(bat_priv, tt_global_entry, message);

  	} else
  		/* no local entry exists, case 1: check for roaming */

  		batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
  					     orig_node, message);

  out:

  	if (tt_global_entry)

  		batadv_tt_global_entry_free_ref(tt_global_entry);
  	if (local_entry)
  		batadv_tt_local_entry_free_ref(local_entry);

  }

  void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
  			       struct batadv_orig_node *orig_node,
  			       const char *message)

  {

  	struct batadv_tt_global_entry *tt_global;
  	struct batadv_tt_common_entry *tt_common_entry;

  	uint32_t i;

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

  	struct hlist_node *safe;

  	struct hlist_head *head;

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

  	if (!hash)
  		return;

  	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, safe,

  					  head, hash_entry) {

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

  			batadv_tt_global_del_orig_entry(bat_priv, tt_global,

  							orig_node, message);

  			if (hlist_empty(&tt_global->orig_list)) {

  				batadv_dbg(BATADV_DBG_TT, bat_priv,

  					   "Deleting global tt entry %pM: %s
  ",

  					   tt_global->common.addr, message);

  				hlist_del_rcu(&tt_common_entry->hash_entry);

  				batadv_tt_global_entry_free_ref(tt_global);

  			}

  		}

  		spin_unlock_bh(list_lock);

  	}

  	orig_node->tt_initialised = false;

  }

  static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
  				      char **msg)

  {

  	bool purge = false;
  	unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
  	unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;

  	if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&
  	    batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {
  		purge = true;
  		*msg = "Roaming timeout
  ";
  	}

  	if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&
  	    batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {
  		purge = true;
  		*msg = "Temporary client timeout
  ";

  	}

  
  	return purge;

  }

  static void batadv_tt_global_purge(struct batadv_priv *bat_priv)

  {

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

  	struct hlist_head *head;

  	struct hlist_node *node_tmp;

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

  	uint32_t i;

  	char *msg = NULL;
  	struct batadv_tt_common_entry *tt_common;
  	struct batadv_tt_global_entry *tt_global;

  	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, node_tmp, head,

  					  hash_entry) {
  			tt_global = container_of(tt_common,
  						 struct batadv_tt_global_entry,
  						 common);
  
  			if (!batadv_tt_global_to_purge(tt_global, &msg))
  				continue;
  
  			batadv_dbg(BATADV_DBG_TT, bat_priv,
  				   "Deleting global tt entry (%pM): %s
  ",
  				   tt_global->common.addr, msg);