Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 7c1fd91da5a5eecc91674991199940c05f87cb3a

Authored by Antonio Quartulli 2012-09-24 04:38:34 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

batman-adv: substitute tt_poss_change with a per-tt_entry flag

tt_poss_change is a node-wide flag which tells whether the node is in a roaming
state (a client recently moved to/away from it) in order to let it apply special
re-routing rules. However this flag does not give a clear idea of the current
state because it is not possible to understand *which client* is actually
involved in the roaming. For this reason a better approach has been chosen:
instead of using a node-wide variable, the roaming state is now given by a
per-tt_entry ROAM flag which, in case of packet coming through the node, tells
the node whether the real destination is in roaming state or not.

With this flag change, batadv_check_unicast_ttvn() has also been rearranged in
order to better fit the new re-routing logic and to be much more readable.

Signed-off-by: Antonio Quartulli <ordex@autistici.org>

Showing 6 changed files with 156 additions and 75 deletions Inline Diff

net/batman-adv/originator.c
net/batman-adv/routing.c
net/batman-adv/soft-interface.c
net/batman-adv/translation-table.c
net/batman-adv/translation-table.h
net/batman-adv/types.h

net/batman-adv/originator.c

Diff comments View file @ 7c1fd91

 /* Copyright (C) 2009-2012 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * 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 "distributed-arp-table.h"
 #include "originator.h"
 #include "hash.h"
 #include "translation-table.h"
 #include "routing.h"
 #include "gateway_client.h"
 #include "hard-interface.h"
 #include "unicast.h"
 #include "soft-interface.h"
 #include "bridge_loop_avoidance.h"
 static void batadv_purge_orig(struct work_struct *work);
 static void batadv_start_purge_timer(struct batadv_priv *bat_priv)
 {
 	INIT_DELAYED_WORK(&bat_priv->orig_work, batadv_purge_orig);
 	queue_delayed_work(batadv_event_workqueue,
 			   &bat_priv->orig_work, msecs_to_jiffies(1000));
 }
 /* returns 1 if they are the same originator */
 static int batadv_compare_orig(const struct hlist_node *node, const void *data2)
 {
 	const void *data1 = container_of(node, struct batadv_orig_node,
 					 hash_entry);
 	return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
 }
 int batadv_originator_init(struct batadv_priv *bat_priv)
 {
 	if (bat_priv->orig_hash)
 		return 0;
 	bat_priv->orig_hash = batadv_hash_new(1024);
 	if (!bat_priv->orig_hash)
 		goto err;
 	batadv_start_purge_timer(bat_priv);
 	return 0;
 err:
 	return -ENOMEM;
 }
 void batadv_neigh_node_free_ref(struct batadv_neigh_node *neigh_node)
 {
 	if (atomic_dec_and_test(&neigh_node->refcount))
 		kfree_rcu(neigh_node, rcu);
 }
 /* increases the refcounter of a found router */
 struct batadv_neigh_node *
 batadv_orig_node_get_router(struct batadv_orig_node *orig_node)
 {
 	struct batadv_neigh_node *router;
 	rcu_read_lock();
 	router = rcu_dereference(orig_node->router);
 	if (router && !atomic_inc_not_zero(&router->refcount))
 		router = NULL;
 	rcu_read_unlock();
 	return router;
 }
 struct batadv_neigh_node *
 batadv_neigh_node_new(struct batadv_hard_iface *hard_iface,
 		      const uint8_t *neigh_addr, uint32_t seqno)
 {
 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 	struct batadv_neigh_node *neigh_node;
 	neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
 	if (!neigh_node)
 		goto out;
 	INIT_HLIST_NODE(&neigh_node->list);
 	memcpy(neigh_node->addr, neigh_addr, ETH_ALEN);
 	spin_lock_init(&neigh_node->lq_update_lock);
 	/* extra reference for return */
 	atomic_set(&neigh_node->refcount, 2);
 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 		   "Creating new neighbor %pM, initial seqno %d\n",
 		   neigh_addr, seqno);
 out:
 	return neigh_node;
 }
 static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
 {
 	struct hlist_node *node, *node_tmp;
 	struct batadv_neigh_node *neigh_node, *tmp_neigh_node;
 	struct batadv_orig_node *orig_node;
 	orig_node = container_of(rcu, struct batadv_orig_node, rcu);
 	spin_lock_bh(&orig_node->neigh_list_lock);
 	/* for all bonding members ... */
 	list_for_each_entry_safe(neigh_node, tmp_neigh_node,
 				 &orig_node->bond_list, bonding_list) {
 		list_del_rcu(&neigh_node->bonding_list);
 		batadv_neigh_node_free_ref(neigh_node);
 	}
 	/* for all neighbors towards this originator ... */
 	hlist_for_each_entry_safe(neigh_node, node, node_tmp,
 				  &orig_node->neigh_list, list) {
 		hlist_del_rcu(&neigh_node->list);
 		batadv_neigh_node_free_ref(neigh_node);
 	}
 	spin_unlock_bh(&orig_node->neigh_list_lock);
 	batadv_frag_list_free(&orig_node->frag_list);
 	batadv_tt_global_del_orig(orig_node->bat_priv, orig_node,
 				  "originator timed out");
 	kfree(orig_node->tt_buff);
 	kfree(orig_node->bcast_own);
 	kfree(orig_node->bcast_own_sum);
 	kfree(orig_node);
 }
 void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node)
 {
 	if (atomic_dec_and_test(&orig_node->refcount))
 		call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu);
 }
 void batadv_originator_free(struct batadv_priv *bat_priv)
 {
 	struct batadv_hashtable *hash = bat_priv->orig_hash;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	spinlock_t *list_lock; /* spinlock to protect write access */
 	struct batadv_orig_node *orig_node;
 	uint32_t i;
 	if (!hash)
 		return;
 	cancel_delayed_work_sync(&bat_priv->orig_work);
 	bat_priv->orig_hash = NULL;
 	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(orig_node, node, node_tmp,
 					  head, hash_entry) {
 			hlist_del_rcu(node);
 			batadv_orig_node_free_ref(orig_node);
 		}
 		spin_unlock_bh(list_lock);
 	}
 	batadv_hash_destroy(hash);
 }
 /* this function finds or creates an originator entry for the given
  * address if it does not exits
  */
 struct batadv_orig_node *batadv_get_orig_node(struct batadv_priv *bat_priv,
 					      const uint8_t *addr)
 {
 	struct batadv_orig_node *orig_node;
 	int size;
 	int hash_added;
 	unsigned long reset_time;
 	orig_node = batadv_orig_hash_find(bat_priv, addr);
 	if (orig_node)
 		return orig_node;
 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 		   "Creating new originator: %pM\n", addr);
 	orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
 	if (!orig_node)
 		return NULL;
 	INIT_HLIST_HEAD(&orig_node->neigh_list);
 	INIT_LIST_HEAD(&orig_node->bond_list);
 	spin_lock_init(&orig_node->ogm_cnt_lock);
 	spin_lock_init(&orig_node->bcast_seqno_lock);
 	spin_lock_init(&orig_node->neigh_list_lock);
 	spin_lock_init(&orig_node->tt_buff_lock);
 	/* extra reference for return */
 	atomic_set(&orig_node->refcount, 2);
 	orig_node->tt_initialised = false;
-	orig_node->tt_poss_change = false;
 	orig_node->bat_priv = bat_priv;
 	memcpy(orig_node->orig, addr, ETH_ALEN);
 	batadv_dat_init_orig_node_addr(orig_node);
 	orig_node->router = NULL;
 	orig_node->tt_crc = 0;
 	atomic_set(&orig_node->last_ttvn, 0);
 	orig_node->tt_buff = NULL;
 	orig_node->tt_buff_len = 0;
 	atomic_set(&orig_node->tt_size, 0);
 	reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);
 	orig_node->bcast_seqno_reset = reset_time;
 	orig_node->batman_seqno_reset = reset_time;
 	atomic_set(&orig_node->bond_candidates, 0);
 	size = bat_priv->num_ifaces * sizeof(unsigned long) * BATADV_NUM_WORDS;
 	orig_node->bcast_own = kzalloc(size, GFP_ATOMIC);
 	if (!orig_node->bcast_own)
 		goto free_orig_node;
 	size = bat_priv->num_ifaces * sizeof(uint8_t);
 	orig_node->bcast_own_sum = kzalloc(size, GFP_ATOMIC);
 	INIT_LIST_HEAD(&orig_node->frag_list);
 	orig_node->last_frag_packet = 0;
 	if (!orig_node->bcast_own_sum)
 		goto free_bcast_own;
 	hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,
 				     batadv_choose_orig, orig_node,
 				     &orig_node->hash_entry);
 	if (hash_added != 0)
 		goto free_bcast_own_sum;
 	return orig_node;
 free_bcast_own_sum:
 	kfree(orig_node->bcast_own_sum);
 free_bcast_own:
 	kfree(orig_node->bcast_own);
 free_orig_node:
 	kfree(orig_node);
 	return NULL;
 }
 static bool
 batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
 			    struct batadv_orig_node *orig_node,
 			    struct batadv_neigh_node **best_neigh_node)
 {
 	struct hlist_node *node, *node_tmp;
 	struct batadv_neigh_node *neigh_node;
 	bool neigh_purged = false;
 	unsigned long last_seen;
 	struct batadv_hard_iface *if_incoming;
 	*best_neigh_node = NULL;
 	spin_lock_bh(&orig_node->neigh_list_lock);
 	/* for all neighbors towards this originator ... */
 	hlist_for_each_entry_safe(neigh_node, node, node_tmp,
 				  &orig_node->neigh_list, list) {
 		last_seen = neigh_node->last_seen;
 		if_incoming = neigh_node->if_incoming;
 		if ((batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT)) ||
 		    (if_incoming->if_status == BATADV_IF_INACTIVE) ||
 		    (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
 		    (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) {
 			if ((if_incoming->if_status == BATADV_IF_INACTIVE) ||
 			    (if_incoming->if_status == BATADV_IF_NOT_IN_USE) ||
 			    (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED))
 				batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 					   "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",
 					   orig_node->orig, neigh_node->addr,
 					   if_incoming->net_dev->name);
 			else
 				batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 					   "neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",
 					   orig_node->orig, neigh_node->addr,
 					   jiffies_to_msecs(last_seen));
 			neigh_purged = true;
 			hlist_del_rcu(&neigh_node->list);
 			batadv_bonding_candidate_del(orig_node, neigh_node);
 			batadv_neigh_node_free_ref(neigh_node);
 		} else {
 			if ((!*best_neigh_node) ||
 			    (neigh_node->tq_avg > (*best_neigh_node)->tq_avg))
 				*best_neigh_node = neigh_node;
 		}
 	}
 	spin_unlock_bh(&orig_node->neigh_list_lock);
 	return neigh_purged;
 }
 static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,
 				   struct batadv_orig_node *orig_node)
 {
 	struct batadv_neigh_node *best_neigh_node;
 	if (batadv_has_timed_out(orig_node->last_seen,
 				 2 * BATADV_PURGE_TIMEOUT)) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Originator timeout: originator %pM, last_seen %u\n",
 			   orig_node->orig,
 			   jiffies_to_msecs(orig_node->last_seen));
 		return true;
 	} else {
 		if (batadv_purge_orig_neighbors(bat_priv, orig_node,
 						&best_neigh_node))
 			batadv_update_route(bat_priv, orig_node,
 					    best_neigh_node);
 	}
 	return false;
 }
 static void _batadv_purge_orig(struct batadv_priv *bat_priv)
 {
 	struct batadv_hashtable *hash = bat_priv->orig_hash;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	spinlock_t *list_lock; /* spinlock to protect write access */
 	struct batadv_orig_node *orig_node;
 	uint32_t i;
 	if (!hash)
 		return;
 	/* for all origins... */
 	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(orig_node, node, node_tmp,
 					  head, hash_entry) {
 			if (batadv_purge_orig_node(bat_priv, orig_node)) {
 				if (orig_node->gw_flags)
 					batadv_gw_node_delete(bat_priv,
 							      orig_node);
 				hlist_del_rcu(node);
 				batadv_orig_node_free_ref(orig_node);
 				continue;
 			}
 			if (batadv_has_timed_out(orig_node->last_frag_packet,
 						 BATADV_FRAG_TIMEOUT))
 				batadv_frag_list_free(&orig_node->frag_list);
 		}
 		spin_unlock_bh(list_lock);
 	}
 	batadv_gw_node_purge(bat_priv);
 	batadv_gw_election(bat_priv);
 }
 static void batadv_purge_orig(struct work_struct *work)
 {
 	struct delayed_work *delayed_work;
 	struct batadv_priv *bat_priv;
 	delayed_work = container_of(work, struct delayed_work, work);
 	bat_priv = container_of(delayed_work, struct batadv_priv, orig_work);
 	_batadv_purge_orig(bat_priv);
 	batadv_start_purge_timer(bat_priv);
 }
 void batadv_purge_orig_ref(struct batadv_priv *bat_priv)
 {
 	_batadv_purge_orig(bat_priv);
 }
 int batadv_orig_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->orig_hash;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	struct batadv_hard_iface *primary_if;
 	struct batadv_orig_node *orig_node;
 	struct batadv_neigh_node *neigh_node, *neigh_node_tmp;
 	int batman_count = 0;
 	int last_seen_secs;
 	int last_seen_msecs;
 	unsigned long last_seen_jiffies;
 	uint32_t i;
 	primary_if = batadv_seq_print_text_primary_if_get(seq);
 	if (!primary_if)
 		goto out;
 	seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",
 		   BATADV_SOURCE_VERSION, primary_if->net_dev->name,
 		   primary_if->net_dev->dev_addr, net_dev->name);
 	seq_printf(seq, "  %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
 		   "Originator", "last-seen", "#", BATADV_TQ_MAX_VALUE,
 		   "Nexthop", "outgoingIF", "Potential nexthops");
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
 			neigh_node = batadv_orig_node_get_router(orig_node);
 			if (!neigh_node)
 				continue;
 			if (neigh_node->tq_avg == 0)
 				goto next;
 			last_seen_jiffies = jiffies - orig_node->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;
 			seq_printf(seq, "%pM %4i.%03is   (%3i) %pM [%10s]:",
 				   orig_node->orig, last_seen_secs,
 				   last_seen_msecs, neigh_node->tq_avg,
 				   neigh_node->addr,
 				   neigh_node->if_incoming->net_dev->name);
 			hlist_for_each_entry_rcu(neigh_node_tmp, node_tmp,
 						 &orig_node->neigh_list, list) {
 				seq_printf(seq, " %pM (%3i)",
 					   neigh_node_tmp->addr,
 					   neigh_node_tmp->tq_avg);
 			}
 			seq_printf(seq, "\n");
 			batman_count++;
 next:
 			batadv_neigh_node_free_ref(neigh_node);
 		}
 		rcu_read_unlock();
 	}
 	if (batman_count == 0)
 		seq_printf(seq, "No batman nodes in range ...\n");
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	return 0;
 }
 static int batadv_orig_node_add_if(struct batadv_orig_node *orig_node,
 				   int max_if_num)
 {
 	void *data_ptr;
 	size_t data_size, old_size;
 	data_size = max_if_num * sizeof(unsigned long) * BATADV_NUM_WORDS;
 	old_size = (max_if_num - 1) * sizeof(unsigned long) * BATADV_NUM_WORDS;
 	data_ptr = kmalloc(data_size, GFP_ATOMIC);
 	if (!data_ptr)
 		return -ENOMEM;
 	memcpy(data_ptr, orig_node->bcast_own, old_size);
 	kfree(orig_node->bcast_own);
 	orig_node->bcast_own = data_ptr;
 	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
 	if (!data_ptr)
 		return -ENOMEM;
 	memcpy(data_ptr, orig_node->bcast_own_sum,
 	       (max_if_num - 1) * sizeof(uint8_t));
 	kfree(orig_node->bcast_own_sum);
 	orig_node->bcast_own_sum = data_ptr;
 	return 0;
 }
 int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
 			    int max_if_num)
 {
 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 	struct batadv_hashtable *hash = bat_priv->orig_hash;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct batadv_orig_node *orig_node;
 	uint32_t i;
 	int ret;
 	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
 	 * if_num
 	 */
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
 			spin_lock_bh(&orig_node->ogm_cnt_lock);
 			ret = batadv_orig_node_add_if(orig_node, max_if_num);
 			spin_unlock_bh(&orig_node->ogm_cnt_lock);
 			if (ret == -ENOMEM)
 				goto err;
 		}
 		rcu_read_unlock();
 	}
 	return 0;
 err:
 	rcu_read_unlock();
 	return -ENOMEM;
 }
 static int batadv_orig_node_del_if(struct batadv_orig_node *orig_node,
 				   int max_if_num, int del_if_num)
 {
 	void *data_ptr = NULL;
 	int chunk_size;
 	/* last interface was removed */
 	if (max_if_num == 0)
 		goto free_bcast_own;
 	chunk_size = sizeof(unsigned long) * BATADV_NUM_WORDS;
 	data_ptr = kmalloc(max_if_num * chunk_size, GFP_ATOMIC);
 	if (!data_ptr)
 		return -ENOMEM;
 	/* copy first part */
 	memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
 	/* copy second part */
 	memcpy((char *)data_ptr + del_if_num * chunk_size,
 	       orig_node->bcast_own + ((del_if_num + 1) * chunk_size),
 	       (max_if_num - del_if_num) * chunk_size);
 free_bcast_own:
 	kfree(orig_node->bcast_own);
 	orig_node->bcast_own = data_ptr;
 	if (max_if_num == 0)
 		goto free_own_sum;
 	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
 	if (!data_ptr)
 		return -ENOMEM;
 	memcpy(data_ptr, orig_node->bcast_own_sum,
 	       del_if_num * sizeof(uint8_t));
 	memcpy((char *)data_ptr + del_if_num * sizeof(uint8_t),
 	       orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),
 	       (max_if_num - del_if_num) * sizeof(uint8_t));
 free_own_sum:
 	kfree(orig_node->bcast_own_sum);
 	orig_node->bcast_own_sum = data_ptr;
 	return 0;
 }
 int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
 			    int max_if_num)
 {
 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 	struct batadv_hashtable *hash = bat_priv->orig_hash;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct batadv_hard_iface *hard_iface_tmp;
 	struct batadv_orig_node *orig_node;
 	uint32_t i;
 	int ret;
 	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
 	 * if_num
 	 */
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
 			spin_lock_bh(&orig_node->ogm_cnt_lock);
 			ret = batadv_orig_node_del_if(orig_node, max_if_num,
 						      hard_iface->if_num);
 			spin_unlock_bh(&orig_node->ogm_cnt_lock);
 			if (ret == -ENOMEM)
 				goto err;
 		}
 		rcu_read_unlock();
 	}
 	/* renumber remaining batman interfaces _inside_ of orig_hash_lock */
 	rcu_read_lock();
 	list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) {
 		if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE)
 			continue;
 		if (hard_iface == hard_iface_tmp)
 			continue;
 		if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)
 			continue;
 		if (hard_iface_tmp->if_num > hard_iface->if_num)
 			hard_iface_tmp->if_num--;
 	}
 	rcu_read_unlock();
 	hard_iface->if_num = -1;
 	return 0;
 err:
 	rcu_read_unlock();
 	return -ENOMEM;
 }

net/batman-adv/routing.c

Diff comments View file @ 7c1fd91

1	/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:	1	/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
2	*	2	*
3	* Marek Lindner, Simon Wunderlich	3	* Marek Lindner, Simon Wunderlich
4	*	4	*
5	* This program is free software; you can redistribute it and/or	5	* This program is free software; you can redistribute it and/or
6	* modify it under the terms of version 2 of the GNU General Public	6	* modify it under the terms of version 2 of the GNU General Public
7	* License as published by the Free Software Foundation.	7	* License as published by the Free Software Foundation.
8	*	8	*
9	* This program is distributed in the hope that it will be useful, but	9	* This program is distributed in the hope that it will be useful, but
10	* WITHOUT ANY WARRANTY; without even the implied warranty of	10	* WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	* General Public License for more details.	12	* General Public License for more details.
13	*	13	*
14	* You should have received a copy of the GNU General Public License	14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software	15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17	* 02110-1301, USA	17	* 02110-1301, USA
18	*/	18	*/
19		19
20	#include "main.h"	20	#include "main.h"
21	#include "routing.h"	21	#include "routing.h"
22	#include "send.h"	22	#include "send.h"
23	#include "soft-interface.h"	23	#include "soft-interface.h"
24	#include "hard-interface.h"	24	#include "hard-interface.h"
25	#include "icmp_socket.h"	25	#include "icmp_socket.h"
26	#include "translation-table.h"	26	#include "translation-table.h"
27	#include "originator.h"	27	#include "originator.h"
28	#include "vis.h"	28	#include "vis.h"
29	#include "unicast.h"	29	#include "unicast.h"
30	#include "bridge_loop_avoidance.h"	30	#include "bridge_loop_avoidance.h"
31	#include "distributed-arp-table.h"	31	#include "distributed-arp-table.h"
32		32
33	static int batadv_route_unicast_packet(struct sk_buff *skb,	33	static int batadv_route_unicast_packet(struct sk_buff *skb,
34	struct batadv_hard_iface *recv_if);	34	struct batadv_hard_iface *recv_if);
35		35
36	void batadv_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)	36	void batadv_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
37	{	37	{
38	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);	38	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
39	struct batadv_hashtable *hash = bat_priv->orig_hash;	39	struct batadv_hashtable *hash = bat_priv->orig_hash;
40	struct hlist_node *node;	40	struct hlist_node *node;
41	struct hlist_head *head;	41	struct hlist_head *head;
42	struct batadv_orig_node *orig_node;	42	struct batadv_orig_node *orig_node;
43	unsigned long *word;	43	unsigned long *word;
44	uint32_t i;	44	uint32_t i;
45	size_t word_index;	45	size_t word_index;
46	uint8_t *w;	46	uint8_t *w;
47		47
48	for (i = 0; i < hash->size; i++) {	48	for (i = 0; i < hash->size; i++) {
49	head = &hash->table[i];	49	head = &hash->table[i];
50		50
51	rcu_read_lock();	51	rcu_read_lock();
52	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {	52	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
53	spin_lock_bh(&orig_node->ogm_cnt_lock);	53	spin_lock_bh(&orig_node->ogm_cnt_lock);
54	word_index = hard_iface->if_num * BATADV_NUM_WORDS;	54	word_index = hard_iface->if_num * BATADV_NUM_WORDS;
55	word = &(orig_node->bcast_own[word_index]);	55	word = &(orig_node->bcast_own[word_index]);
56		56
57	batadv_bit_get_packet(bat_priv, word, 1, 0);	57	batadv_bit_get_packet(bat_priv, word, 1, 0);
58	w = &orig_node->bcast_own_sum[hard_iface->if_num];	58	w = &orig_node->bcast_own_sum[hard_iface->if_num];
59	*w = bitmap_weight(word, BATADV_TQ_LOCAL_WINDOW_SIZE);	59	*w = bitmap_weight(word, BATADV_TQ_LOCAL_WINDOW_SIZE);
60	spin_unlock_bh(&orig_node->ogm_cnt_lock);	60	spin_unlock_bh(&orig_node->ogm_cnt_lock);
61	}	61	}
62	rcu_read_unlock();	62	rcu_read_unlock();
63	}	63	}
64	}	64	}
65		65
66	static void _batadv_update_route(struct batadv_priv *bat_priv,	66	static void _batadv_update_route(struct batadv_priv *bat_priv,
67	struct batadv_orig_node *orig_node,	67	struct batadv_orig_node *orig_node,
68	struct batadv_neigh_node *neigh_node)	68	struct batadv_neigh_node *neigh_node)
69	{	69	{
70	struct batadv_neigh_node *curr_router;	70	struct batadv_neigh_node *curr_router;
71		71
72	curr_router = batadv_orig_node_get_router(orig_node);	72	curr_router = batadv_orig_node_get_router(orig_node);
73		73
74	/* route deleted */	74	/* route deleted */
75	if ((curr_router) && (!neigh_node)) {	75	if ((curr_router) && (!neigh_node)) {
76	batadv_dbg(BATADV_DBG_ROUTES, bat_priv,	76	batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
77	"Deleting route towards: %pM\n", orig_node->orig);	77	"Deleting route towards: %pM\n", orig_node->orig);
78	batadv_tt_global_del_orig(bat_priv, orig_node,	78	batadv_tt_global_del_orig(bat_priv, orig_node,
79	"Deleted route towards originator");	79	"Deleted route towards originator");
80		80
81	/* route added */	81	/* route added */
82	} else if ((!curr_router) && (neigh_node)) {	82	} else if ((!curr_router) && (neigh_node)) {
83		83
84	batadv_dbg(BATADV_DBG_ROUTES, bat_priv,	84	batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
85	"Adding route towards: %pM (via %pM)\n",	85	"Adding route towards: %pM (via %pM)\n",
86	orig_node->orig, neigh_node->addr);	86	orig_node->orig, neigh_node->addr);
87	/* route changed */	87	/* route changed */
88	} else if (neigh_node && curr_router) {	88	} else if (neigh_node && curr_router) {
89	batadv_dbg(BATADV_DBG_ROUTES, bat_priv,	89	batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
90	"Changing route towards: %pM (now via %pM - was via %pM)\n",	90	"Changing route towards: %pM (now via %pM - was via %pM)\n",
91	orig_node->orig, neigh_node->addr,	91	orig_node->orig, neigh_node->addr,
92	curr_router->addr);	92	curr_router->addr);
93	}	93	}
94		94
95	if (curr_router)	95	if (curr_router)
96	batadv_neigh_node_free_ref(curr_router);	96	batadv_neigh_node_free_ref(curr_router);
97		97
98	/* increase refcount of new best neighbor */	98	/* increase refcount of new best neighbor */
99	if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))	99	if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))
100	neigh_node = NULL;	100	neigh_node = NULL;
101		101
102	spin_lock_bh(&orig_node->neigh_list_lock);	102	spin_lock_bh(&orig_node->neigh_list_lock);
103	rcu_assign_pointer(orig_node->router, neigh_node);	103	rcu_assign_pointer(orig_node->router, neigh_node);
104	spin_unlock_bh(&orig_node->neigh_list_lock);	104	spin_unlock_bh(&orig_node->neigh_list_lock);
105		105
106	/* decrease refcount of previous best neighbor */	106	/* decrease refcount of previous best neighbor */
107	if (curr_router)	107	if (curr_router)
108	batadv_neigh_node_free_ref(curr_router);	108	batadv_neigh_node_free_ref(curr_router);
109	}	109	}
110		110
111	void batadv_update_route(struct batadv_priv *bat_priv,	111	void batadv_update_route(struct batadv_priv *bat_priv,
112	struct batadv_orig_node *orig_node,	112	struct batadv_orig_node *orig_node,
113	struct batadv_neigh_node *neigh_node)	113	struct batadv_neigh_node *neigh_node)
114	{	114	{
115	struct batadv_neigh_node *router = NULL;	115	struct batadv_neigh_node *router = NULL;
116		116
117	if (!orig_node)	117	if (!orig_node)
118	goto out;	118	goto out;
119		119
120	router = batadv_orig_node_get_router(orig_node);	120	router = batadv_orig_node_get_router(orig_node);
121		121
122	if (router != neigh_node)	122	if (router != neigh_node)
123	_batadv_update_route(bat_priv, orig_node, neigh_node);	123	_batadv_update_route(bat_priv, orig_node, neigh_node);
124		124
125	out:	125	out:
126	if (router)	126	if (router)
127	batadv_neigh_node_free_ref(router);	127	batadv_neigh_node_free_ref(router);
128	}	128	}
129		129
130	/* caller must hold the neigh_list_lock */	130	/* caller must hold the neigh_list_lock */
131	void batadv_bonding_candidate_del(struct batadv_orig_node *orig_node,	131	void batadv_bonding_candidate_del(struct batadv_orig_node *orig_node,
132	struct batadv_neigh_node *neigh_node)	132	struct batadv_neigh_node *neigh_node)
133	{	133	{
134	/* this neighbor is not part of our candidate list */	134	/* this neighbor is not part of our candidate list */
135	if (list_empty(&neigh_node->bonding_list))	135	if (list_empty(&neigh_node->bonding_list))
136	goto out;	136	goto out;
137		137
138	list_del_rcu(&neigh_node->bonding_list);	138	list_del_rcu(&neigh_node->bonding_list);
139	INIT_LIST_HEAD(&neigh_node->bonding_list);	139	INIT_LIST_HEAD(&neigh_node->bonding_list);
140	batadv_neigh_node_free_ref(neigh_node);	140	batadv_neigh_node_free_ref(neigh_node);
141	atomic_dec(&orig_node->bond_candidates);	141	atomic_dec(&orig_node->bond_candidates);
142		142
143	out:	143	out:
144	return;	144	return;
145	}	145	}
146		146
147	void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node,	147	void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node,
148	struct batadv_neigh_node *neigh_node)	148	struct batadv_neigh_node *neigh_node)
149	{	149	{
150	struct hlist_node *node;	150	struct hlist_node *node;
151	struct batadv_neigh_node tmp_neigh_node, router = NULL;	151	struct batadv_neigh_node tmp_neigh_node, router = NULL;
152	uint8_t interference_candidate = 0;	152	uint8_t interference_candidate = 0;
153		153
154	spin_lock_bh(&orig_node->neigh_list_lock);	154	spin_lock_bh(&orig_node->neigh_list_lock);
155		155
156	/* only consider if it has the same primary address ... */	156	/* only consider if it has the same primary address ... */
157	if (!batadv_compare_eth(orig_node->orig,	157	if (!batadv_compare_eth(orig_node->orig,
158	neigh_node->orig_node->primary_addr))	158	neigh_node->orig_node->primary_addr))
159	goto candidate_del;	159	goto candidate_del;
160		160
161	router = batadv_orig_node_get_router(orig_node);	161	router = batadv_orig_node_get_router(orig_node);
162	if (!router)	162	if (!router)
163	goto candidate_del;	163	goto candidate_del;
164		164
165	/* ... and is good enough to be considered */	165	/* ... and is good enough to be considered */
166	if (neigh_node->tq_avg < router->tq_avg - BATADV_BONDING_TQ_THRESHOLD)	166	if (neigh_node->tq_avg < router->tq_avg - BATADV_BONDING_TQ_THRESHOLD)
167	goto candidate_del;	167	goto candidate_del;
168		168
169	/* check if we have another candidate with the same mac address or	169	/* check if we have another candidate with the same mac address or
170	* interface. If we do, we won't select this candidate because of	170	* interface. If we do, we won't select this candidate because of
171	* possible interference.	171	* possible interference.
172	*/	172	*/
173	hlist_for_each_entry_rcu(tmp_neigh_node, node,	173	hlist_for_each_entry_rcu(tmp_neigh_node, node,
174	&orig_node->neigh_list, list) {	174	&orig_node->neigh_list, list) {
175		175
176	if (tmp_neigh_node == neigh_node)	176	if (tmp_neigh_node == neigh_node)
177	continue;	177	continue;
178		178
179	/* we only care if the other candidate is even	179	/* we only care if the other candidate is even
180	* considered as candidate.	180	* considered as candidate.
181	*/	181	*/
182	if (list_empty(&tmp_neigh_node->bonding_list))	182	if (list_empty(&tmp_neigh_node->bonding_list))
183	continue;	183	continue;
184		184
185	if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) \|\|	185	if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) \|\|
186	(batadv_compare_eth(neigh_node->addr,	186	(batadv_compare_eth(neigh_node->addr,
187	tmp_neigh_node->addr))) {	187	tmp_neigh_node->addr))) {
188	interference_candidate = 1;	188	interference_candidate = 1;
189	break;	189	break;
190	}	190	}
191	}	191	}
192		192
193	/* don't care further if it is an interference candidate */	193	/* don't care further if it is an interference candidate */
194	if (interference_candidate)	194	if (interference_candidate)
195	goto candidate_del;	195	goto candidate_del;
196		196
197	/* this neighbor already is part of our candidate list */	197	/* this neighbor already is part of our candidate list */
198	if (!list_empty(&neigh_node->bonding_list))	198	if (!list_empty(&neigh_node->bonding_list))
199	goto out;	199	goto out;
200		200
201	if (!atomic_inc_not_zero(&neigh_node->refcount))	201	if (!atomic_inc_not_zero(&neigh_node->refcount))
202	goto out;	202	goto out;
203		203
204	list_add_rcu(&neigh_node->bonding_list, &orig_node->bond_list);	204	list_add_rcu(&neigh_node->bonding_list, &orig_node->bond_list);
205	atomic_inc(&orig_node->bond_candidates);	205	atomic_inc(&orig_node->bond_candidates);
206	goto out;	206	goto out;
207		207
208	candidate_del:	208	candidate_del:
209	batadv_bonding_candidate_del(orig_node, neigh_node);	209	batadv_bonding_candidate_del(orig_node, neigh_node);
210		210
211	out:	211	out:
212	spin_unlock_bh(&orig_node->neigh_list_lock);	212	spin_unlock_bh(&orig_node->neigh_list_lock);
213		213
214	if (router)	214	if (router)
215	batadv_neigh_node_free_ref(router);	215	batadv_neigh_node_free_ref(router);
216	}	216	}
217		217
218	/* copy primary address for bonding */	218	/* copy primary address for bonding */
219	void	219	void
220	batadv_bonding_save_primary(const struct batadv_orig_node *orig_node,	220	batadv_bonding_save_primary(const struct batadv_orig_node *orig_node,
221	struct batadv_orig_node *orig_neigh_node,	221	struct batadv_orig_node *orig_neigh_node,
222	const struct batadv_ogm_packet *batman_ogm_packet)	222	const struct batadv_ogm_packet *batman_ogm_packet)
223	{	223	{
224	if (!(batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))	224	if (!(batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))
225	return;	225	return;
226		226
227	memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);	227	memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
228	}	228	}
229		229
230	/* checks whether the host restarted and is in the protection time.	230	/* checks whether the host restarted and is in the protection time.
231	* returns:	231	* returns:
232	* 0 if the packet is to be accepted	232	* 0 if the packet is to be accepted
233	* 1 if the packet is to be ignored.	233	* 1 if the packet is to be ignored.
234	*/	234	*/
235	int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff,	235	int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff,
236	unsigned long *last_reset)	236	unsigned long *last_reset)
237	{	237	{
238	if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE \|\|	238	if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE \|\|
239	seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {	239	seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
240	if (!batadv_has_timed_out(*last_reset,	240	if (!batadv_has_timed_out(*last_reset,
241	BATADV_RESET_PROTECTION_MS))	241	BATADV_RESET_PROTECTION_MS))
242	return 1;	242	return 1;
243		243
244	*last_reset = jiffies;	244	*last_reset = jiffies;
245	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,	245	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
246	"old packet received, start protection\n");	246	"old packet received, start protection\n");
247	}	247	}
248		248
249	return 0;	249	return 0;
250	}	250	}
251		251
252	bool batadv_check_management_packet(struct sk_buff *skb,	252	bool batadv_check_management_packet(struct sk_buff *skb,
253	struct batadv_hard_iface *hard_iface,	253	struct batadv_hard_iface *hard_iface,
254	int header_len)	254	int header_len)
255	{	255	{
256	struct ethhdr *ethhdr;	256	struct ethhdr *ethhdr;
257		257
258	/* drop packet if it has not necessary minimum size */	258	/* drop packet if it has not necessary minimum size */
259	if (unlikely(!pskb_may_pull(skb, header_len)))	259	if (unlikely(!pskb_may_pull(skb, header_len)))
260	return false;	260	return false;
261		261
262	ethhdr = (struct ethhdr *)skb_mac_header(skb);	262	ethhdr = (struct ethhdr *)skb_mac_header(skb);
263		263
264	/* packet with broadcast indication but unicast recipient */	264	/* packet with broadcast indication but unicast recipient */
265	if (!is_broadcast_ether_addr(ethhdr->h_dest))	265	if (!is_broadcast_ether_addr(ethhdr->h_dest))
266	return false;	266	return false;
267		267
268	/* packet with broadcast sender address */	268	/* packet with broadcast sender address */
269	if (is_broadcast_ether_addr(ethhdr->h_source))	269	if (is_broadcast_ether_addr(ethhdr->h_source))
270	return false;	270	return false;
271		271
272	/* create a copy of the skb, if needed, to modify it. */	272	/* create a copy of the skb, if needed, to modify it. */
273	if (skb_cow(skb, 0) < 0)	273	if (skb_cow(skb, 0) < 0)
274	return false;	274	return false;
275		275
276	/* keep skb linear */	276	/* keep skb linear */
277	if (skb_linearize(skb) < 0)	277	if (skb_linearize(skb) < 0)
278	return false;	278	return false;
279		279
280	return true;	280	return true;
281	}	281	}
282		282
283	static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,	283	static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
284	struct sk_buff *skb, size_t icmp_len)	284	struct sk_buff *skb, size_t icmp_len)
285	{	285	{
286	struct batadv_hard_iface *primary_if = NULL;	286	struct batadv_hard_iface *primary_if = NULL;
287	struct batadv_orig_node *orig_node = NULL;	287	struct batadv_orig_node *orig_node = NULL;
288	struct batadv_neigh_node *router = NULL;	288	struct batadv_neigh_node *router = NULL;
289	struct batadv_icmp_packet_rr *icmp_packet;	289	struct batadv_icmp_packet_rr *icmp_packet;
290	int ret = NET_RX_DROP;	290	int ret = NET_RX_DROP;
291		291
292	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;	292	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
293		293
294	/* add data to device queue */	294	/* add data to device queue */
295	if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {	295	if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
296	batadv_socket_receive_packet(icmp_packet, icmp_len);	296	batadv_socket_receive_packet(icmp_packet, icmp_len);
297	goto out;	297	goto out;
298	}	298	}
299		299
300	primary_if = batadv_primary_if_get_selected(bat_priv);	300	primary_if = batadv_primary_if_get_selected(bat_priv);
301	if (!primary_if)	301	if (!primary_if)
302	goto out;	302	goto out;
303		303
304	/* answer echo request (ping) */	304	/* answer echo request (ping) */
305	/* get routing information */	305	/* get routing information */
306	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);	306	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
307	if (!orig_node)	307	if (!orig_node)
308	goto out;	308	goto out;
309		309
310	router = batadv_orig_node_get_router(orig_node);	310	router = batadv_orig_node_get_router(orig_node);
311	if (!router)	311	if (!router)
312	goto out;	312	goto out;
313		313
314	/* create a copy of the skb, if needed, to modify it. */	314	/* create a copy of the skb, if needed, to modify it. */
315	if (skb_cow(skb, ETH_HLEN) < 0)	315	if (skb_cow(skb, ETH_HLEN) < 0)
316	goto out;	316	goto out;
317		317
318	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;	318	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
319		319
320	memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);	320	memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
321	memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);	321	memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
322	icmp_packet->msg_type = BATADV_ECHO_REPLY;	322	icmp_packet->msg_type = BATADV_ECHO_REPLY;
323	icmp_packet->header.ttl = BATADV_TTL;	323	icmp_packet->header.ttl = BATADV_TTL;
324		324
325	batadv_send_skb_packet(skb, router->if_incoming, router->addr);	325	batadv_send_skb_packet(skb, router->if_incoming, router->addr);
326	ret = NET_RX_SUCCESS;	326	ret = NET_RX_SUCCESS;
327		327
328	out:	328	out:
329	if (primary_if)	329	if (primary_if)
330	batadv_hardif_free_ref(primary_if);	330	batadv_hardif_free_ref(primary_if);
331	if (router)	331	if (router)
332	batadv_neigh_node_free_ref(router);	332	batadv_neigh_node_free_ref(router);
333	if (orig_node)	333	if (orig_node)
334	batadv_orig_node_free_ref(orig_node);	334	batadv_orig_node_free_ref(orig_node);
335	return ret;	335	return ret;
336	}	336	}
337		337
338	static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,	338	static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
339	struct sk_buff *skb)	339	struct sk_buff *skb)
340	{	340	{
341	struct batadv_hard_iface *primary_if = NULL;	341	struct batadv_hard_iface *primary_if = NULL;
342	struct batadv_orig_node *orig_node = NULL;	342	struct batadv_orig_node *orig_node = NULL;
343	struct batadv_neigh_node *router = NULL;	343	struct batadv_neigh_node *router = NULL;
344	struct batadv_icmp_packet *icmp_packet;	344	struct batadv_icmp_packet *icmp_packet;
345	int ret = NET_RX_DROP;	345	int ret = NET_RX_DROP;
346		346
347	icmp_packet = (struct batadv_icmp_packet *)skb->data;	347	icmp_packet = (struct batadv_icmp_packet *)skb->data;
348		348
349	/* send TTL exceeded if packet is an echo request (traceroute) */	349	/* send TTL exceeded if packet is an echo request (traceroute) */
350	if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {	350	if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
351	pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",	351	pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
352	icmp_packet->orig, icmp_packet->dst);	352	icmp_packet->orig, icmp_packet->dst);
353	goto out;	353	goto out;
354	}	354	}
355		355
356	primary_if = batadv_primary_if_get_selected(bat_priv);	356	primary_if = batadv_primary_if_get_selected(bat_priv);
357	if (!primary_if)	357	if (!primary_if)
358	goto out;	358	goto out;
359		359
360	/* get routing information */	360	/* get routing information */
361	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);	361	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
362	if (!orig_node)	362	if (!orig_node)
363	goto out;	363	goto out;
364		364
365	router = batadv_orig_node_get_router(orig_node);	365	router = batadv_orig_node_get_router(orig_node);
366	if (!router)	366	if (!router)
367	goto out;	367	goto out;
368		368
369	/* create a copy of the skb, if needed, to modify it. */	369	/* create a copy of the skb, if needed, to modify it. */
370	if (skb_cow(skb, ETH_HLEN) < 0)	370	if (skb_cow(skb, ETH_HLEN) < 0)
371	goto out;	371	goto out;
372		372
373	icmp_packet = (struct batadv_icmp_packet *)skb->data;	373	icmp_packet = (struct batadv_icmp_packet *)skb->data;
374		374
375	memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);	375	memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
376	memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);	376	memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
377	icmp_packet->msg_type = BATADV_TTL_EXCEEDED;	377	icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
378	icmp_packet->header.ttl = BATADV_TTL;	378	icmp_packet->header.ttl = BATADV_TTL;
379		379
380	batadv_send_skb_packet(skb, router->if_incoming, router->addr);	380	batadv_send_skb_packet(skb, router->if_incoming, router->addr);
381	ret = NET_RX_SUCCESS;	381	ret = NET_RX_SUCCESS;
382		382
383	out:	383	out:
384	if (primary_if)	384	if (primary_if)
385	batadv_hardif_free_ref(primary_if);	385	batadv_hardif_free_ref(primary_if);
386	if (router)	386	if (router)
387	batadv_neigh_node_free_ref(router);	387	batadv_neigh_node_free_ref(router);
388	if (orig_node)	388	if (orig_node)
389	batadv_orig_node_free_ref(orig_node);	389	batadv_orig_node_free_ref(orig_node);
390	return ret;	390	return ret;
391	}	391	}
392		392
393		393
394	int batadv_recv_icmp_packet(struct sk_buff *skb,	394	int batadv_recv_icmp_packet(struct sk_buff *skb,
395	struct batadv_hard_iface *recv_if)	395	struct batadv_hard_iface *recv_if)
396	{	396	{
397	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	397	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
398	struct batadv_icmp_packet_rr *icmp_packet;	398	struct batadv_icmp_packet_rr *icmp_packet;
399	struct ethhdr *ethhdr;	399	struct ethhdr *ethhdr;
400	struct batadv_orig_node *orig_node = NULL;	400	struct batadv_orig_node *orig_node = NULL;
401	struct batadv_neigh_node *router = NULL;	401	struct batadv_neigh_node *router = NULL;
402	int hdr_size = sizeof(struct batadv_icmp_packet);	402	int hdr_size = sizeof(struct batadv_icmp_packet);
403	int ret = NET_RX_DROP;	403	int ret = NET_RX_DROP;
404		404
405	/* we truncate all incoming icmp packets if they don't match our size */	405	/* we truncate all incoming icmp packets if they don't match our size */
406	if (skb->len >= sizeof(struct batadv_icmp_packet_rr))	406	if (skb->len >= sizeof(struct batadv_icmp_packet_rr))
407	hdr_size = sizeof(struct batadv_icmp_packet_rr);	407	hdr_size = sizeof(struct batadv_icmp_packet_rr);
408		408
409	/* drop packet if it has not necessary minimum size */	409	/* drop packet if it has not necessary minimum size */
410	if (unlikely(!pskb_may_pull(skb, hdr_size)))	410	if (unlikely(!pskb_may_pull(skb, hdr_size)))
411	goto out;	411	goto out;
412		412
413	ethhdr = (struct ethhdr *)skb_mac_header(skb);	413	ethhdr = (struct ethhdr *)skb_mac_header(skb);
414		414
415	/* packet with unicast indication but broadcast recipient */	415	/* packet with unicast indication but broadcast recipient */
416	if (is_broadcast_ether_addr(ethhdr->h_dest))	416	if (is_broadcast_ether_addr(ethhdr->h_dest))
417	goto out;	417	goto out;
418		418
419	/* packet with broadcast sender address */	419	/* packet with broadcast sender address */
420	if (is_broadcast_ether_addr(ethhdr->h_source))	420	if (is_broadcast_ether_addr(ethhdr->h_source))
421	goto out;	421	goto out;
422		422
423	/* not for me */	423	/* not for me */
424	if (!batadv_is_my_mac(ethhdr->h_dest))	424	if (!batadv_is_my_mac(ethhdr->h_dest))
425	goto out;	425	goto out;
426		426
427	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;	427	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
428		428
429	/* add record route information if not full */	429	/* add record route information if not full */
430	if ((hdr_size == sizeof(struct batadv_icmp_packet_rr)) &&	430	if ((hdr_size == sizeof(struct batadv_icmp_packet_rr)) &&
431	(icmp_packet->rr_cur < BATADV_RR_LEN)) {	431	(icmp_packet->rr_cur < BATADV_RR_LEN)) {
432	memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),	432	memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
433	ethhdr->h_dest, ETH_ALEN);	433	ethhdr->h_dest, ETH_ALEN);
434	icmp_packet->rr_cur++;	434	icmp_packet->rr_cur++;
435	}	435	}
436		436
437	/* packet for me */	437	/* packet for me */
438	if (batadv_is_my_mac(icmp_packet->dst))	438	if (batadv_is_my_mac(icmp_packet->dst))
439	return batadv_recv_my_icmp_packet(bat_priv, skb, hdr_size);	439	return batadv_recv_my_icmp_packet(bat_priv, skb, hdr_size);
440		440
441	/* TTL exceeded */	441	/* TTL exceeded */
442	if (icmp_packet->header.ttl < 2)	442	if (icmp_packet->header.ttl < 2)
443	return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);	443	return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
444		444
445	/* get routing information */	445	/* get routing information */
446	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->dst);	446	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->dst);
447	if (!orig_node)	447	if (!orig_node)
448	goto out;	448	goto out;
449		449
450	router = batadv_orig_node_get_router(orig_node);	450	router = batadv_orig_node_get_router(orig_node);
451	if (!router)	451	if (!router)
452	goto out;	452	goto out;
453		453
454	/* create a copy of the skb, if needed, to modify it. */	454	/* create a copy of the skb, if needed, to modify it. */
455	if (skb_cow(skb, ETH_HLEN) < 0)	455	if (skb_cow(skb, ETH_HLEN) < 0)
456	goto out;	456	goto out;
457		457
458	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;	458	icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
459		459
460	/* decrement ttl */	460	/* decrement ttl */
461	icmp_packet->header.ttl--;	461	icmp_packet->header.ttl--;
462		462
463	/* route it */	463	/* route it */
464	batadv_send_skb_packet(skb, router->if_incoming, router->addr);	464	batadv_send_skb_packet(skb, router->if_incoming, router->addr);
465	ret = NET_RX_SUCCESS;	465	ret = NET_RX_SUCCESS;
466		466
467	out:	467	out:
468	if (router)	468	if (router)
469	batadv_neigh_node_free_ref(router);	469	batadv_neigh_node_free_ref(router);
470	if (orig_node)	470	if (orig_node)
471	batadv_orig_node_free_ref(orig_node);	471	batadv_orig_node_free_ref(orig_node);
472	return ret;	472	return ret;
473	}	473	}
474		474
475	/* In the bonding case, send the packets in a round	475	/* In the bonding case, send the packets in a round
476	* robin fashion over the remaining interfaces.	476	* robin fashion over the remaining interfaces.
477	*	477	*
478	* This method rotates the bonding list and increases the	478	* This method rotates the bonding list and increases the
479	* returned router's refcount.	479	* returned router's refcount.
480	*/	480	*/
481	static struct batadv_neigh_node *	481	static struct batadv_neigh_node *
482	batadv_find_bond_router(struct batadv_orig_node *primary_orig,	482	batadv_find_bond_router(struct batadv_orig_node *primary_orig,
483	const struct batadv_hard_iface *recv_if)	483	const struct batadv_hard_iface *recv_if)
484	{	484	{
485	struct batadv_neigh_node *tmp_neigh_node;	485	struct batadv_neigh_node *tmp_neigh_node;
486	struct batadv_neigh_node router = NULL, first_candidate = NULL;	486	struct batadv_neigh_node router = NULL, first_candidate = NULL;
487		487
488	rcu_read_lock();	488	rcu_read_lock();
489	list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,	489	list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,
490	bonding_list) {	490	bonding_list) {
491	if (!first_candidate)	491	if (!first_candidate)
492	first_candidate = tmp_neigh_node;	492	first_candidate = tmp_neigh_node;
493		493
494	/* recv_if == NULL on the first node. */	494	/* recv_if == NULL on the first node. */
495	if (tmp_neigh_node->if_incoming == recv_if)	495	if (tmp_neigh_node->if_incoming == recv_if)
496	continue;	496	continue;
497		497
498	if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))	498	if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
499	continue;	499	continue;
500		500
501	router = tmp_neigh_node;	501	router = tmp_neigh_node;
502	break;	502	break;
503	}	503	}
504		504
505	/* use the first candidate if nothing was found. */	505	/* use the first candidate if nothing was found. */
506	if (!router && first_candidate &&	506	if (!router && first_candidate &&
507	atomic_inc_not_zero(&first_candidate->refcount))	507	atomic_inc_not_zero(&first_candidate->refcount))
508	router = first_candidate;	508	router = first_candidate;
509		509
510	if (!router)	510	if (!router)
511	goto out;	511	goto out;
512		512
513	/* selected should point to the next element	513	/* selected should point to the next element
514	* after the current router	514	* after the current router
515	*/	515	*/
516	spin_lock_bh(&primary_orig->neigh_list_lock);	516	spin_lock_bh(&primary_orig->neigh_list_lock);
517	/* this is a list_move(), which unfortunately	517	/* this is a list_move(), which unfortunately
518	* does not exist as rcu version	518	* does not exist as rcu version
519	*/	519	*/
520	list_del_rcu(&primary_orig->bond_list);	520	list_del_rcu(&primary_orig->bond_list);
521	list_add_rcu(&primary_orig->bond_list,	521	list_add_rcu(&primary_orig->bond_list,
522	&router->bonding_list);	522	&router->bonding_list);
523	spin_unlock_bh(&primary_orig->neigh_list_lock);	523	spin_unlock_bh(&primary_orig->neigh_list_lock);
524		524
525	out:	525	out:
526	rcu_read_unlock();	526	rcu_read_unlock();
527	return router;	527	return router;
528	}	528	}
529		529
530	/* Interface Alternating: Use the best of the	530	/* Interface Alternating: Use the best of the
531	* remaining candidates which are not using	531	* remaining candidates which are not using
532	* this interface.	532	* this interface.
533	*	533	*
534	* Increases the returned router's refcount	534	* Increases the returned router's refcount
535	*/	535	*/
536	static struct batadv_neigh_node *	536	static struct batadv_neigh_node *
537	batadv_find_ifalter_router(struct batadv_orig_node *primary_orig,	537	batadv_find_ifalter_router(struct batadv_orig_node *primary_orig,
538	const struct batadv_hard_iface *recv_if)	538	const struct batadv_hard_iface *recv_if)
539	{	539	{
540	struct batadv_neigh_node *tmp_neigh_node;	540	struct batadv_neigh_node *tmp_neigh_node;
541	struct batadv_neigh_node router = NULL, first_candidate = NULL;	541	struct batadv_neigh_node router = NULL, first_candidate = NULL;
542		542
543	rcu_read_lock();	543	rcu_read_lock();
544	list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,	544	list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,
545	bonding_list) {	545	bonding_list) {
546	if (!first_candidate)	546	if (!first_candidate)
547	first_candidate = tmp_neigh_node;	547	first_candidate = tmp_neigh_node;
548		548
549	/* recv_if == NULL on the first node. */	549	/* recv_if == NULL on the first node. */
550	if (tmp_neigh_node->if_incoming == recv_if)	550	if (tmp_neigh_node->if_incoming == recv_if)
551	continue;	551	continue;
552		552
553	if (router && tmp_neigh_node->tq_avg <= router->tq_avg)	553	if (router && tmp_neigh_node->tq_avg <= router->tq_avg)
554	continue;	554	continue;
555		555
556	if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))	556	if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
557	continue;	557	continue;
558		558
559	/* decrement refcount of previously selected router */	559	/* decrement refcount of previously selected router */
560	if (router)	560	if (router)
561	batadv_neigh_node_free_ref(router);	561	batadv_neigh_node_free_ref(router);
562		562
563	/* we found a better router (or at least one valid router) */	563	/* we found a better router (or at least one valid router) */
564	router = tmp_neigh_node;	564	router = tmp_neigh_node;
565	}	565	}
566		566
567	/* use the first candidate if nothing was found. */	567	/* use the first candidate if nothing was found. */
568	if (!router && first_candidate &&	568	if (!router && first_candidate &&
569	atomic_inc_not_zero(&first_candidate->refcount))	569	atomic_inc_not_zero(&first_candidate->refcount))
570	router = first_candidate;	570	router = first_candidate;
571		571
572	rcu_read_unlock();	572	rcu_read_unlock();
573	return router;	573	return router;
574	}	574	}
575		575
576	static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)	576	static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
577	{	577	{
578	struct ethhdr *ethhdr;	578	struct ethhdr *ethhdr;
579		579
580	/* drop packet if it has not necessary minimum size */	580	/* drop packet if it has not necessary minimum size */
581	if (unlikely(!pskb_may_pull(skb, hdr_size)))	581	if (unlikely(!pskb_may_pull(skb, hdr_size)))
582	return -1;	582	return -1;
583		583
584	ethhdr = (struct ethhdr *)skb_mac_header(skb);	584	ethhdr = (struct ethhdr *)skb_mac_header(skb);
585		585
586	/* packet with unicast indication but broadcast recipient */	586	/* packet with unicast indication but broadcast recipient */
587	if (is_broadcast_ether_addr(ethhdr->h_dest))	587	if (is_broadcast_ether_addr(ethhdr->h_dest))
588	return -1;	588	return -1;
589		589
590	/* packet with broadcast sender address */	590	/* packet with broadcast sender address */
591	if (is_broadcast_ether_addr(ethhdr->h_source))	591	if (is_broadcast_ether_addr(ethhdr->h_source))
592	return -1;	592	return -1;
593		593
594	/* not for me */	594	/* not for me */
595	if (!batadv_is_my_mac(ethhdr->h_dest))	595	if (!batadv_is_my_mac(ethhdr->h_dest))
596	return -1;	596	return -1;
597		597
598	return 0;	598	return 0;
599	}	599	}
600		600
601	int batadv_recv_tt_query(struct sk_buff skb, struct batadv_hard_iface recv_if)	601	int batadv_recv_tt_query(struct sk_buff skb, struct batadv_hard_iface recv_if)
602	{	602	{
603	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	603	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
604	struct batadv_tt_query_packet *tt_query;	604	struct batadv_tt_query_packet *tt_query;
605	uint16_t tt_size;	605	uint16_t tt_size;
606	int hdr_size = sizeof(*tt_query);	606	int hdr_size = sizeof(*tt_query);
607	char tt_flag;	607	char tt_flag;
608	size_t packet_size;	608	size_t packet_size;
609		609
610	if (batadv_check_unicast_packet(skb, hdr_size) < 0)	610	if (batadv_check_unicast_packet(skb, hdr_size) < 0)
611	return NET_RX_DROP;	611	return NET_RX_DROP;
612		612
613	/* I could need to modify it */	613	/* I could need to modify it */
614	if (skb_cow(skb, sizeof(struct batadv_tt_query_packet)) < 0)	614	if (skb_cow(skb, sizeof(struct batadv_tt_query_packet)) < 0)
615	goto out;	615	goto out;
616		616
617	tt_query = (struct batadv_tt_query_packet *)skb->data;	617	tt_query = (struct batadv_tt_query_packet *)skb->data;
618		618
619	switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) {	619	switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) {
620	case BATADV_TT_REQUEST:	620	case BATADV_TT_REQUEST:
621	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);	621	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
622		622
623	/* If we cannot provide an answer the tt_request is	623	/* If we cannot provide an answer the tt_request is
624	* forwarded	624	* forwarded
625	*/	625	*/
626	if (!batadv_send_tt_response(bat_priv, tt_query)) {	626	if (!batadv_send_tt_response(bat_priv, tt_query)) {
627	if (tt_query->flags & BATADV_TT_FULL_TABLE)	627	if (tt_query->flags & BATADV_TT_FULL_TABLE)
628	tt_flag = 'F';	628	tt_flag = 'F';
629	else	629	else
630	tt_flag = '.';	630	tt_flag = '.';
631		631
632	batadv_dbg(BATADV_DBG_TT, bat_priv,	632	batadv_dbg(BATADV_DBG_TT, bat_priv,
633	"Routing TT_REQUEST to %pM [%c]\n",	633	"Routing TT_REQUEST to %pM [%c]\n",
634	tt_query->dst,	634	tt_query->dst,
635	tt_flag);	635	tt_flag);
636	return batadv_route_unicast_packet(skb, recv_if);	636	return batadv_route_unicast_packet(skb, recv_if);
637	}	637	}
638	break;	638	break;
639	case BATADV_TT_RESPONSE:	639	case BATADV_TT_RESPONSE:
640	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);	640	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
641		641
642	if (batadv_is_my_mac(tt_query->dst)) {	642	if (batadv_is_my_mac(tt_query->dst)) {
643	/* packet needs to be linearized to access the TT	643	/* packet needs to be linearized to access the TT
644	* changes	644	* changes
645	*/	645	*/
646	if (skb_linearize(skb) < 0)	646	if (skb_linearize(skb) < 0)
647	goto out;	647	goto out;
648	/* skb_linearize() possibly changed skb->data */	648	/* skb_linearize() possibly changed skb->data */
649	tt_query = (struct batadv_tt_query_packet *)skb->data;	649	tt_query = (struct batadv_tt_query_packet *)skb->data;
650		650
651	tt_size = batadv_tt_len(ntohs(tt_query->tt_data));	651	tt_size = batadv_tt_len(ntohs(tt_query->tt_data));
652		652
653	/* Ensure we have all the claimed data */	653	/* Ensure we have all the claimed data */
654	packet_size = sizeof(struct batadv_tt_query_packet);	654	packet_size = sizeof(struct batadv_tt_query_packet);
655	packet_size += tt_size;	655	packet_size += tt_size;
656	if (unlikely(skb_headlen(skb) < packet_size))	656	if (unlikely(skb_headlen(skb) < packet_size))
657	goto out;	657	goto out;
658		658
659	batadv_handle_tt_response(bat_priv, tt_query);	659	batadv_handle_tt_response(bat_priv, tt_query);
660	} else {	660	} else {
661	if (tt_query->flags & BATADV_TT_FULL_TABLE)	661	if (tt_query->flags & BATADV_TT_FULL_TABLE)
662	tt_flag = 'F';	662	tt_flag = 'F';
663	else	663	else
664	tt_flag = '.';	664	tt_flag = '.';
665	batadv_dbg(BATADV_DBG_TT, bat_priv,	665	batadv_dbg(BATADV_DBG_TT, bat_priv,
666	"Routing TT_RESPONSE to %pM [%c]\n",	666	"Routing TT_RESPONSE to %pM [%c]\n",
667	tt_query->dst,	667	tt_query->dst,
668	tt_flag);	668	tt_flag);
669	return batadv_route_unicast_packet(skb, recv_if);	669	return batadv_route_unicast_packet(skb, recv_if);
670	}	670	}
671	break;	671	break;
672	}	672	}
673		673
674	out:	674	out:
675	/* returning NET_RX_DROP will make the caller function kfree the skb */	675	/* returning NET_RX_DROP will make the caller function kfree the skb */
676	return NET_RX_DROP;	676	return NET_RX_DROP;
677	}	677	}
678		678
679	int batadv_recv_roam_adv(struct sk_buff skb, struct batadv_hard_iface recv_if)	679	int batadv_recv_roam_adv(struct sk_buff skb, struct batadv_hard_iface recv_if)
680	{	680	{
681	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	681	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
682	struct batadv_roam_adv_packet *roam_adv_packet;	682	struct batadv_roam_adv_packet *roam_adv_packet;
683	struct batadv_orig_node *orig_node;	683	struct batadv_orig_node *orig_node;
684		684
685	if (batadv_check_unicast_packet(skb, sizeof(*roam_adv_packet)) < 0)	685	if (batadv_check_unicast_packet(skb, sizeof(*roam_adv_packet)) < 0)
686	goto out;	686	goto out;
687		687
688	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);	688	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
689		689
690	roam_adv_packet = (struct batadv_roam_adv_packet *)skb->data;	690	roam_adv_packet = (struct batadv_roam_adv_packet *)skb->data;
691		691
692	if (!batadv_is_my_mac(roam_adv_packet->dst))	692	if (!batadv_is_my_mac(roam_adv_packet->dst))
693	return batadv_route_unicast_packet(skb, recv_if);	693	return batadv_route_unicast_packet(skb, recv_if);
694		694
695	/* check if it is a backbone gateway. we don't accept	695	/* check if it is a backbone gateway. we don't accept
696	* roaming advertisement from it, as it has the same	696	* roaming advertisement from it, as it has the same
697	* entries as we have.	697	* entries as we have.
698	*/	698	*/
699	if (batadv_bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src))	699	if (batadv_bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src))
700	goto out;	700	goto out;
701		701
702	orig_node = batadv_orig_hash_find(bat_priv, roam_adv_packet->src);	702	orig_node = batadv_orig_hash_find(bat_priv, roam_adv_packet->src);
703	if (!orig_node)	703	if (!orig_node)
704	goto out;	704	goto out;
705		705
706	batadv_dbg(BATADV_DBG_TT, bat_priv,	706	batadv_dbg(BATADV_DBG_TT, bat_priv,
707	"Received ROAMING_ADV from %pM (client %pM)\n",	707	"Received ROAMING_ADV from %pM (client %pM)\n",
708	roam_adv_packet->src, roam_adv_packet->client);	708	roam_adv_packet->src, roam_adv_packet->client);
709		709
710	batadv_tt_global_add(bat_priv, orig_node, roam_adv_packet->client,	710	batadv_tt_global_add(bat_priv, orig_node, roam_adv_packet->client,
711	BATADV_TT_CLIENT_ROAM,	711	BATADV_TT_CLIENT_ROAM,
712	atomic_read(&orig_node->last_ttvn) + 1);	712	atomic_read(&orig_node->last_ttvn) + 1);
713		713
714	/* Roaming phase starts: I have new information but the ttvn has not
715	* been incremented yet. This flag will make me check all the incoming
716	* packets for the correct destination.
717	*/
718	bat_priv->tt.poss_change = true;
719
720	batadv_orig_node_free_ref(orig_node);	714	batadv_orig_node_free_ref(orig_node);
721	out:	715	out:
722	/* returning NET_RX_DROP will make the caller function kfree the skb */	716	/* returning NET_RX_DROP will make the caller function kfree the skb */
723	return NET_RX_DROP;	717	return NET_RX_DROP;
724	}	718	}
725		719
726	/* find a suitable router for this originator, and use	720	/* find a suitable router for this originator, and use
727	* bonding if possible. increases the found neighbors	721	* bonding if possible. increases the found neighbors
728	* refcount.	722	* refcount.
729	*/	723	*/
730	struct batadv_neigh_node *	724	struct batadv_neigh_node *
731	batadv_find_router(struct batadv_priv *bat_priv,	725	batadv_find_router(struct batadv_priv *bat_priv,
732	struct batadv_orig_node *orig_node,	726	struct batadv_orig_node *orig_node,
733	const struct batadv_hard_iface *recv_if)	727	const struct batadv_hard_iface *recv_if)
734	{	728	{
735	struct batadv_orig_node *primary_orig_node;	729	struct batadv_orig_node *primary_orig_node;
736	struct batadv_orig_node *router_orig;	730	struct batadv_orig_node *router_orig;
737	struct batadv_neigh_node *router;	731	struct batadv_neigh_node *router;
738	static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};	732	static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
739	int bonding_enabled;	733	int bonding_enabled;
740	uint8_t *primary_addr;	734	uint8_t *primary_addr;
741		735
742	if (!orig_node)	736	if (!orig_node)
743	return NULL;	737	return NULL;
744		738
745	router = batadv_orig_node_get_router(orig_node);	739	router = batadv_orig_node_get_router(orig_node);
746	if (!router)	740	if (!router)
747	goto err;	741	goto err;
748		742
749	/* without bonding, the first node should	743	/* without bonding, the first node should
750	* always choose the default router.	744	* always choose the default router.
751	*/	745	*/
752	bonding_enabled = atomic_read(&bat_priv->bonding);	746	bonding_enabled = atomic_read(&bat_priv->bonding);
753		747
754	rcu_read_lock();	748	rcu_read_lock();
755	/* select default router to output */	749	/* select default router to output */
756	router_orig = router->orig_node;	750	router_orig = router->orig_node;
757	if (!router_orig)	751	if (!router_orig)
758	goto err_unlock;	752	goto err_unlock;
759		753
760	if ((!recv_if) && (!bonding_enabled))	754	if ((!recv_if) && (!bonding_enabled))
761	goto return_router;	755	goto return_router;
762		756
763	primary_addr = router_orig->primary_addr;	757	primary_addr = router_orig->primary_addr;
764		758
765	/* if we have something in the primary_addr, we can search	759	/* if we have something in the primary_addr, we can search
766	* for a potential bonding candidate.	760	* for a potential bonding candidate.
767	*/	761	*/
768	if (batadv_compare_eth(primary_addr, zero_mac))	762	if (batadv_compare_eth(primary_addr, zero_mac))
769	goto return_router;	763	goto return_router;
770		764
771	/* find the orig_node which has the primary interface. might	765	/* find the orig_node which has the primary interface. might
772	* even be the same as our router_orig in many cases	766	* even be the same as our router_orig in many cases
773	*/	767	*/
774	if (batadv_compare_eth(primary_addr, router_orig->orig)) {	768	if (batadv_compare_eth(primary_addr, router_orig->orig)) {
775	primary_orig_node = router_orig;	769	primary_orig_node = router_orig;
776	} else {	770	} else {
777	primary_orig_node = batadv_orig_hash_find(bat_priv,	771	primary_orig_node = batadv_orig_hash_find(bat_priv,
778	primary_addr);	772	primary_addr);
779	if (!primary_orig_node)	773	if (!primary_orig_node)
780	goto return_router;	774	goto return_router;
781		775
782	batadv_orig_node_free_ref(primary_orig_node);	776	batadv_orig_node_free_ref(primary_orig_node);
783	}	777	}
784		778
785	/* with less than 2 candidates, we can't do any	779	/* with less than 2 candidates, we can't do any
786	* bonding and prefer the original router.	780	* bonding and prefer the original router.
787	*/	781	*/
788	if (atomic_read(&primary_orig_node->bond_candidates) < 2)	782	if (atomic_read(&primary_orig_node->bond_candidates) < 2)
789	goto return_router;	783	goto return_router;
790		784
791	/* all nodes between should choose a candidate which	785	/* all nodes between should choose a candidate which
792	* is is not on the interface where the packet came	786	* is is not on the interface where the packet came
793	* in.	787	* in.
794	*/	788	*/
795	batadv_neigh_node_free_ref(router);	789	batadv_neigh_node_free_ref(router);
796		790
797	if (bonding_enabled)	791	if (bonding_enabled)
798	router = batadv_find_bond_router(primary_orig_node, recv_if);	792	router = batadv_find_bond_router(primary_orig_node, recv_if);
799	else	793	else
800	router = batadv_find_ifalter_router(primary_orig_node, recv_if);	794	router = batadv_find_ifalter_router(primary_orig_node, recv_if);
801		795
802	return_router:	796	return_router:
803	if (router && router->if_incoming->if_status != BATADV_IF_ACTIVE)	797	if (router && router->if_incoming->if_status != BATADV_IF_ACTIVE)
804	goto err_unlock;	798	goto err_unlock;
805		799
806	rcu_read_unlock();	800	rcu_read_unlock();
807	return router;	801	return router;
808	err_unlock:	802	err_unlock:
809	rcu_read_unlock();	803	rcu_read_unlock();
810	err:	804	err:
811	if (router)	805	if (router)
812	batadv_neigh_node_free_ref(router);	806	batadv_neigh_node_free_ref(router);
813	return NULL;	807	return NULL;
814	}	808	}
815		809
816	static int batadv_route_unicast_packet(struct sk_buff *skb,	810	static int batadv_route_unicast_packet(struct sk_buff *skb,
817	struct batadv_hard_iface *recv_if)	811	struct batadv_hard_iface *recv_if)
818	{	812	{
819	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	813	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
820	struct batadv_orig_node *orig_node = NULL;	814	struct batadv_orig_node *orig_node = NULL;
821	struct batadv_neigh_node *neigh_node = NULL;	815	struct batadv_neigh_node *neigh_node = NULL;
822	struct batadv_unicast_packet *unicast_packet;	816	struct batadv_unicast_packet *unicast_packet;
823	struct ethhdr ethhdr = (struct ethhdr )skb_mac_header(skb);	817	struct ethhdr ethhdr = (struct ethhdr )skb_mac_header(skb);
824	int ret = NET_RX_DROP;	818	int ret = NET_RX_DROP;
825	struct sk_buff *new_skb;	819	struct sk_buff *new_skb;
826		820
827	unicast_packet = (struct batadv_unicast_packet *)skb->data;	821	unicast_packet = (struct batadv_unicast_packet *)skb->data;
828		822
829	/* TTL exceeded */	823	/* TTL exceeded */
830	if (unicast_packet->header.ttl < 2) {	824	if (unicast_packet->header.ttl < 2) {
831	pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",	825	pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
832	ethhdr->h_source, unicast_packet->dest);	826	ethhdr->h_source, unicast_packet->dest);
833	goto out;	827	goto out;
834	}	828	}
835		829
836	/* get routing information */	830	/* get routing information */
837	orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);	831	orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
838		832
839	if (!orig_node)	833	if (!orig_node)
840	goto out;	834	goto out;
841		835
842	/* find_router() increases neigh_nodes refcount if found. */	836	/* find_router() increases neigh_nodes refcount if found. */
843	neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);	837	neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
844		838
845	if (!neigh_node)	839	if (!neigh_node)
846	goto out;	840	goto out;
847		841
848	/* create a copy of the skb, if needed, to modify it. */	842	/* create a copy of the skb, if needed, to modify it. */
849	if (skb_cow(skb, ETH_HLEN) < 0)	843	if (skb_cow(skb, ETH_HLEN) < 0)
850	goto out;	844	goto out;
851		845
852	unicast_packet = (struct batadv_unicast_packet *)skb->data;	846	unicast_packet = (struct batadv_unicast_packet *)skb->data;
853		847
854	if (unicast_packet->header.packet_type == BATADV_UNICAST &&	848	if (unicast_packet->header.packet_type == BATADV_UNICAST &&
855	atomic_read(&bat_priv->fragmentation) &&	849	atomic_read(&bat_priv->fragmentation) &&
856	skb->len > neigh_node->if_incoming->net_dev->mtu) {	850	skb->len > neigh_node->if_incoming->net_dev->mtu) {
857	ret = batadv_frag_send_skb(skb, bat_priv,	851	ret = batadv_frag_send_skb(skb, bat_priv,
858	neigh_node->if_incoming,	852	neigh_node->if_incoming,
859	neigh_node->addr);	853	neigh_node->addr);
860	goto out;	854	goto out;
861	}	855	}
862		856
863	if (unicast_packet->header.packet_type == BATADV_UNICAST_FRAG &&	857	if (unicast_packet->header.packet_type == BATADV_UNICAST_FRAG &&
864	batadv_frag_can_reassemble(skb,	858	batadv_frag_can_reassemble(skb,
865	neigh_node->if_incoming->net_dev->mtu)) {	859	neigh_node->if_incoming->net_dev->mtu)) {
866		860
867	ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);	861	ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
868		862
869	if (ret == NET_RX_DROP)	863	if (ret == NET_RX_DROP)
870	goto out;	864	goto out;
871		865
872	/* packet was buffered for late merge */	866	/* packet was buffered for late merge */
873	if (!new_skb) {	867	if (!new_skb) {
874	ret = NET_RX_SUCCESS;	868	ret = NET_RX_SUCCESS;
875	goto out;	869	goto out;
876	}	870	}
877		871
878	skb = new_skb;	872	skb = new_skb;
879	unicast_packet = (struct batadv_unicast_packet *)skb->data;	873	unicast_packet = (struct batadv_unicast_packet *)skb->data;
880	}	874	}
881		875
882	/* decrement ttl */	876	/* decrement ttl */
883	unicast_packet->header.ttl--;	877	unicast_packet->header.ttl--;
884		878
885	/* Update stats counter */	879	/* Update stats counter */
886	batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);	880	batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
887	batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,	881	batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
888	skb->len + ETH_HLEN);	882	skb->len + ETH_HLEN);
889		883
890	/* route it */	884	/* route it */
891	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);	885	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
892	ret = NET_RX_SUCCESS;	886	ret = NET_RX_SUCCESS;
893		887
894	out:	888	out:
895	if (neigh_node)	889	if (neigh_node)
896	batadv_neigh_node_free_ref(neigh_node);	890	batadv_neigh_node_free_ref(neigh_node);
897	if (orig_node)	891	if (orig_node)
898	batadv_orig_node_free_ref(orig_node);	892	batadv_orig_node_free_ref(orig_node);
899	return ret;	893	return ret;
900	}	894	}
901		895
		896	/**
		897	* batadv_reroute_unicast_packet - update the unicast header for re-routing
		898	* @bat_priv: the bat priv with all the soft interface information
		899	* @unicast_packet: the unicast header to be updated
		900	* @dst_addr: the payload destination
		901	*
		902	* Search the translation table for dst_addr and update the unicast header with
		903	* the new corresponding information (originator address where the destination
		904	* client currently is and its known TTVN)
		905	*
		906	* Returns true if the packet header has been updated, false otherwise
		907	*/
		908	static bool
		909	batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
		910	struct batadv_unicast_packet *unicast_packet,
		911	uint8_t *dst_addr)
		912	{
		913	struct batadv_orig_node *orig_node = NULL;
		914	struct batadv_hard_iface *primary_if = NULL;
		915	bool ret = false;
		916	uint8_t *orig_addr, orig_ttvn;
		917
		918	if (batadv_is_my_client(bat_priv, dst_addr)) {
		919	primary_if = batadv_primary_if_get_selected(bat_priv);
		920	if (!primary_if)
		921	goto out;
		922	orig_addr = primary_if->net_dev->dev_addr;
		923	orig_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
		924	} else {
		925	orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr);
		926	if (!orig_node)
		927	goto out;
		928
		929	if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
		930	goto out;
		931
		932	orig_addr = orig_node->orig;
		933	orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
		934	}
		935
		936	/* update the packet header */
		937	memcpy(unicast_packet->dest, orig_addr, ETH_ALEN);
		938	unicast_packet->ttvn = orig_ttvn;
		939
		940	ret = true;
		941	out:
		942	if (primary_if)
		943	batadv_hardif_free_ref(primary_if);
		944	if (orig_node)
		945	batadv_orig_node_free_ref(orig_node);
		946
		947	return ret;
		948	}
		949
902	static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,	950	static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
903	struct sk_buff *skb) {	951	struct sk_buff *skb) {
904	uint8_t curr_ttvn;	952	uint8_t curr_ttvn, old_ttvn;
905	struct batadv_orig_node *orig_node;	953	struct batadv_orig_node *orig_node;
906	struct ethhdr *ethhdr;	954	struct ethhdr *ethhdr;
907	struct batadv_hard_iface *primary_if;	955	struct batadv_hard_iface *primary_if;
908	struct batadv_unicast_packet *unicast_packet;	956	struct batadv_unicast_packet *unicast_packet;
909	bool tt_poss_change;
910	int is_old_ttvn;	957	int is_old_ttvn;
911		958
912	/* check if there is enough data before accessing it */	959	/* check if there is enough data before accessing it */
913	if (pskb_may_pull(skb, sizeof(*unicast_packet) + ETH_HLEN) < 0)	960	if (pskb_may_pull(skb, sizeof(*unicast_packet) + ETH_HLEN) < 0)
914	return 0;	961	return 0;
915		962
916	/* create a copy of the skb (in case of for re-routing) to modify it. */	963	/* create a copy of the skb (in case of for re-routing) to modify it. */
917	if (skb_cow(skb, sizeof(*unicast_packet)) < 0)	964	if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
918	return 0;	965	return 0;
919		966
920	unicast_packet = (struct batadv_unicast_packet *)skb->data;	967	unicast_packet = (struct batadv_unicast_packet *)skb->data;
		968	ethhdr = (struct ethhdr )(skb->data + sizeof(unicast_packet));
921		969
922	if (batadv_is_my_mac(unicast_packet->dest)) {	970	/* check if the destination client was served by this node and it is now
923	tt_poss_change = bat_priv->tt.poss_change;	971	* roaming. In this case, it means that the node has got a ROAM_ADV
924	curr_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);	972	* message and that it knows the new destination in the mesh to re-route
925	} else {	973	* the packet to
		974	*/
		975	if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest)) {
		976	if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
		977	ethhdr->h_dest))
		978	net_ratelimited_function(batadv_dbg, BATADV_DBG_TT,
		979	bat_priv,
		980	"Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
		981	unicast_packet->dest,
		982	ethhdr->h_dest);
		983	/* at this point the mesh destination should have been
		984	* substituted with the originator address found in the global
		985	* table. If not, let the packet go untouched anyway because
		986	* there is nothing the node can do
		987	*/
		988	return 1;
		989	}
		990
		991	/* retrieve the TTVN known by this node for the packet destination. This
		992	* value is used later to check if the node which sent (or re-routed
		993	* last time) the packet had an updated information or not
		994	*/
		995	curr_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
		996	if (!batadv_is_my_mac(unicast_packet->dest)) {
926	orig_node = batadv_orig_hash_find(bat_priv,	997	orig_node = batadv_orig_hash_find(bat_priv,
927	unicast_packet->dest);	998	unicast_packet->dest);
928		999	/* if it is not possible to find the orig_node representing the
		1000	* destination, the packet can immediately be dropped as it will
		1001	* not be possible to deliver it
		1002	*/
929	if (!orig_node)	1003	if (!orig_node)
930	return 0;	1004	return 0;
931		1005
932	curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);	1006	curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
933	tt_poss_change = orig_node->tt_poss_change;
934	batadv_orig_node_free_ref(orig_node);	1007	batadv_orig_node_free_ref(orig_node);
935	}	1008	}
936		1009
937	/* Check whether I have to reroute the packet */	1010	/* check if the TTVN contained in the packet is fresher than what the
		1011	* node knows
		1012	*/
938	is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);	1013	is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
939	if (is_old_ttvn \|\| tt_poss_change) {	1014	if (!is_old_ttvn)
940	/* check if there is enough data before accessing it */	1015	return 1;
941	if (pskb_may_pull(skb, sizeof(struct batadv_unicast_packet) +
942	ETH_HLEN) < 0)
943	return 0;
944		1016
945	ethhdr = (struct ethhdr )(skb->data + sizeof(unicast_packet));	1017	old_ttvn = unicast_packet->ttvn;
		1018	/* the packet was forged based on outdated network information. Its
		1019	* destination can possibly be updated and forwarded towards the new
		1020	* target host
		1021	*/
		1022	if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
		1023	ethhdr->h_dest)) {
		1024	net_ratelimited_function(batadv_dbg, BATADV_DBG_TT, bat_priv,
		1025	"Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
		1026	unicast_packet->dest, ethhdr->h_dest,
		1027	old_ttvn, curr_ttvn);
		1028	return 1;
		1029	}
946		1030
947	/* we don't have an updated route for this client, so we should	1031	/* the packet has not been re-routed: either the destination is
948	* not try to reroute the packet!!	1032	* currently served by this node or there is no destination at all and
949	*/	1033	* it is possible to drop the packet
950	if (batadv_tt_global_client_is_roaming(bat_priv,	1034	*/
951	ethhdr->h_dest))	1035	if (!batadv_is_my_client(bat_priv, ethhdr->h_dest))
952	return 1;	1036	return 0;
953		1037
954	orig_node = batadv_transtable_search(bat_priv, NULL,	1038	/* update the header in order to let the packet be delivered to this
955	ethhdr->h_dest);	1039	* node's soft interface
		1040	*/
		1041	primary_if = batadv_primary_if_get_selected(bat_priv);
		1042	if (!primary_if)
		1043	return 0;
956		1044
957	if (!orig_node) {	1045	memcpy(unicast_packet->dest, primary_if->net_dev->dev_addr, ETH_ALEN);
958	if (!batadv_is_my_client(bat_priv, ethhdr->h_dest))
959	return 0;
960	primary_if = batadv_primary_if_get_selected(bat_priv);
961	if (!primary_if)
962	return 0;
963	memcpy(unicast_packet->dest,
964	primary_if->net_dev->dev_addr, ETH_ALEN);
965	batadv_hardif_free_ref(primary_if);
966	} else {
967	memcpy(unicast_packet->dest, orig_node->orig,
968	ETH_ALEN);
969	curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
970	batadv_orig_node_free_ref(orig_node);
971	}
972		1046
973	net_ratelimited_function(batadv_dbg, BATADV_DBG_TT, bat_priv,	1047	batadv_hardif_free_ref(primary_if);
974	"TTVN mismatch (old_ttvn %u new_ttvn %u)! Rerouting unicast packet (for %pM) to %pM\n",
975	unicast_packet->ttvn, curr_ttvn,
976	ethhdr->h_dest, unicast_packet->dest);
977		1048
978	unicast_packet->ttvn = curr_ttvn;	1049	unicast_packet->ttvn = curr_ttvn;
979	}	1050
980	return 1;	1051	return 1;
981	}	1052	}
982		1053
983	int batadv_recv_unicast_packet(struct sk_buff *skb,	1054	int batadv_recv_unicast_packet(struct sk_buff *skb,
984	struct batadv_hard_iface *recv_if)	1055	struct batadv_hard_iface *recv_if)
985	{	1056	{
986	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	1057	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
987	struct batadv_unicast_packet *unicast_packet;	1058	struct batadv_unicast_packet *unicast_packet;
988	struct batadv_unicast_4addr_packet *unicast_4addr_packet;	1059	struct batadv_unicast_4addr_packet *unicast_4addr_packet;
989	uint8_t *orig_addr;	1060	uint8_t *orig_addr;
990	struct batadv_orig_node *orig_node = NULL;	1061	struct batadv_orig_node *orig_node = NULL;
991	int hdr_size = sizeof(*unicast_packet);	1062	int hdr_size = sizeof(*unicast_packet);
992	bool is4addr;	1063	bool is4addr;
993		1064
994	unicast_packet = (struct batadv_unicast_packet *)skb->data;	1065	unicast_packet = (struct batadv_unicast_packet *)skb->data;
995	unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;	1066	unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
996		1067
997	is4addr = unicast_packet->header.packet_type == BATADV_UNICAST_4ADDR;	1068	is4addr = unicast_packet->header.packet_type == BATADV_UNICAST_4ADDR;
998	/* the caller function should have already pulled 2 bytes */	1069	/* the caller function should have already pulled 2 bytes */
999	if (is4addr)	1070	if (is4addr)
1000	hdr_size = sizeof(*unicast_4addr_packet);	1071	hdr_size = sizeof(*unicast_4addr_packet);
1001		1072
1002	if (batadv_check_unicast_packet(skb, hdr_size) < 0)	1073	if (batadv_check_unicast_packet(skb, hdr_size) < 0)
1003	return NET_RX_DROP;	1074	return NET_RX_DROP;
1004		1075
1005	if (!batadv_check_unicast_ttvn(bat_priv, skb))	1076	if (!batadv_check_unicast_ttvn(bat_priv, skb))
1006	return NET_RX_DROP;	1077	return NET_RX_DROP;
1007		1078
1008	/* packet for me */	1079	/* packet for me */
1009	if (batadv_is_my_mac(unicast_packet->dest)) {	1080	if (batadv_is_my_mac(unicast_packet->dest)) {
1010	if (is4addr) {	1081	if (is4addr) {
1011	batadv_dat_inc_counter(bat_priv,	1082	batadv_dat_inc_counter(bat_priv,
1012	unicast_4addr_packet->subtype);	1083	unicast_4addr_packet->subtype);
1013	orig_addr = unicast_4addr_packet->src;	1084	orig_addr = unicast_4addr_packet->src;
1014	orig_node = batadv_orig_hash_find(bat_priv, orig_addr);	1085	orig_node = batadv_orig_hash_find(bat_priv, orig_addr);
1015	}	1086	}
1016		1087
1017	if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,	1088	if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
1018	hdr_size))	1089	hdr_size))
1019	goto rx_success;	1090	goto rx_success;
1020	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,	1091	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
1021	hdr_size))	1092	hdr_size))
1022	goto rx_success;	1093	goto rx_success;
1023		1094
1024	batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,	1095	batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1025	orig_node);	1096	orig_node);
1026		1097
1027	rx_success:	1098	rx_success:
1028	if (orig_node)	1099	if (orig_node)
1029	batadv_orig_node_free_ref(orig_node);	1100	batadv_orig_node_free_ref(orig_node);
1030		1101
1031	return NET_RX_SUCCESS;	1102	return NET_RX_SUCCESS;
1032	}	1103	}
1033		1104
1034	return batadv_route_unicast_packet(skb, recv_if);	1105	return batadv_route_unicast_packet(skb, recv_if);
1035	}	1106	}
1036		1107
1037	int batadv_recv_ucast_frag_packet(struct sk_buff *skb,	1108	int batadv_recv_ucast_frag_packet(struct sk_buff *skb,
1038	struct batadv_hard_iface *recv_if)	1109	struct batadv_hard_iface *recv_if)
1039	{	1110	{
1040	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	1111	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1041	struct batadv_unicast_frag_packet *unicast_packet;	1112	struct batadv_unicast_frag_packet *unicast_packet;
1042	int hdr_size = sizeof(*unicast_packet);	1113	int hdr_size = sizeof(*unicast_packet);
1043	struct sk_buff *new_skb = NULL;	1114	struct sk_buff *new_skb = NULL;
1044	int ret;	1115	int ret;
1045		1116
1046	if (batadv_check_unicast_packet(skb, hdr_size) < 0)	1117	if (batadv_check_unicast_packet(skb, hdr_size) < 0)
1047	return NET_RX_DROP;	1118	return NET_RX_DROP;
1048		1119
1049	if (!batadv_check_unicast_ttvn(bat_priv, skb))	1120	if (!batadv_check_unicast_ttvn(bat_priv, skb))
1050	return NET_RX_DROP;	1121	return NET_RX_DROP;
1051		1122
1052	unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;	1123	unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;
1053		1124
1054	/* packet for me */	1125	/* packet for me */
1055	if (batadv_is_my_mac(unicast_packet->dest)) {	1126	if (batadv_is_my_mac(unicast_packet->dest)) {
1056		1127
1057	ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);	1128	ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
1058		1129
1059	if (ret == NET_RX_DROP)	1130	if (ret == NET_RX_DROP)
1060	return NET_RX_DROP;	1131	return NET_RX_DROP;
1061		1132
1062	/* packet was buffered for late merge */	1133	/* packet was buffered for late merge */
1063	if (!new_skb)	1134	if (!new_skb)
1064	return NET_RX_SUCCESS;	1135	return NET_RX_SUCCESS;
1065		1136
1066	if (batadv_dat_snoop_incoming_arp_request(bat_priv, new_skb,	1137	if (batadv_dat_snoop_incoming_arp_request(bat_priv, new_skb,
1067	hdr_size))	1138	hdr_size))
1068	goto rx_success;	1139	goto rx_success;
1069	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, new_skb,	1140	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, new_skb,
1070	hdr_size))	1141	hdr_size))
1071	goto rx_success;	1142	goto rx_success;
1072		1143
1073	batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if,	1144	batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if,
1074	sizeof(struct batadv_unicast_packet), NULL);	1145	sizeof(struct batadv_unicast_packet), NULL);
1075		1146
1076	rx_success:	1147	rx_success:
1077	return NET_RX_SUCCESS;	1148	return NET_RX_SUCCESS;
1078	}	1149	}
1079		1150
1080	return batadv_route_unicast_packet(skb, recv_if);	1151	return batadv_route_unicast_packet(skb, recv_if);
1081	}	1152	}
1082		1153
1083		1154
1084	int batadv_recv_bcast_packet(struct sk_buff *skb,	1155	int batadv_recv_bcast_packet(struct sk_buff *skb,
1085	struct batadv_hard_iface *recv_if)	1156	struct batadv_hard_iface *recv_if)
1086	{	1157	{
1087	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	1158	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1088	struct batadv_orig_node *orig_node = NULL;	1159	struct batadv_orig_node *orig_node = NULL;
1089	struct batadv_bcast_packet *bcast_packet;	1160	struct batadv_bcast_packet *bcast_packet;
1090	struct ethhdr *ethhdr;	1161	struct ethhdr *ethhdr;
1091	int hdr_size = sizeof(*bcast_packet);	1162	int hdr_size = sizeof(*bcast_packet);
1092	int ret = NET_RX_DROP;	1163	int ret = NET_RX_DROP;
1093	int32_t seq_diff;	1164	int32_t seq_diff;
1094		1165
1095	/* drop packet if it has not necessary minimum size */	1166	/* drop packet if it has not necessary minimum size */
1096	if (unlikely(!pskb_may_pull(skb, hdr_size)))	1167	if (unlikely(!pskb_may_pull(skb, hdr_size)))
1097	goto out;	1168	goto out;
1098		1169
1099	ethhdr = (struct ethhdr *)skb_mac_header(skb);	1170	ethhdr = (struct ethhdr *)skb_mac_header(skb);
1100		1171
1101	/* packet with broadcast indication but unicast recipient */	1172	/* packet with broadcast indication but unicast recipient */
1102	if (!is_broadcast_ether_addr(ethhdr->h_dest))	1173	if (!is_broadcast_ether_addr(ethhdr->h_dest))
1103	goto out;	1174	goto out;
1104		1175
1105	/* packet with broadcast sender address */	1176	/* packet with broadcast sender address */
1106	if (is_broadcast_ether_addr(ethhdr->h_source))	1177	if (is_broadcast_ether_addr(ethhdr->h_source))
1107	goto out;	1178	goto out;
1108		1179
1109	/* ignore broadcasts sent by myself */	1180	/* ignore broadcasts sent by myself */
1110	if (batadv_is_my_mac(ethhdr->h_source))	1181	if (batadv_is_my_mac(ethhdr->h_source))
1111	goto out;	1182	goto out;
1112		1183
1113	bcast_packet = (struct batadv_bcast_packet *)skb->data;	1184	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1114		1185
1115	/* ignore broadcasts originated by myself */	1186	/* ignore broadcasts originated by myself */
1116	if (batadv_is_my_mac(bcast_packet->orig))	1187	if (batadv_is_my_mac(bcast_packet->orig))
1117	goto out;	1188	goto out;
1118		1189
1119	if (bcast_packet->header.ttl < 2)	1190	if (bcast_packet->header.ttl < 2)
1120	goto out;	1191	goto out;
1121		1192
1122	orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);	1193	orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1123		1194
1124	if (!orig_node)	1195	if (!orig_node)
1125	goto out;	1196	goto out;
1126		1197
1127	spin_lock_bh(&orig_node->bcast_seqno_lock);	1198	spin_lock_bh(&orig_node->bcast_seqno_lock);
1128		1199
1129	/* check whether the packet is a duplicate */	1200	/* check whether the packet is a duplicate */
1130	if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,	1201	if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1131	ntohl(bcast_packet->seqno)))	1202	ntohl(bcast_packet->seqno)))
1132	goto spin_unlock;	1203	goto spin_unlock;
1133		1204
1134	seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;	1205	seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
1135		1206
1136	/* check whether the packet is old and the host just restarted. */	1207	/* check whether the packet is old and the host just restarted. */
1137	if (batadv_window_protected(bat_priv, seq_diff,	1208	if (batadv_window_protected(bat_priv, seq_diff,
1138	&orig_node->bcast_seqno_reset))	1209	&orig_node->bcast_seqno_reset))
1139	goto spin_unlock;	1210	goto spin_unlock;
1140		1211
1141	/* mark broadcast in flood history, update window position	1212	/* mark broadcast in flood history, update window position
1142	* if required.	1213	* if required.
1143	*/	1214	*/
1144	if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))	1215	if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1145	orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);	1216	orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
1146		1217
1147	spin_unlock_bh(&orig_node->bcast_seqno_lock);	1218	spin_unlock_bh(&orig_node->bcast_seqno_lock);
1148		1219
1149	/* keep skb linear for crc calculation */	1220	/* keep skb linear for crc calculation */
1150	if (skb_linearize(skb) < 0)	1221	if (skb_linearize(skb) < 0)
1151	goto out;	1222	goto out;
1152		1223
1153	bcast_packet = (struct batadv_bcast_packet *)skb->data;	1224	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1154		1225
1155	/* check whether this has been sent by another originator before */	1226	/* check whether this has been sent by another originator before */
1156	if (batadv_bla_check_bcast_duplist(bat_priv, bcast_packet, skb->len))	1227	if (batadv_bla_check_bcast_duplist(bat_priv, bcast_packet, skb->len))
1157	goto out;	1228	goto out;
1158		1229
1159	/* rebroadcast packet */	1230	/* rebroadcast packet */
1160	batadv_add_bcast_packet_to_list(bat_priv, skb, 1);	1231	batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1161		1232
1162	/* don't hand the broadcast up if it is from an originator	1233	/* don't hand the broadcast up if it is from an originator
1163	* from the same backbone.	1234	* from the same backbone.
1164	*/	1235	*/
1165	if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))	1236	if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1166	goto out;	1237	goto out;
1167		1238
1168	if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))	1239	if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
1169	goto rx_success;	1240	goto rx_success;
1170	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))	1241	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
1171	goto rx_success;	1242	goto rx_success;
1172		1243
1173	/* broadcast for me */	1244	/* broadcast for me */
1174	batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,	1245	batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1175	orig_node);	1246	orig_node);
1176		1247
1177	rx_success:	1248	rx_success:
1178	ret = NET_RX_SUCCESS;	1249	ret = NET_RX_SUCCESS;
1179	goto out;	1250	goto out;
1180		1251
1181	spin_unlock:	1252	spin_unlock:
1182	spin_unlock_bh(&orig_node->bcast_seqno_lock);	1253	spin_unlock_bh(&orig_node->bcast_seqno_lock);
1183	out:	1254	out:
1184	if (orig_node)	1255	if (orig_node)
1185	batadv_orig_node_free_ref(orig_node);	1256	batadv_orig_node_free_ref(orig_node);
1186	return ret;	1257	return ret;
1187	}	1258	}
1188		1259
1189	int batadv_recv_vis_packet(struct sk_buff *skb,	1260	int batadv_recv_vis_packet(struct sk_buff *skb,
1190	struct batadv_hard_iface *recv_if)	1261	struct batadv_hard_iface *recv_if)
1191	{	1262	{
1192	struct batadv_vis_packet *vis_packet;	1263	struct batadv_vis_packet *vis_packet;
1193	struct ethhdr *ethhdr;	1264	struct ethhdr *ethhdr;
1194	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);	1265	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1195	int hdr_size = sizeof(*vis_packet);	1266	int hdr_size = sizeof(*vis_packet);
1196		1267
1197	/* keep skb linear */	1268	/* keep skb linear */
1198	if (skb_linearize(skb) < 0)	1269	if (skb_linearize(skb) < 0)
1199	return NET_RX_DROP;	1270	return NET_RX_DROP;
1200		1271
1201	if (unlikely(!pskb_may_pull(skb, hdr_size)))	1272	if (unlikely(!pskb_may_pull(skb, hdr_size)))
1202	return NET_RX_DROP;	1273	return NET_RX_DROP;
1203		1274
1204	vis_packet = (struct batadv_vis_packet *)skb->data;	1275	vis_packet = (struct batadv_vis_packet *)skb->data;
1205	ethhdr = (struct ethhdr *)skb_mac_header(skb);	1276	ethhdr = (struct ethhdr *)skb_mac_header(skb);
1206		1277
1207	/* not for me */	1278	/* not for me */
1208	if (!batadv_is_my_mac(ethhdr->h_dest))	1279	if (!batadv_is_my_mac(ethhdr->h_dest))
1209	return NET_RX_DROP;	1280	return NET_RX_DROP;
1210		1281

net/batman-adv/soft-interface.c

Diff comments View file @ 7c1fd91

 /* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * 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 "soft-interface.h"
 #include "hard-interface.h"
 #include "distributed-arp-table.h"
 #include "routing.h"
 #include "send.h"
 #include "debugfs.h"
 #include "translation-table.h"
 #include "hash.h"
 #include "gateway_common.h"
 #include "gateway_client.h"
 #include "sysfs.h"
 #include "originator.h"
 #include <linux/slab.h>
 #include <linux/ethtool.h>
 #include <linux/etherdevice.h>
 #include <linux/if_vlan.h>
 #include "unicast.h"
 #include "bridge_loop_avoidance.h"
 static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
 static void batadv_get_drvinfo(struct net_device *dev,
 			       struct ethtool_drvinfo *info);
 static u32 batadv_get_msglevel(struct net_device *dev);
 static void batadv_set_msglevel(struct net_device *dev, u32 value);
 static u32 batadv_get_link(struct net_device *dev);
 static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data);
 static void batadv_get_ethtool_stats(struct net_device *dev,
 				     struct ethtool_stats *stats, u64 *data);
 static int batadv_get_sset_count(struct net_device *dev, int stringset);
 static const struct ethtool_ops batadv_ethtool_ops = {
 	.get_settings = batadv_get_settings,
 	.get_drvinfo = batadv_get_drvinfo,
 	.get_msglevel = batadv_get_msglevel,
 	.set_msglevel = batadv_set_msglevel,
 	.get_link = batadv_get_link,
 	.get_strings = batadv_get_strings,
 	.get_ethtool_stats = batadv_get_ethtool_stats,
 	.get_sset_count = batadv_get_sset_count,
 };
 int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
 {
 	int result;
 	/* TODO: We must check if we can release all references to non-payload
 	 * data using skb_header_release in our skbs to allow skb_cow_header to
 	 * work optimally. This means that those skbs are not allowed to read
 	 * or write any data which is before the current position of skb->data
 	 * after that call and thus allow other skbs with the same data buffer
 	 * to write freely in that area.
 	 */
 	result = skb_cow_head(skb, len);
 	if (result < 0)
 		return result;
 	skb_push(skb, len);
 	return 0;
 }
 static int batadv_interface_open(struct net_device *dev)
 {
 	netif_start_queue(dev);
 	return 0;
 }
 static int batadv_interface_release(struct net_device *dev)
 {
 	netif_stop_queue(dev);
 	return 0;
 }
 static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct net_device_stats *stats = &bat_priv->stats;
 	stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX);
 	stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES);
 	stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 	stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX);
 	stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES);
 	return stats;
 }
 static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct sockaddr *addr = p;
 	uint8_t old_addr[ETH_ALEN];
 	if (!is_valid_ether_addr(addr->sa_data))
 		return -EADDRNOTAVAIL;
 	memcpy(old_addr, dev->dev_addr, ETH_ALEN);
 	memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
 	/* only modify transtable if it has been initialized before */
 	if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) {
 		batadv_tt_local_remove(bat_priv, old_addr,
 				       "mac address changed", false);
 		batadv_tt_local_add(dev, addr->sa_data, BATADV_NULL_IFINDEX);
 	}
 	dev->addr_assign_type &= ~NET_ADDR_RANDOM;
 	return 0;
 }
 static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu)
 {
 	/* check ranges */
 	if ((new_mtu < 68) || (new_mtu > batadv_hardif_min_mtu(dev)))
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 static int batadv_interface_tx(struct sk_buff *skb,
 			       struct net_device *soft_iface)
 {
 	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_hard_iface *primary_if = NULL;
 	struct batadv_bcast_packet *bcast_packet;
 	struct vlan_ethhdr *vhdr;
 	__be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN);
 	static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,
 						   0x00, 0x00};
 	static const uint8_t ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00,
 						    0x00, 0x00};
 	unsigned int header_len = 0;
 	int data_len = skb->len, ret;
 	short vid __maybe_unused = -1;
 	bool do_bcast = false;
 	uint32_t seqno;
 	unsigned long brd_delay = 1;
 	if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 		goto dropped;
 	soft_iface->trans_start = jiffies;
 	switch (ntohs(ethhdr->h_proto)) {
 	case ETH_P_8021Q:
 		vhdr = (struct vlan_ethhdr *)skb->data;
 		vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
 		if (vhdr->h_vlan_encapsulated_proto != ethertype)
 			break;
 		/* fall through */
 	case BATADV_ETH_P_BATMAN:
 		goto dropped;
 	}
 	if (batadv_bla_tx(bat_priv, skb, vid))
 		goto dropped;
 	/* Register the client MAC in the transtable */
 	batadv_tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
 	/* don't accept stp packets. STP does not help in meshes.
 	 * better use the bridge loop avoidance ...
 	 *
 	 * The same goes for ECTP sent at least by some Cisco Switches,
 	 * it might confuse the mesh when used with bridge loop avoidance.
 	 */
 	if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
 		goto dropped;
 	if (batadv_compare_eth(ethhdr->h_dest, ectp_addr))
 		goto dropped;
 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
 		do_bcast = true;
 		switch (atomic_read(&bat_priv->gw_mode)) {
 		case BATADV_GW_MODE_SERVER:
 			/* gateway servers should not send dhcp
 			 * requests into the mesh
 			 */
 			ret = batadv_gw_is_dhcp_target(skb, &header_len);
 			if (ret)
 				goto dropped;
 			break;
 		case BATADV_GW_MODE_CLIENT:
 			/* gateway clients should send dhcp requests
 			 * via unicast to their gateway
 			 */
 			ret = batadv_gw_is_dhcp_target(skb, &header_len);
 			if (ret)
 				do_bcast = false;
 			break;
 		case BATADV_GW_MODE_OFF:
 		default:
 			break;
 		}
 	}
 	/* ethernet packet should be broadcasted */
 	if (do_bcast) {
 		primary_if = batadv_primary_if_get_selected(bat_priv);
 		if (!primary_if)
 			goto dropped;
 		/* in case of ARP request, we do not immediately broadcasti the
 		 * packet, instead we first wait for DAT to try to retrieve the
 		 * correct ARP entry
 		 */
 		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
 			brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);
 		if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
 			goto dropped;
 		bcast_packet = (struct batadv_bcast_packet *)skb->data;
 		bcast_packet->header.version = BATADV_COMPAT_VERSION;
 		bcast_packet->header.ttl = BATADV_TTL;
 		/* batman packet type: broadcast */
 		bcast_packet->header.packet_type = BATADV_BCAST;
 		bcast_packet->reserved = 0;
 		/* hw address of first interface is the orig mac because only
 		 * this mac is known throughout the mesh
 		 */
 		memcpy(bcast_packet->orig,
 		       primary_if->net_dev->dev_addr, ETH_ALEN);
 		/* set broadcast sequence number */
 		seqno = atomic_inc_return(&bat_priv->bcast_seqno);
 		bcast_packet->seqno = htonl(seqno);
 		batadv_add_bcast_packet_to_list(bat_priv, skb, brd_delay);
 		/* a copy is stored in the bcast list, therefore removing
 		 * the original skb.
 		 */
 		kfree_skb(skb);
 	/* unicast packet */
 	} else {
 		if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_OFF) {
 			ret = batadv_gw_out_of_range(bat_priv, skb, ethhdr);
 			if (ret)
 				goto dropped;
 		}
 		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
 			goto dropped;
 		batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb);
 		ret = batadv_unicast_send_skb(bat_priv, skb);
 		if (ret != 0)
 			goto dropped_freed;
 	}
 	batadv_inc_counter(bat_priv, BATADV_CNT_TX);
 	batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
 	goto end;
 dropped:
 	kfree_skb(skb);
 dropped_freed:
 	batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 end:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	return NETDEV_TX_OK;
 }
 void batadv_interface_rx(struct net_device *soft_iface,
 			 struct sk_buff *skb, struct batadv_hard_iface *recv_if,
 			 int hdr_size, struct batadv_orig_node *orig_node)
 {
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct ethhdr *ethhdr;
 	struct vlan_ethhdr *vhdr;
 	struct batadv_header *batadv_header = (struct batadv_header *)skb->data;
 	short vid __maybe_unused = -1;
 	__be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN);
 	bool is_bcast;
 	is_bcast = (batadv_header->packet_type == BATADV_BCAST);
 	/* check if enough space is available for pulling, and pull */
 	if (!pskb_may_pull(skb, hdr_size))
 		goto dropped;
 	skb_pull_rcsum(skb, hdr_size);
 	skb_reset_mac_header(skb);
 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 	switch (ntohs(ethhdr->h_proto)) {
 	case ETH_P_8021Q:
 		vhdr = (struct vlan_ethhdr *)skb->data;
 		vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
 		if (vhdr->h_vlan_encapsulated_proto != ethertype)
 			break;
 		/* fall through */
 	case BATADV_ETH_P_BATMAN:
 		goto dropped;
 	}
 	/* skb->dev & skb->pkt_type are set here */
 	if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
 		goto dropped;
 	skb->protocol = eth_type_trans(skb, soft_iface);
 	/* should not be necessary anymore as we use skb_pull_rcsum()
 	 * TODO: please verify this and remove this TODO
 	 * -- Dec 21st 2009, Simon Wunderlich
 	 */
 	/* skb->ip_summed = CHECKSUM_UNNECESSARY; */
 	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
 	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
 			   skb->len + ETH_HLEN);
 	soft_iface->last_rx = jiffies;
 	if (orig_node)
 		batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
 						     ethhdr->h_source);
 	if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest))
 		goto dropped;
 	/* Let the bridge loop avoidance check the packet. If will
 	 * not handle it, we can safely push it up.
 	 */
 	if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
 		goto out;
 	netif_rx(skb);
 	goto out;
 dropped:
 	kfree_skb(skb);
 out:
 	return;
 }
 /* batman-adv network devices have devices nesting below it and are a special
  * "super class" of normal network devices; split their locks off into a
  * separate class since they always nest.
  */
 static struct lock_class_key batadv_netdev_xmit_lock_key;
 static struct lock_class_key batadv_netdev_addr_lock_key;
 /**
  * batadv_set_lockdep_class_one - Set lockdep class for a single tx queue
  * @dev: device which owns the tx queue
  * @txq: tx queue to modify
  * @_unused: always NULL
  */
 static void batadv_set_lockdep_class_one(struct net_device *dev,
 					 struct netdev_queue *txq,
 					 void *_unused)
 {
 	lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
 }
 /**
  * batadv_set_lockdep_class - Set txq and addr_list lockdep class
  * @dev: network device to modify
  */
 static void batadv_set_lockdep_class(struct net_device *dev)
 {
 	lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
 	netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
 }
 /**
  * batadv_softif_init - Late stage initialization of soft interface
  * @dev: registered network device to modify
  *
  * Returns error code on failures
  */
 static int batadv_softif_init(struct net_device *dev)
 {
 	batadv_set_lockdep_class(dev);
 	return 0;
 }
 static const struct net_device_ops batadv_netdev_ops = {
 	.ndo_init = batadv_softif_init,
 	.ndo_open = batadv_interface_open,
 	.ndo_stop = batadv_interface_release,
 	.ndo_get_stats = batadv_interface_stats,
 	.ndo_set_mac_address = batadv_interface_set_mac_addr,
 	.ndo_change_mtu = batadv_interface_change_mtu,
 	.ndo_start_xmit = batadv_interface_tx,
 	.ndo_validate_addr = eth_validate_addr
 };
 static void batadv_interface_setup(struct net_device *dev)
 {
 	struct batadv_priv *priv = netdev_priv(dev);
 	ether_setup(dev);
 	dev->netdev_ops = &batadv_netdev_ops;
 	dev->destructor = free_netdev;
 	dev->tx_queue_len = 0;
 	/* can't call min_mtu, because the needed variables
 	 * have not been initialized yet
 	 */
 	dev->mtu = ETH_DATA_LEN;
 	/* reserve more space in the skbuff for our header */
 	dev->hard_header_len = BATADV_HEADER_LEN;
 	/* generate random address */
 	eth_hw_addr_random(dev);
 	SET_ETHTOOL_OPS(dev, &batadv_ethtool_ops);
 	memset(priv, 0, sizeof(*priv));
 }
 struct net_device *batadv_softif_create(const char *name)
 {
 	struct net_device *soft_iface;
 	struct batadv_priv *bat_priv;
 	int ret;
 	size_t cnt_len = sizeof(uint64_t) * BATADV_CNT_NUM;
 	soft_iface = alloc_netdev(sizeof(*bat_priv), name,
 				  batadv_interface_setup);
 	if (!soft_iface)
 		goto out;
 	bat_priv = netdev_priv(soft_iface);
 	/* batadv_interface_stats() needs to be available as soon as
 	 * register_netdevice() has been called
 	 */
 	bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(uint64_t));
 	if (!bat_priv->bat_counters)
 		goto free_soft_iface;
 	ret = register_netdevice(soft_iface);
 	if (ret < 0) {
 		pr_err("Unable to register the batman interface '%s': %i\n",
 		       name, ret);
 		goto free_bat_counters;
 	}
 	atomic_set(&bat_priv->aggregated_ogms, 1);
 	atomic_set(&bat_priv->bonding, 0);
 	atomic_set(&bat_priv->bridge_loop_avoidance, 0);
 #ifdef CONFIG_BATMAN_ADV_DAT
 	atomic_set(&bat_priv->distributed_arp_table, 1);
 #endif
 	atomic_set(&bat_priv->ap_isolation, 0);
 	atomic_set(&bat_priv->vis_mode, BATADV_VIS_TYPE_CLIENT_UPDATE);
 	atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF);
 	atomic_set(&bat_priv->gw_sel_class, 20);
 	atomic_set(&bat_priv->gw_bandwidth, 41);
 	atomic_set(&bat_priv->orig_interval, 1000);
 	atomic_set(&bat_priv->hop_penalty, 30);
 	atomic_set(&bat_priv->log_level, 0);
 	atomic_set(&bat_priv->fragmentation, 1);
 	atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
 	atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
 	atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
 	atomic_set(&bat_priv->bcast_seqno, 1);
 	atomic_set(&bat_priv->tt.vn, 0);
 	atomic_set(&bat_priv->tt.local_changes, 0);
 	atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
 #ifdef CONFIG_BATMAN_ADV_BLA
 	atomic_set(&bat_priv->bla.num_requests, 0);
 #endif
 	bat_priv->tt.last_changeset = NULL;
 	bat_priv->tt.last_changeset_len = 0;
-	bat_priv->tt.poss_change = false;
 	bat_priv->primary_if = NULL;
 	bat_priv->num_ifaces = 0;
 	ret = batadv_algo_select(bat_priv, batadv_routing_algo);
 	if (ret < 0)
 		goto unreg_soft_iface;
 	ret = batadv_sysfs_add_meshif(soft_iface);
 	if (ret < 0)
 		goto unreg_soft_iface;
 	ret = batadv_debugfs_add_meshif(soft_iface);
 	if (ret < 0)
 		goto unreg_sysfs;
 	ret = batadv_mesh_init(soft_iface);
 	if (ret < 0)
 		goto unreg_debugfs;
 	return soft_iface;
 unreg_debugfs:
 	batadv_debugfs_del_meshif(soft_iface);
 unreg_sysfs:
 	batadv_sysfs_del_meshif(soft_iface);
 unreg_soft_iface:
 	free_percpu(bat_priv->bat_counters);
 	unregister_netdevice(soft_iface);
 	return NULL;
 free_bat_counters:
 	free_percpu(bat_priv->bat_counters);
 free_soft_iface:
 	free_netdev(soft_iface);
 out:
 	return NULL;
 }
 void batadv_softif_destroy(struct net_device *soft_iface)
 {
 	batadv_debugfs_del_meshif(soft_iface);
 	batadv_sysfs_del_meshif(soft_iface);
 	batadv_mesh_free(soft_iface);
 	unregister_netdevice(soft_iface);
 }
 int batadv_softif_is_valid(const struct net_device *net_dev)
 {
 	if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
 		return 1;
 	return 0;
 }
 /* ethtool */
 static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
 	cmd->supported = 0;
 	cmd->advertising = 0;
 	ethtool_cmd_speed_set(cmd, SPEED_10);
 	cmd->duplex = DUPLEX_FULL;
 	cmd->port = PORT_TP;
 	cmd->phy_address = 0;
 	cmd->transceiver = XCVR_INTERNAL;
 	cmd->autoneg = AUTONEG_DISABLE;
 	cmd->maxtxpkt = 0;
 	cmd->maxrxpkt = 0;
 	return 0;
 }
 static void batadv_get_drvinfo(struct net_device *dev,
 			       struct ethtool_drvinfo *info)
 {
 	strcpy(info->driver, "B.A.T.M.A.N. advanced");
 	strcpy(info->version, BATADV_SOURCE_VERSION);
 	strcpy(info->fw_version, "N/A");
 	strcpy(info->bus_info, "batman");
 }
 static u32 batadv_get_msglevel(struct net_device *dev)
 {
 	return -EOPNOTSUPP;
 }
 static void batadv_set_msglevel(struct net_device *dev, u32 value)
 {
 }
 static u32 batadv_get_link(struct net_device *dev)
 {
 	return 1;
 }
 /* Inspired by drivers/net/ethernet/dlink/sundance.c:1702
  * Declare each description string in struct.name[] to get fixed sized buffer
  * and compile time checking for strings longer than ETH_GSTRING_LEN.
  */
 static const struct {
 	const char name[ETH_GSTRING_LEN];
 } batadv_counters_strings[] = {
 	{ "tx" },
 	{ "tx_bytes" },
 	{ "tx_dropped" },
 	{ "rx" },
 	{ "rx_bytes" },
 	{ "forward" },
 	{ "forward_bytes" },
 	{ "mgmt_tx" },
 	{ "mgmt_tx_bytes" },
 	{ "mgmt_rx" },
 	{ "mgmt_rx_bytes" },
 	{ "tt_request_tx" },
 	{ "tt_request_rx" },
 	{ "tt_response_tx" },
 	{ "tt_response_rx" },
 	{ "tt_roam_adv_tx" },
 	{ "tt_roam_adv_rx" },
 #ifdef CONFIG_BATMAN_ADV_DAT
 	{ "dat_get_tx" },
 	{ "dat_get_rx" },
 	{ "dat_put_tx" },
 	{ "dat_put_rx" },
 	{ "dat_cached_reply_tx" },
 #endif
 };
 static void batadv_get_strings(struct net_device *dev, uint32_t stringset,
 			       uint8_t *data)
 {
 	if (stringset == ETH_SS_STATS)
 		memcpy(data, batadv_counters_strings,
 		       sizeof(batadv_counters_strings));
 }
 static void batadv_get_ethtool_stats(struct net_device *dev,
 				     struct ethtool_stats *stats,
 				     uint64_t *data)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	int i;
 	for (i = 0; i < BATADV_CNT_NUM; i++)
 		data[i] = batadv_sum_counter(bat_priv, i);
 }
 static int batadv_get_sset_count(struct net_device *dev, int stringset)
 {
 	if (stringset == ETH_SS_STATS)
 		return BATADV_CNT_NUM;
 	return -EOPNOTSUPP;
 }

net/batman-adv/translation-table.c

Diff comments View file @ 7c1fd91

 /* Copyright (C) 2007-2012 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>
 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 void batadv_tt_start_timer(struct batadv_priv *bat_priv)
 {
 	INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
 	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
 			   msecs_to_jiffies(5000));
 }
 static struct batadv_tt_common_entry *
 batadv_tt_hash_find(struct batadv_hashtable *hash, const void *data)
 {
 	struct hlist_head *head;
 	struct hlist_node *node;
 	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, node, 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);
 	batadv_orig_node_free_ref(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;
 	return 0;
 }
 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_entry = NULL;
 	struct batadv_tt_global_entry *tt_global_entry = NULL;
 	struct hlist_head *head;
 	struct hlist_node *node;
 	struct batadv_tt_orig_list_entry *orig_entry;
 	int hash_added;
 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
 	if (tt_local_entry) {
 		tt_local_entry->last_seen = jiffies;
 		/* possibly unset the BATADV_TT_CLIENT_PENDING flag */
 		tt_local_entry->common.flags &= ~BATADV_TT_CLIENT_PENDING;
 		goto out;
 	}
 	tt_local_entry = kmalloc(sizeof(*tt_local_entry), GFP_ATOMIC);
 	if (!tt_local_entry)
 		goto out;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Creating new local tt entry: %pM (ttvn: %d)\n", addr,
 		   (uint8_t)atomic_read(&bat_priv->tt.vn));
 	memcpy(tt_local_entry->common.addr, addr, ETH_ALEN);
 	tt_local_entry->common.flags = BATADV_NO_FLAGS;
 	if (batadv_is_wifi_iface(ifindex))
 		tt_local_entry->common.flags |= BATADV_TT_CLIENT_WIFI;
 	atomic_set(&tt_local_entry->common.refcount, 2);
 	tt_local_entry->last_seen = jiffies;
 	tt_local_entry->common.added_at = tt_local_entry->last_seen;
 	/* the batman interface mac address should never be purged */
 	if (batadv_compare_eth(addr, soft_iface->dev_addr))
 		tt_local_entry->common.flags |= BATADV_TT_CLIENT_NOPURGE;
 	/* 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_entry->common.flags |= BATADV_TT_CLIENT_NEW;
 	hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
 				     batadv_choose_orig,
 				     &tt_local_entry->common,
 				     &tt_local_entry->common.hash_entry);
 	if (unlikely(hash_added != 0)) {
 		/* remove the reference for the hash */
 		batadv_tt_local_entry_free_ref(tt_local_entry);
 		goto out;
 	}
 	batadv_tt_local_event(bat_priv, addr, tt_local_entry->common.flags);
 	/* remove address from global hash if present */
 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
 	/* Check whether it is a roaming! */
 	if (tt_global_entry) {
 		/* These node are probably going to update their tt table */
 		head = &tt_global_entry->orig_list;
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(orig_entry, node, head, list) {
-			orig_entry->orig_node->tt_poss_change = true;
 			batadv_send_roam_adv(bat_priv,
 					     tt_global_entry->common.addr,
 					     orig_entry->orig_node);
 		}
 		rcu_read_unlock();
 		/* The global entry has to be marked as ROAMING and
 		 * has to be kept for consistency purpose
 		 */
 		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
 		tt_global_entry->roam_at = jiffies;
 	}
 out:
 	if (tt_local_entry)
 		batadv_tt_local_entry_free_ref(tt_local_entry);
 	if (tt_global_entry)
 		batadv_tt_global_entry_free_ref(tt_global_entry);
 }
 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)
 {
 	struct batadv_hard_iface *primary_if;
 	int req_len;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	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 ((!primary_if) || (req_len > primary_if->soft_iface->mtu))
 		req_len = min_packet_len;
 	batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
 				      min_packet_len, req_len);
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 }
 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_hard_iface *primary_if;
 	struct hlist_node *node;
 	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,
 		   "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
 		   net_dev->name, (uint8_t)atomic_read(&bat_priv->tt.vn));
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(tt_common_entry, node,
 					 head, hash_entry) {
 			seq_printf(seq, " * %pM [%c%c%c%c%c]\n",
 				   tt_common_entry->addr,
 				   (tt_common_entry->flags &
 				    BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
 				   (tt_common_entry->flags &
 				    BATADV_TT_CLIENT_NOPURGE ? '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' : '.'));
 		}
 		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\n",
 		   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 = NULL;
 	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 (roaming)
+	if (roaming) {
 		flags |= BATADV_TT_CLIENT_ROAM;
+		/* mark the local client as ROAMed */
+		tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
+	}
 	batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags, message);
 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, *node_tmp;
 	hlist_for_each_entry_safe(tt_common_entry, node, 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, *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, node_tmp,
 					  head, hash_entry) {
 			hlist_del_rcu(node);
 			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;
 	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;
 	struct hlist_node *node;
 	rcu_read_lock();
 	head = &entry->orig_list;
 	hlist_for_each_entry_rcu(tmp_orig_entry, node, 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 = NULL;
 	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);
 	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 {
 		/* 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 we can exit
 		 * directly because the temporary information should never
 		 * override any already known client state (whatever it is)
 		 */
 		if (flags & BATADV_TT_CLIENT_TEMP)
 			goto out;
 		/* if the client was temporary added before receiving the first
 		 * OGM announcing it, we have to clear the TEMP flag
 		 */
 		tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_TEMP;
 		/* 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 (tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM) {
 			batadv_tt_global_del_orig_list(tt_global_entry);
 			tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
 			tt_global_entry->roam_at = 0;
 		}
 	}
 	/* 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)\n",
 		   tt_global_entry->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;
 out:
 	if (tt_global_entry)
 		batadv_tt_global_entry_free_ref(tt_global_entry);
 	return ret;
 }
 /* print all orig nodes who announce the address for this global entry.
  * it is assumed that 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 hlist_node *node;
 	struct batadv_tt_orig_list_entry *orig_entry;
 	struct batadv_tt_common_entry *tt_common_entry;
 	uint16_t flags;
 	uint8_t last_ttvn;
 	tt_common_entry = &tt_global_entry->common;
 	head = &tt_global_entry->orig_list;
 	hlist_for_each_entry_rcu(orig_entry, node, head, list) {
 		flags = tt_common_entry->flags;
 		last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);
 		seq_printf(seq,	" * %pM  (%3u) via %pM     (%3u)   [%c%c%c]\n",
 			   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_node *node;
 	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\n",
 		   net_dev->name);
 	seq_printf(seq, "       %-13s %s       %-15s %s %s\n",
 		   "Client", "(TTVN)", "Originator", "(Curr TTVN)", "Flags");
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(tt_common_entry, node,
 					 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 *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, node, safe, head, list) {
 		hlist_del_rcu(node);
 		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 *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, node, 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\n",
 				   orig_node->orig,
 				   tt_global_entry->common.addr, message);
 			hlist_del_rcu(node);
 			batadv_tt_orig_list_entry_free_ref(orig_entry);
 		}
 	}
 	spin_unlock_bh(&tt_global_entry->list_lock);
 }
 static void
 batadv_tt_global_del_struct(struct batadv_priv *bat_priv,
 			    struct batadv_tt_global_entry *tt_global_entry,
 			    const char *message)
 {
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Deleting global tt entry %pM: %s\n",
 		   tt_global_entry->common.addr, message);
 	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
 			   batadv_choose_orig, tt_global_entry->common.addr);
 	batadv_tt_global_entry_free_ref(tt_global_entry);
 }
 /* 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 hlist_node *node;
 	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, node, 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 = NULL;
 	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_del_struct(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_del_struct(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 *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, node, 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\n",
 					   tt_global->common.addr, message);
 				hlist_del_rcu(node);
 				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\n";
 	}
 	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\n";
 	}
 	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, *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, 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\n",
 				   tt_global->common.addr, msg);
 			hlist_del_rcu(node);
 			batadv_tt_global_entry_free_ref(tt_global);
 		}
 		spin_unlock_bh(list_lock);
 	}
 }
 static void batadv_tt_global_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_global_entry *tt_global;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	uint32_t i;
 	if (!bat_priv->tt.global_hash)
 		return;
 	hash = bat_priv->tt.global_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, node_tmp,
 					  head, hash_entry) {
 			hlist_del_rcu(node);
 			tt_global = container_of(tt_common_entry,
 						 struct batadv_tt_global_entry,
 						 common);
 			batadv_tt_global_entry_free_ref(tt_global);
 		}
 		spin_unlock_bh(list_lock);
 	}
 	batadv_hash_destroy(hash);
 	bat_priv->tt.global_hash = NULL;
 }
 static bool
 _batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
 		       struct batadv_tt_global_entry *tt_global_entry)
 {
 	bool ret = false;
 	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
 	    tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
 		ret = true;
 	return ret;
 }
 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
 						  const uint8_t *src,
 						  const uint8_t *addr)
 {
 	struct batadv_tt_local_entry *tt_local_entry = NULL;
 	struct batadv_tt_global_entry *tt_global_entry = NULL;
 	struct batadv_orig_node *orig_node = NULL;
 	struct batadv_neigh_node *router = NULL;
 	struct hlist_head *head;
 	struct hlist_node *node;
 	struct batadv_tt_orig_list_entry *orig_entry;
 	int best_tq;
 	if (src && atomic_read(&bat_priv->ap_isolation)) {
 		tt_local_entry = batadv_tt_local_hash_find(bat_priv, src);
 		if (!tt_local_entry)
 			goto out;
 	}
 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
 	if (!tt_global_entry)
 		goto out;
 	/* check whether the clients should not communicate due to AP
 	 * isolation
 	 */
 	if (tt_local_entry &&
 	    _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
 		goto out;
 	best_tq = 0;
 	rcu_read_lock();
 	head = &tt_global_entry->orig_list;
 	hlist_for_each_entry_rcu(orig_entry, node, head, list) {
 		router = batadv_orig_node_get_router(orig_entry->orig_node);
 		if (!router)
 			continue;
 		if (router->tq_avg > best_tq) {
 			orig_node = orig_entry->orig_node;
 			best_tq = router->tq_avg;
 		}
 		batadv_neigh_node_free_ref(router);
 	}
 	/* found anything? */
 	if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))
 		orig_node = NULL;
 	rcu_read_unlock();
 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 orig_node;
 }
 /* Calculates the checksum of the local table of a given orig_node */
 static uint16_t batadv_tt_global_crc(struct batadv_priv *bat_priv,
 				     struct batadv_orig_node *orig_node)
 {
 	uint16_t total = 0, total_one;
 	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
 	struct batadv_tt_common_entry *tt_common;
 	struct batadv_tt_global_entry *tt_global;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	uint32_t i;
 	int j;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) {
 			tt_global = container_of(tt_common,
 						 struct batadv_tt_global_entry,
 						 common);
 			/* Roaming clients are in the global table for
 			 * consistency only. They don't have to be
 			 * taken into account while computing the
 			 * global crc
 			 */
 			if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
 				continue;
 			/* Temporary clients have not been announced yet, so
 			 * they have to be skipped while computing the global
 			 * crc
 			 */
 			if (tt_common->flags & BATADV_TT_CLIENT_TEMP)
 				continue;
 			/* find out if this global entry is announced by this
 			 * originator
 			 */
 			if (!batadv_tt_global_entry_has_orig(tt_global,
 							     orig_node))
 				continue;
 			total_one = 0;
 			for (j = 0; j < ETH_ALEN; j++)
 				total_one = crc16_byte(total_one,
 						       tt_common->addr[j]);
 			total ^= total_one;
 		}
 		rcu_read_unlock();
 	}
 	return total;
 }
 /* Calculates the checksum of the local table */
 static uint16_t batadv_tt_local_crc(struct batadv_priv *bat_priv)
 {
 	uint16_t total = 0, total_one;
 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
 	struct batadv_tt_common_entry *tt_common;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	uint32_t i;
 	int j;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) {
 			/* not yet committed clients have not to be taken into
 			 * account while computing the CRC
 			 */
 			if (tt_common->flags & BATADV_TT_CLIENT_NEW)
 				continue;
 			total_one = 0;
 			for (j = 0; j < ETH_ALEN; j++)
 				total_one = crc16_byte(total_one,
 						       tt_common->addr[j]);
 			total ^= total_one;
 		}
 		rcu_read_unlock();
 	}
 	return total;
 }
 static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
 {
 	struct batadv_tt_req_node *node, *safe;
 	spin_lock_bh(&bat_priv->tt.req_list_lock);
 	list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
 		list_del(&node->list);
 		kfree(node);
 	}
 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
 }
 static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
 				       struct batadv_orig_node *orig_node,
 				       const unsigned char *tt_buff,
 				       uint8_t tt_num_changes)
 {
 	uint16_t tt_buff_len = batadv_tt_len(tt_num_changes);
 	/* Replace the old buffer only if I received something in the
 	 * last OGM (the OGM could carry no changes)
 	 */
 	spin_lock_bh(&orig_node->tt_buff_lock);
 	if (tt_buff_len > 0) {
 		kfree(orig_node->tt_buff);
 		orig_node->tt_buff_len = 0;
 		orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
 		if (orig_node->tt_buff) {
 			memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
 			orig_node->tt_buff_len = tt_buff_len;
 		}
 	}
 	spin_unlock_bh(&orig_node->tt_buff_lock);
 }
 static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
 {
 	struct batadv_tt_req_node *node, *safe;
 	spin_lock_bh(&bat_priv->tt.req_list_lock);
 	list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
 		if (batadv_has_timed_out(node->issued_at,
 					 BATADV_TT_REQUEST_TIMEOUT)) {
 			list_del(&node->list);
 			kfree(node);
 		}
 	}
 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
 }
 /* returns the pointer to the new tt_req_node struct if no request
  * has already been issued for this orig_node, NULL otherwise
  */
 static struct batadv_tt_req_node *
 batadv_new_tt_req_node(struct batadv_priv *bat_priv,
 		       struct batadv_orig_node *orig_node)
 {
 	struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
 	spin_lock_bh(&bat_priv->tt.req_list_lock);
 	list_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
 		if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
 		    !batadv_has_timed_out(tt_req_node_tmp->issued_at,
 					  BATADV_TT_REQUEST_TIMEOUT))
 			goto unlock;
 	}
 	tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
 	if (!tt_req_node)
 		goto unlock;
 	memcpy(tt_req_node->addr, orig_node->orig, ETH_ALEN);
 	tt_req_node->issued_at = jiffies;
 	list_add(&tt_req_node->list, &bat_priv->tt.req_list);
 unlock:
 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
 	return tt_req_node;
 }
 /* data_ptr is useless here, but has to be kept to respect the prototype */
 static int batadv_tt_local_valid_entry(const void *entry_ptr,
 				       const void *data_ptr)
 {
 	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
 	if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
 		return 0;
 	return 1;
 }
 static int batadv_tt_global_valid(const void *entry_ptr,
 				  const void *data_ptr)
 {
 	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
 	const struct batadv_tt_global_entry *tt_global_entry;
 	const struct batadv_orig_node *orig_node = data_ptr;
 	if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
 	    tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
 		return 0;
 	tt_global_entry = container_of(tt_common_entry,
 				       struct batadv_tt_global_entry,
 				       common);
 	return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);
 }
 static struct sk_buff *
 batadv_tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
 			      struct batadv_hashtable *hash,
 			      struct batadv_hard_iface *primary_if,
 			      int (*valid_cb)(const void *, const void *),
 			      void *cb_data)
 {
 	struct batadv_tt_common_entry *tt_common_entry;
 	struct batadv_tt_query_packet *tt_response;
 	struct batadv_tt_change *tt_change;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct sk_buff *skb = NULL;
 	uint16_t tt_tot, tt_count;
 	ssize_t tt_query_size = sizeof(struct batadv_tt_query_packet);
 	uint32_t i;
 	size_t len;
 	if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
 		tt_len = primary_if->soft_iface->mtu - tt_query_size;
 		tt_len -= tt_len % sizeof(struct batadv_tt_change);
 	}
 	tt_tot = tt_len / sizeof(struct batadv_tt_change);
 	len = tt_query_size + tt_len;
 	skb = dev_alloc_skb(len + ETH_HLEN + NET_IP_ALIGN);
 	if (!skb)
 		goto out;
 	skb_reserve(skb, ETH_HLEN + NET_IP_ALIGN);
 	tt_response = (struct batadv_tt_query_packet *)skb_put(skb, len);
 	tt_response->ttvn = ttvn;
 	tt_change = (struct batadv_tt_change *)(skb->data + tt_query_size);
 	tt_count = 0;
 	rcu_read_lock();
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		hlist_for_each_entry_rcu(tt_common_entry, node,
 					 head, hash_entry) {
 			if (tt_count == tt_tot)
 				break;
 			if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
 				continue;
 			memcpy(tt_change->addr, tt_common_entry->addr,
 			       ETH_ALEN);
 			tt_change->flags = BATADV_NO_FLAGS;
 			tt_count++;
 			tt_change++;
 		}
 	}
 	rcu_read_unlock();
 	/* store in the message the number of entries we have successfully
 	 * copied
 	 */
 	tt_response->tt_data = htons(tt_count);
 out:
 	return skb;
 }
 static int batadv_send_tt_request(struct batadv_priv *bat_priv,
 				  struct batadv_orig_node *dst_orig_node,
 				  uint8_t ttvn, uint16_t tt_crc,
 				  bool full_table)
 {
 	struct sk_buff *skb = NULL;
 	struct batadv_tt_query_packet *tt_request;
 	struct batadv_neigh_node *neigh_node = NULL;
 	struct batadv_hard_iface *primary_if;
 	struct batadv_tt_req_node *tt_req_node = NULL;
 	int ret = 1;
 	size_t tt_req_len;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	/* The new tt_req will be issued only if I'm not waiting for a
 	 * reply from the same orig_node yet
 	 */
 	tt_req_node = batadv_new_tt_req_node(bat_priv, dst_orig_node);
 	if (!tt_req_node)
 		goto out;
 	skb = dev_alloc_skb(sizeof(*tt_request) + ETH_HLEN + NET_IP_ALIGN);
 	if (!skb)
 		goto out;
 	skb_reserve(skb, ETH_HLEN + NET_IP_ALIGN);
 	tt_req_len = sizeof(*tt_request);
 	tt_request = (struct batadv_tt_query_packet *)skb_put(skb, tt_req_len);
 	tt_request->header.packet_type = BATADV_TT_QUERY;
 	tt_request->header.version = BATADV_COMPAT_VERSION;
 	memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN);
 	memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN);
 	tt_request->header.ttl = BATADV_TTL;
 	tt_request->ttvn = ttvn;
 	tt_request->tt_data = htons(tt_crc);
 	tt_request->flags = BATADV_TT_REQUEST;
 	if (full_table)
 		tt_request->flags |= BATADV_TT_FULL_TABLE;
 	neigh_node = batadv_orig_node_get_router(dst_orig_node);
 	if (!neigh_node)
 		goto out;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Sending TT_REQUEST to %pM via %pM [%c]\n",
 		   dst_orig_node->orig, neigh_node->addr,
 		   (full_table ? 'F' : '.'));
 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
 	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 	ret = 0;
 out:
 	if (neigh_node)
 		batadv_neigh_node_free_ref(neigh_node);
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	if (ret)
 		kfree_skb(skb);
 	if (ret && tt_req_node) {
 		spin_lock_bh(&bat_priv->tt.req_list_lock);
 		list_del(&tt_req_node->list);
 		spin_unlock_bh(&bat_priv->tt.req_list_lock);
 		kfree(tt_req_node);
 	}
 	return ret;
 }
 static bool
 batadv_send_other_tt_response(struct batadv_priv *bat_priv,
 			      struct batadv_tt_query_packet *tt_request)
 {
 	struct batadv_orig_node *req_dst_orig_node = NULL;
 	struct batadv_orig_node *res_dst_orig_node = NULL;
 	struct batadv_neigh_node *neigh_node = NULL;
 	struct batadv_hard_iface *primary_if = NULL;
 	uint8_t orig_ttvn, req_ttvn, ttvn;
 	int ret = false;
 	unsigned char *tt_buff;
 	bool full_table;
 	uint16_t tt_len, tt_tot;
 	struct sk_buff *skb = NULL;
 	struct batadv_tt_query_packet *tt_response;
 	uint8_t *packet_pos;
 	size_t len;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
 		   tt_request->src, tt_request->ttvn, tt_request->dst,
 		   (tt_request->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
 	/* Let's get the orig node of the REAL destination */
 	req_dst_orig_node = batadv_orig_hash_find(bat_priv, tt_request->dst);
 	if (!req_dst_orig_node)
 		goto out;
 	res_dst_orig_node = batadv_orig_hash_find(bat_priv, tt_request->src);
 	if (!res_dst_orig_node)
 		goto out;
 	neigh_node = batadv_orig_node_get_router(res_dst_orig_node);
 	if (!neigh_node)
 		goto out;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
 	req_ttvn = tt_request->ttvn;
 	/* I don't have the requested data */
 	if (orig_ttvn != req_ttvn ||
 	    tt_request->tt_data != htons(req_dst_orig_node->tt_crc))
 		goto out;
 	/* If the full table has been explicitly requested */
 	if (tt_request->flags & BATADV_TT_FULL_TABLE ||
 	    !req_dst_orig_node->tt_buff)
 		full_table = true;
 	else
 		full_table = false;
 	/* In this version, fragmentation is not implemented, then
 	 * I'll send only one packet with as much TT entries as I can
 	 */
 	if (!full_table) {
 		spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
 		tt_len = req_dst_orig_node->tt_buff_len;
 		tt_tot = tt_len / sizeof(struct batadv_tt_change);
 		len = sizeof(*tt_response) + tt_len;
 		skb = dev_alloc_skb(len + ETH_HLEN + NET_IP_ALIGN);
 		if (!skb)
 			goto unlock;
 		skb_reserve(skb, ETH_HLEN + NET_IP_ALIGN);
 		packet_pos = skb_put(skb, len);
 		tt_response = (struct batadv_tt_query_packet *)packet_pos;
 		tt_response->ttvn = req_ttvn;
 		tt_response->tt_data = htons(tt_tot);
 		tt_buff = skb->data + sizeof(*tt_response);
 		/* Copy the last orig_node's OGM buffer */
 		memcpy(tt_buff, req_dst_orig_node->tt_buff,
 		       req_dst_orig_node->tt_buff_len);
 		spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
 	} else {
 		tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size);
 		tt_len *= sizeof(struct batadv_tt_change);
 		ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
 		skb = batadv_tt_response_fill_table(tt_len, ttvn,
 						    bat_priv->tt.global_hash,
 						    primary_if,
 						    batadv_tt_global_valid,
 						    req_dst_orig_node);
 		if (!skb)
 			goto out;
 		tt_response = (struct batadv_tt_query_packet *)skb->data;
 	}
 	tt_response->header.packet_type = BATADV_TT_QUERY;
 	tt_response->header.version = BATADV_COMPAT_VERSION;
 	tt_response->header.ttl = BATADV_TTL;
 	memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN);
 	memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
 	tt_response->flags = BATADV_TT_RESPONSE;
 	if (full_table)
 		tt_response->flags |= BATADV_TT_FULL_TABLE;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
 		   res_dst_orig_node->orig, neigh_node->addr,
 		   req_dst_orig_node->orig, req_ttvn);
 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
 	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 	ret = true;
 	goto out;
 unlock:
 	spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
 out:
 	if (res_dst_orig_node)
 		batadv_orig_node_free_ref(res_dst_orig_node);
 	if (req_dst_orig_node)
 		batadv_orig_node_free_ref(req_dst_orig_node);
 	if (neigh_node)
 		batadv_neigh_node_free_ref(neigh_node);
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	if (!ret)
 		kfree_skb(skb);
 	return ret;
 }
 static bool
 batadv_send_my_tt_response(struct batadv_priv *bat_priv,
 			   struct batadv_tt_query_packet *tt_request)
 {
 	struct batadv_orig_node *orig_node = NULL;
 	struct batadv_neigh_node *neigh_node = NULL;
 	struct batadv_hard_iface *primary_if = NULL;
 	uint8_t my_ttvn, req_ttvn, ttvn;
 	int ret = false;
 	unsigned char *tt_buff;
 	bool full_table;
 	uint16_t tt_len, tt_tot;
 	struct sk_buff *skb = NULL;
 	struct batadv_tt_query_packet *tt_response;
 	uint8_t *packet_pos;
 	size_t len;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
 		   tt_request->src, tt_request->ttvn,
 		   (tt_request->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
 	my_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
 	req_ttvn = tt_request->ttvn;
 	orig_node = batadv_orig_hash_find(bat_priv, tt_request->src);
 	if (!orig_node)
 		goto out;
 	neigh_node = batadv_orig_node_get_router(orig_node);
 	if (!neigh_node)
 		goto out;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	/* If the full table has been explicitly requested or the gap
 	 * is too big send the whole local translation table
 	 */
 	if (tt_request->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
 	    !bat_priv->tt.last_changeset)
 		full_table = true;
 	else
 		full_table = false;
 	/* In this version, fragmentation is not implemented, then
 	 * I'll send only one packet with as much TT entries as I can
 	 */
 	if (!full_table) {
 		spin_lock_bh(&bat_priv->tt.last_changeset_lock);
 		tt_len = bat_priv->tt.last_changeset_len;
 		tt_tot = tt_len / sizeof(struct batadv_tt_change);
 		len = sizeof(*tt_response) + tt_len;
 		skb = dev_alloc_skb(len + ETH_HLEN + NET_IP_ALIGN);
 		if (!skb)
 			goto unlock;
 		skb_reserve(skb, ETH_HLEN + NET_IP_ALIGN);
 		packet_pos = skb_put(skb, len);
 		tt_response = (struct batadv_tt_query_packet *)packet_pos;
 		tt_response->ttvn = req_ttvn;
 		tt_response->tt_data = htons(tt_tot);
 		tt_buff = skb->data + sizeof(*tt_response);
 		memcpy(tt_buff, bat_priv->tt.last_changeset,
 		       bat_priv->tt.last_changeset_len);
 		spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
 	} else {
 		tt_len = (uint16_t)atomic_read(&bat_priv->tt.local_entry_num);
 		tt_len *= sizeof(struct batadv_tt_change);
 		ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
 		skb = batadv_tt_response_fill_table(tt_len, ttvn,
 						    bat_priv->tt.local_hash,
 						    primary_if,
 						    batadv_tt_local_valid_entry,
 						    NULL);
 		if (!skb)
 			goto out;
 		tt_response = (struct batadv_tt_query_packet *)skb->data;
 	}
 	tt_response->header.packet_type = BATADV_TT_QUERY;
 	tt_response->header.version = BATADV_COMPAT_VERSION;
 	tt_response->header.ttl = BATADV_TTL;
 	memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN);
 	memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
 	tt_response->flags = BATADV_TT_RESPONSE;
 	if (full_table)
 		tt_response->flags |= BATADV_TT_FULL_TABLE;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Sending TT_RESPONSE to %pM via %pM [%c]\n",
 		   orig_node->orig, neigh_node->addr,
 		   (tt_response->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
 	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 	ret = true;
 	goto out;
 unlock:
 	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
 out:
 	if (orig_node)
 		batadv_orig_node_free_ref(orig_node);
 	if (neigh_node)
 		batadv_neigh_node_free_ref(neigh_node);
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	if (!ret)
 		kfree_skb(skb);
 	/* This packet was for me, so it doesn't need to be re-routed */
 	return true;
 }
 bool batadv_send_tt_response(struct batadv_priv *bat_priv,
 			     struct batadv_tt_query_packet *tt_request)
 {
 	if (batadv_is_my_mac(tt_request->dst)) {
 		/* don't answer backbone gws! */
 		if (batadv_bla_is_backbone_gw_orig(bat_priv, tt_request->src))
 			return true;
 		return batadv_send_my_tt_response(bat_priv, tt_request);
 	} else {
 		return batadv_send_other_tt_response(bat_priv, tt_request);
 	}
 }
 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
 				      struct batadv_orig_node *orig_node,
 				      struct batadv_tt_change *tt_change,
 				      uint16_t tt_num_changes, uint8_t ttvn)
 {
 	int i;
 	int roams;
 	for (i = 0; i < tt_num_changes; i++) {
 		if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
 			roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
 			batadv_tt_global_del(bat_priv, orig_node,
 					     (tt_change + i)->addr,
 					     "tt removed by changes",
 					     roams);
 		} else {
 			if (!batadv_tt_global_add(bat_priv, orig_node,
 						  (tt_change + i)->addr,
 						  (tt_change + i)->flags, ttvn))
 				/* In case of problem while storing a
 				 * global_entry, we stop the updating
 				 * procedure without committing the
 				 * ttvn change. This will avoid to send
 				 * corrupted data on tt_request
 				 */
 				return;
 		}
 	}
 	orig_node->tt_initialised = true;
 }
 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
 				  struct batadv_tt_query_packet *tt_response)
 {
 	struct batadv_orig_node *orig_node = NULL;
 	orig_node = batadv_orig_hash_find(bat_priv, tt_response->src);
 	if (!orig_node)
 		goto out;
 	/* Purge the old table first.. */
 	batadv_tt_global_del_orig(bat_priv, orig_node, "Received full table");
 	_batadv_tt_update_changes(bat_priv, orig_node,
 				  (struct batadv_tt_change *)(tt_response + 1),
 				  ntohs(tt_response->tt_data),
 				  tt_response->ttvn);
 	spin_lock_bh(&orig_node->tt_buff_lock);
 	kfree(orig_node->tt_buff);
 	orig_node->tt_buff_len = 0;
 	orig_node->tt_buff = NULL;
 	spin_unlock_bh(&orig_node->tt_buff_lock);
 	atomic_set(&orig_node->last_ttvn, tt_response->ttvn);
 out:
 	if (orig_node)
 		batadv_orig_node_free_ref(orig_node);
 }
 static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
 				     struct batadv_orig_node *orig_node,
 				     uint16_t tt_num_changes, uint8_t ttvn,
 				     struct batadv_tt_change *tt_change)
 {
 	_batadv_tt_update_changes(bat_priv, orig_node, tt_change,
 				  tt_num_changes, ttvn);
 	batadv_tt_save_orig_buffer(bat_priv, orig_node,
 				   (unsigned char *)tt_change, tt_num_changes);
 	atomic_set(&orig_node->last_ttvn, ttvn);
 }
 bool batadv_is_my_client(struct batadv_priv *bat_priv, const uint8_t *addr)
 {
 	struct batadv_tt_local_entry *tt_local_entry = NULL;
 	bool ret = false;
 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
 	if (!tt_local_entry)
 		goto out;
 	/* Check if the client has been logically deleted (but is kept for
 	 * consistency purpose)
 	 */
-	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
+	if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
+	    (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
 		goto out;
 	ret = true;
 out:
 	if (tt_local_entry)
 		batadv_tt_local_entry_free_ref(tt_local_entry);
 	return ret;
 }
 void batadv_handle_tt_response(struct batadv_priv *bat_priv,
 			       struct batadv_tt_query_packet *tt_response)
 {
 	struct batadv_tt_req_node *node, *safe;
 	struct batadv_orig_node *orig_node = NULL;
 	struct batadv_tt_change *tt_change;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
 		   tt_response->src, tt_response->ttvn,
 		   ntohs(tt_response->tt_data),
 		   (tt_response->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
 	/* we should have never asked a backbone gw */
 	if (batadv_bla_is_backbone_gw_orig(bat_priv, tt_response->src))
 		goto out;
 	orig_node = batadv_orig_hash_find(bat_priv, tt_response->src);
 	if (!orig_node)
 		goto out;
 	if (tt_response->flags & BATADV_TT_FULL_TABLE) {
 		batadv_tt_fill_gtable(bat_priv, tt_response);
 	} else {
 		tt_change = (struct batadv_tt_change *)(tt_response + 1);
 		batadv_tt_update_changes(bat_priv, orig_node,
 					 ntohs(tt_response->tt_data),
 					 tt_response->ttvn, tt_change);
 	}
 	/* Delete the tt_req_node from pending tt_requests list */
 	spin_lock_bh(&bat_priv->tt.req_list_lock);
 	list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
 		if (!batadv_compare_eth(node->addr, tt_response->src))
 			continue;
 		list_del(&node->list);
 		kfree(node);
 	}
 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
 	/* Recalculate the CRC for this orig_node and store it */
 	orig_node->tt_crc = batadv_tt_global_crc(bat_priv, orig_node);
-	/* Roaming phase is over: tables are in sync again. I can
-	 * unset the flag
-	 */
-	orig_node->tt_poss_change = false;
 out:
 	if (orig_node)
 		batadv_orig_node_free_ref(orig_node);
 }
 int batadv_tt_init(struct batadv_priv *bat_priv)
 {
 	int ret;
 	ret = batadv_tt_local_init(bat_priv);
 	if (ret < 0)
 		return ret;
 	ret = batadv_tt_global_init(bat_priv);
 	if (ret < 0)
 		return ret;
 	batadv_tt_start_timer(bat_priv);
 	return 1;
 }
 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
 {
 	struct batadv_tt_roam_node *node, *safe;
 	spin_lock_bh(&bat_priv->tt.roam_list_lock);
 	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
 		list_del(&node->list);
 		kfree(node);
 	}
 	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
 }
 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
 {
 	struct batadv_tt_roam_node *node, *safe;
 	spin_lock_bh(&bat_priv->tt.roam_list_lock);
 	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
 		if (!batadv_has_timed_out(node->first_time,
 					  BATADV_ROAMING_MAX_TIME))
 			continue;
 		list_del(&node->list);
 		kfree(node);
 	}
 	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
 }
 /* This function checks whether the client already reached the
  * maximum number of possible roaming phases. In this case the ROAMING_ADV
  * will not be sent.
  *
  * returns true if the ROAMING_ADV can be sent, false otherwise
  */
 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv,
 				       uint8_t *client)
 {
 	struct batadv_tt_roam_node *tt_roam_node;
 	bool ret = false;
 	spin_lock_bh(&bat_priv->tt.roam_list_lock);
 	/* The new tt_req will be issued only if I'm not waiting for a
 	 * reply from the same orig_node yet
 	 */
 	list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
 		if (!batadv_compare_eth(tt_roam_node->addr, client))
 			continue;
 		if (batadv_has_timed_out(tt_roam_node->first_time,
 					 BATADV_ROAMING_MAX_TIME))
 			continue;
 		if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
 			/* Sorry, you roamed too many times! */
 			goto unlock;
 		ret = true;
 		break;
 	}
 	if (!ret) {
 		tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
 		if (!tt_roam_node)
 			goto unlock;
 		tt_roam_node->first_time = jiffies;
 		atomic_set(&tt_roam_node->counter,
 			   BATADV_ROAMING_MAX_COUNT - 1);
 		memcpy(tt_roam_node->addr, client, ETH_ALEN);
 		list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
 		ret = true;
 	}
 unlock:
 	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
 	return ret;
 }
 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client,
 				 struct batadv_orig_node *orig_node)
 {
 	struct batadv_neigh_node *neigh_node = NULL;
 	struct sk_buff *skb = NULL;
 	struct batadv_roam_adv_packet *roam_adv_packet;
 	int ret = 1;
 	struct batadv_hard_iface *primary_if;
 	size_t len = sizeof(*roam_adv_packet);
 	/* before going on we have to check whether the client has
 	 * already roamed to us too many times
 	 */
 	if (!batadv_tt_check_roam_count(bat_priv, client))
 		goto out;
 	skb = dev_alloc_skb(sizeof(*roam_adv_packet) + ETH_HLEN + NET_IP_ALIGN);
 	if (!skb)
 		goto out;
 	skb_reserve(skb, ETH_HLEN + NET_IP_ALIGN);
 	roam_adv_packet = (struct batadv_roam_adv_packet *)skb_put(skb, len);
 	roam_adv_packet->header.packet_type = BATADV_ROAM_ADV;
 	roam_adv_packet->header.version = BATADV_COMPAT_VERSION;
 	roam_adv_packet->header.ttl = BATADV_TTL;
 	roam_adv_packet->reserved = 0;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
 	batadv_hardif_free_ref(primary_if);
 	memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN);
 	memcpy(roam_adv_packet->client, client, ETH_ALEN);
 	neigh_node = batadv_orig_node_get_router(orig_node);
 	if (!neigh_node)
 		goto out;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
 		   orig_node->orig, client, neigh_node->addr);
 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
 	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 	ret = 0;
 out:
 	if (neigh_node)
 		batadv_neigh_node_free_ref(neigh_node);
 	if (ret)
 		kfree_skb(skb);
 	return;
 }
 static void batadv_tt_purge(struct work_struct *work)
 {
 	struct delayed_work *delayed_work;
 	struct batadv_priv_tt *priv_tt;
 	struct batadv_priv *bat_priv;
 	delayed_work = container_of(work, struct delayed_work, work);
 	priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
 	bat_priv = container_of(priv_tt, struct batadv_priv, tt);
 	batadv_tt_local_purge(bat_priv);
 	batadv_tt_global_purge(bat_priv);
 	batadv_tt_req_purge(bat_priv);
 	batadv_tt_roam_purge(bat_priv);
 	batadv_tt_start_timer(bat_priv);
 }
 void batadv_tt_free(struct batadv_priv *bat_priv)
 {
 	cancel_delayed_work_sync(&bat_priv->tt.work);
 	batadv_tt_local_table_free(bat_priv);
 	batadv_tt_global_table_free(bat_priv);
 	batadv_tt_req_list_free(bat_priv);
 	batadv_tt_changes_list_free(bat_priv);
 	batadv_tt_roam_list_free(bat_priv);
 	kfree(bat_priv->tt.last_changeset);
 }
 /* This function will enable or disable the specified flags for all the entries
  * in the given hash table and returns the number of modified entries
  */
 static uint16_t batadv_tt_set_flags(struct batadv_hashtable *hash,
 				    uint16_t flags, bool enable)
 {
 	uint32_t i;
 	uint16_t changed_num = 0;
 	struct hlist_head *head;
 	struct hlist_node *node;
 	struct batadv_tt_common_entry *tt_common_entry;
 	if (!hash)
 		goto out;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(tt_common_entry, node,
 					 head, hash_entry) {
 			if (enable) {
 				if ((tt_common_entry->flags & flags) == flags)
 					continue;
 				tt_common_entry->flags |= flags;
 			} else {
 				if (!(tt_common_entry->flags & flags))
 					continue;
 				tt_common_entry->flags &= ~flags;
 			}
 			changed_num++;
 		}
 		rcu_read_unlock();
 	}
 out:
 	return changed_num;
 }
 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
 {
 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
 	struct batadv_tt_common_entry *tt_common;
 	struct batadv_tt_local_entry *tt_local;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	spinlock_t *list_lock; /* protects write access to the hash lists */
 	uint32_t i;
 	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, node, node_tmp, head,
 					  hash_entry) {
 			if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
 				continue;
 			batadv_dbg(BATADV_DBG_TT, bat_priv,
 				   "Deleting local tt entry (%pM): pending\n",
 				   tt_common->addr);
 			atomic_dec(&bat_priv->tt.local_entry_num);
 			hlist_del_rcu(node);
 			tt_local = container_of(tt_common,
 						struct batadv_tt_local_entry,
 						common);
 			batadv_tt_local_entry_free_ref(tt_local);
 		}
 		spin_unlock_bh(list_lock);
 	}
 }
 static int batadv_tt_commit_changes(struct batadv_priv *bat_priv,
 				    unsigned char **packet_buff,
 				    int *packet_buff_len, int packet_min_len)
 {
 	uint16_t changed_num = 0;
 	if (atomic_read(&bat_priv->tt.local_changes) < 1)
 		return -ENOENT;
 	changed_num = batadv_tt_set_flags(bat_priv->tt.local_hash,
 					  BATADV_TT_CLIENT_NEW, false);
 	/* all reset entries have to be counted as local entries */
 	atomic_add(changed_num, &bat_priv->tt.local_entry_num);
 	batadv_tt_local_purge_pending_clients(bat_priv);
 	bat_priv->tt.local_crc = batadv_tt_local_crc(bat_priv);
 	/* Increment the TTVN only once per OGM interval */
 	atomic_inc(&bat_priv->tt.vn);
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Local changes committed, updating to ttvn %u\n",
 		   (uint8_t)atomic_read(&bat_priv->tt.vn));
-	bat_priv->tt.poss_change = false;
 	/* reset the sending counter */
 	atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
 	return batadv_tt_changes_fill_buff(bat_priv, packet_buff,
 					   packet_buff_len, packet_min_len);
 }
 /* when calling this function (hard_iface == primary_if) has to be true */
 int batadv_tt_append_diff(struct batadv_priv *bat_priv,
 			  unsigned char **packet_buff, int *packet_buff_len,
 			  int packet_min_len)
 {
 	int tt_num_changes;
 	/* if at least one change happened */
 	tt_num_changes = batadv_tt_commit_changes(bat_priv, packet_buff,
 						  packet_buff_len,
 						  packet_min_len);
 	/* if the changes have been sent often enough */
 	if ((tt_num_changes < 0) &&
 	    (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))) {
 		batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
 					      packet_min_len, packet_min_len);
 		tt_num_changes = 0;
 	}
 	return tt_num_changes;
 }
 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, uint8_t *src,
 			   uint8_t *dst)
 {
 	struct batadv_tt_local_entry *tt_local_entry = NULL;
 	struct batadv_tt_global_entry *tt_global_entry = NULL;
 	bool ret = false;
 	if (!atomic_read(&bat_priv->ap_isolation))
 		goto out;
 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst);
 	if (!tt_local_entry)
 		goto out;
 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, src);
 	if (!tt_global_entry)
 		goto out;
 	if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
 		goto out;
 	ret = true;
 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;
 }
 void batadv_tt_update_orig(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node,
 			   const unsigned char *tt_buff, uint8_t tt_num_changes,
 			   uint8_t ttvn, uint16_t tt_crc)
 {
 	uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
 	bool full_table = true;
 	struct batadv_tt_change *tt_change;
 	/* don't care about a backbone gateways updates. */
 	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig))
 		return;
 	/* orig table not initialised AND first diff is in the OGM OR the ttvn
 	 * increased by one -> we can apply the attached changes
 	 */
 	if ((!orig_node->tt_initialised && ttvn == 1) ||
 	    ttvn - orig_ttvn == 1) {
 		/* the OGM could not contain the changes due to their size or
 		 * because they have already been sent BATADV_TT_OGM_APPEND_MAX
 		 * times.
 		 * In this case send a tt request
 		 */
 		if (!tt_num_changes) {
 			full_table = false;
 			goto request_table;
 		}
 		tt_change = (struct batadv_tt_change *)tt_buff;
 		batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
 					 ttvn, tt_change);
 		/* Even if we received the precomputed crc with the OGM, we
 		 * prefer to recompute it to spot any possible inconsistency
 		 * in the global table
 		 */
 		orig_node->tt_crc = batadv_tt_global_crc(bat_priv, orig_node);
 		/* The ttvn alone is not enough to guarantee consistency
 		 * because a single value could represent different states
 		 * (due to the wrap around). Thus a node has to check whether
 		 * the resulting table (after applying the changes) is still
 		 * consistent or not. E.g. a node could disconnect while its
 		 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
 		 * checking the CRC value is mandatory to detect the
 		 * inconsistency
 		 */
 		if (orig_node->tt_crc != tt_crc)
 			goto request_table;
-		/* Roaming phase is over: tables are in sync again. I can
-		 * unset the flag
-		 */
-		orig_node->tt_poss_change = false;
 	} else {
 		/* if we missed more than one change or our tables are not
 		 * in sync anymore -> request fresh tt data
 		 */
 		if (!orig_node->tt_initialised || ttvn != orig_ttvn ||
 		    orig_node->tt_crc != tt_crc) {
 request_table:
 			batadv_dbg(BATADV_DBG_TT, bat_priv,
 				   "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u crc: %u last_crc: %u num_changes: %u)\n",
 				   orig_node->orig, ttvn, orig_ttvn, tt_crc,
 				   orig_node->tt_crc, tt_num_changes);
 			batadv_send_tt_request(bat_priv, orig_node, ttvn,
 					       tt_crc, full_table);
 			return;
 		}
 	}
 }
 /* returns true whether we know that the client has moved from its old
  * originator to another one. This entry is kept is still kept for consistency
  * purposes
  */
 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
 					uint8_t *addr)
 {
 	struct batadv_tt_global_entry *tt_global_entry;
 	bool ret = false;
 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
 	if (!tt_global_entry)
 		goto out;
 	ret = !!(tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM);
 	batadv_tt_global_entry_free_ref(tt_global_entry);
 out:
 	return ret;
+}
+/**
+ * batadv_tt_local_client_is_roaming - tells whether the client is roaming
+ * @bat_priv: the bat priv with all the soft interface information
+ * @addr: the MAC address of the local client to query
+ *
+ * Returns true if the local client is known to be roaming (it is not served by
+ * this node anymore) or not. If yes, the client is still present in the table
+ * to keep the latter consistent with the node TTVN
+ */
+bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
+				       uint8_t *addr)
+{
+	struct batadv_tt_local_entry *tt_local_entry;
+	bool ret = false;
+	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
+	if (!tt_local_entry)
+		goto out;
+	ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
+	batadv_tt_local_entry_free_ref(tt_local_entry);
+out:
+	return ret;
 }
 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
 					  struct batadv_orig_node *orig_node,
 					  const unsigned char *addr)
 {
 	bool ret = false;
 	if (!batadv_tt_global_add(bat_priv, orig_node, addr,

net/batman-adv/translation-table.h

Diff comments View file @ 7c1fd91

 /* Copyright (C) 2007-2012 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
  */
 #ifndef _NET_BATMAN_ADV_TRANSLATION_TABLE_H_
 #define _NET_BATMAN_ADV_TRANSLATION_TABLE_H_
 int batadv_tt_len(int changes_num);
 int batadv_tt_init(struct batadv_priv *bat_priv);
 void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
 			 int ifindex);
 uint16_t batadv_tt_local_remove(struct batadv_priv *bat_priv,
 				const uint8_t *addr, const char *message,
 				bool roaming);
 int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset);
 void batadv_tt_global_add_orig(struct batadv_priv *bat_priv,
 			       struct batadv_orig_node *orig_node,
 			       const unsigned char *tt_buff, int tt_buff_len);
 int batadv_tt_global_add(struct batadv_priv *bat_priv,
 			 struct batadv_orig_node *orig_node,
 			 const unsigned char *addr, uint8_t flags,
 			 uint8_t ttvn);
 int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset);
 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
 			       struct batadv_orig_node *orig_node,
 			       const char *message);
 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
 						  const uint8_t *src,
 						  const uint8_t *addr);
 void batadv_tt_free(struct batadv_priv *bat_priv);
 bool batadv_send_tt_response(struct batadv_priv *bat_priv,
 			     struct batadv_tt_query_packet *tt_request);
 bool batadv_is_my_client(struct batadv_priv *bat_priv, const uint8_t *addr);
 void batadv_handle_tt_response(struct batadv_priv *bat_priv,
 			       struct batadv_tt_query_packet *tt_response);
 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, uint8_t *src,
 			   uint8_t *dst);
 void batadv_tt_update_orig(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node,
 			   const unsigned char *tt_buff, uint8_t tt_num_changes,
 			   uint8_t ttvn, uint16_t tt_crc);
 int batadv_tt_append_diff(struct batadv_priv *bat_priv,
 			  unsigned char **packet_buff, int *packet_buff_len,
 			  int packet_min_len);
 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
 					uint8_t *addr);
+bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
+				       uint8_t *addr);
 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
 					  struct batadv_orig_node *orig_node,
 					  const unsigned char *addr);
 #endif /* _NET_BATMAN_ADV_TRANSLATION_TABLE_H_ */

net/batman-adv/types.h

Diff comments View file @ 7c1fd91

 /* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * 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
  */
 #ifndef _NET_BATMAN_ADV_TYPES_H_
 #define _NET_BATMAN_ADV_TYPES_H_
 #include "packet.h"
 #include "bitarray.h"
 #include <linux/kernel.h>
 #define BATADV_HEADER_LEN \
 	(ETH_HLEN + max(sizeof(struct batadv_unicast_packet), \
 			sizeof(struct batadv_bcast_packet)))
 #ifdef CONFIG_BATMAN_ADV_DAT
 /* batadv_dat_addr_t is the type used for all DHT addresses. If it is changed,
  * BATADV_DAT_ADDR_MAX is changed as well.
  *
  * *Please be careful: batadv_dat_addr_t must be UNSIGNED*
  */
 #define batadv_dat_addr_t uint16_t
 #endif /* CONFIG_BATMAN_ADV_DAT */
 /**
  * struct batadv_hard_iface_bat_iv - per hard interface B.A.T.M.A.N. IV data
  * @ogm_buff: buffer holding the OGM packet
  * @ogm_buff_len: length of the OGM packet buffer
  * @ogm_seqno: OGM sequence number - used to identify each OGM
  */
 struct batadv_hard_iface_bat_iv {
 	unsigned char *ogm_buff;
 	int ogm_buff_len;
 	atomic_t ogm_seqno;
 };
 struct batadv_hard_iface {
 	struct list_head list;
 	int16_t if_num;
 	char if_status;
 	struct net_device *net_dev;
 	atomic_t frag_seqno;
 	struct kobject *hardif_obj;
 	atomic_t refcount;
 	struct packet_type batman_adv_ptype;
 	struct net_device *soft_iface;
 	struct rcu_head rcu;
 	struct batadv_hard_iface_bat_iv bat_iv;
 };
 /**
  *	struct batadv_orig_node - structure for orig_list maintaining nodes of mesh
  *	@primary_addr: hosts primary interface address
  *	@last_seen: when last packet from this node was received
  *	@bcast_seqno_reset: time when the broadcast seqno window was reset
  *	@batman_seqno_reset: time when the batman seqno window was reset
  *	@gw_flags: flags related to gateway class
  *	@flags: for now only VIS_SERVER flag
  *	@last_real_seqno: last and best known sequence number
  *	@last_ttl: ttl of last received packet
  *	@last_bcast_seqno: last broadcast sequence number received by this host
  *
  *	@candidates: how many candidates are available
  *	@selected: next bonding candidate
  */
 struct batadv_orig_node {
 	uint8_t orig[ETH_ALEN];
 	uint8_t primary_addr[ETH_ALEN];
 	struct batadv_neigh_node __rcu *router; /* rcu protected pointer */
 #ifdef CONFIG_BATMAN_ADV_DAT
 	batadv_dat_addr_t dat_addr;
 #endif
 	unsigned long *bcast_own;
 	uint8_t *bcast_own_sum;
 	unsigned long last_seen;
 	unsigned long bcast_seqno_reset;
 	unsigned long batman_seqno_reset;
 	uint8_t gw_flags;
 	uint8_t flags;
 	atomic_t last_ttvn; /* last seen translation table version number */
 	uint16_t tt_crc;
 	unsigned char *tt_buff;
 	int16_t tt_buff_len;
 	spinlock_t tt_buff_lock; /* protects tt_buff */
 	atomic_t tt_size;
 	bool tt_initialised;
-	/* The tt_poss_change flag is used to detect an ongoing roaming phase.
-	 * If true, then I sent a Roaming_adv to this orig_node and I have to
-	 * inspect every packet directed to it to check whether it is still
-	 * the true destination or not. This flag will be reset to false as
-	 * soon as I receive a new TTVN from this orig_node
-	 */
-	bool tt_poss_change;
 	uint32_t last_real_seqno;
 	uint8_t last_ttl;
 	DECLARE_BITMAP(bcast_bits, BATADV_TQ_LOCAL_WINDOW_SIZE);
 	uint32_t last_bcast_seqno;
 	struct hlist_head neigh_list;
 	struct list_head frag_list;
 	spinlock_t neigh_list_lock; /* protects neigh_list and router */
 	atomic_t refcount;
 	struct rcu_head rcu;
 	struct hlist_node hash_entry;
 	struct batadv_priv *bat_priv;
 	unsigned long last_frag_packet;
 	/* ogm_cnt_lock protects: bcast_own, bcast_own_sum,
 	 * neigh_node->real_bits, neigh_node->real_packet_count
 	 */
 	spinlock_t ogm_cnt_lock;
 	/* bcast_seqno_lock protects bcast_bits, last_bcast_seqno */
 	spinlock_t bcast_seqno_lock;
 	spinlock_t tt_list_lock; /* protects tt_list */
 	atomic_t bond_candidates;
 	struct list_head bond_list;
 };
 struct batadv_gw_node {
 	struct hlist_node list;
 	struct batadv_orig_node *orig_node;
 	unsigned long deleted;
 	atomic_t refcount;
 	struct rcu_head rcu;
 };
 /*	batadv_neigh_node
  *	@last_seen: when last packet via this neighbor was received
  */
 struct batadv_neigh_node {
 	struct hlist_node list;
 	uint8_t addr[ETH_ALEN];
 	uint8_t real_packet_count;
 	uint8_t tq_recv[BATADV_TQ_GLOBAL_WINDOW_SIZE];
 	uint8_t tq_index;
 	uint8_t tq_avg;
 	uint8_t last_ttl;
 	struct list_head bonding_list;
 	unsigned long last_seen;
 	DECLARE_BITMAP(real_bits, BATADV_TQ_LOCAL_WINDOW_SIZE);
 	atomic_t refcount;
 	struct rcu_head rcu;
 	struct batadv_orig_node *orig_node;
 	struct batadv_hard_iface *if_incoming;
 	spinlock_t lq_update_lock;	/* protects: tq_recv, tq_index */
 };
 #ifdef CONFIG_BATMAN_ADV_BLA
 struct batadv_bcast_duplist_entry {
 	uint8_t orig[ETH_ALEN];
 	uint16_t crc;
 	unsigned long entrytime;
 };
 #endif
 enum batadv_counters {
 	BATADV_CNT_TX,
 	BATADV_CNT_TX_BYTES,
 	BATADV_CNT_TX_DROPPED,
 	BATADV_CNT_RX,
 	BATADV_CNT_RX_BYTES,
 	BATADV_CNT_FORWARD,
 	BATADV_CNT_FORWARD_BYTES,
 	BATADV_CNT_MGMT_TX,
 	BATADV_CNT_MGMT_TX_BYTES,
 	BATADV_CNT_MGMT_RX,
 	BATADV_CNT_MGMT_RX_BYTES,
 	BATADV_CNT_TT_REQUEST_TX,
 	BATADV_CNT_TT_REQUEST_RX,
 	BATADV_CNT_TT_RESPONSE_TX,
 	BATADV_CNT_TT_RESPONSE_RX,
 	BATADV_CNT_TT_ROAM_ADV_TX,
 	BATADV_CNT_TT_ROAM_ADV_RX,
 #ifdef CONFIG_BATMAN_ADV_DAT
 	BATADV_CNT_DAT_GET_TX,
 	BATADV_CNT_DAT_GET_RX,
 	BATADV_CNT_DAT_PUT_TX,
 	BATADV_CNT_DAT_PUT_RX,
 	BATADV_CNT_DAT_CACHED_REPLY_TX,
 #endif
 	BATADV_CNT_NUM,
 };
 /**
  * struct batadv_priv_tt - per mesh interface translation table data
  * @vn: translation table version number
  * @local_changes: changes registered in an originator interval
  * @poss_change: Detect an ongoing roaming phase. If true, then this node
  *  received a roaming_adv and has to inspect every packet directed to it to
  *  check whether it still is the true destination or not. This flag will be
  *  reset to false as soon as the this node's ttvn is increased
  * @changes_list: tracks tt local changes within an originator interval
  * @req_list: list of pending tt_requests
  * @local_crc: Checksum of the local table, recomputed before sending a new OGM
  */
 struct batadv_priv_tt {
 	atomic_t vn;
 	atomic_t ogm_append_cnt;
 	atomic_t local_changes;
-	bool poss_change;
 	struct list_head changes_list;
 	struct batadv_hashtable *local_hash;
 	struct batadv_hashtable *global_hash;
 	struct list_head req_list;
 	struct list_head roam_list;
 	spinlock_t changes_list_lock; /* protects changes */
 	spinlock_t req_list_lock; /* protects req_list */
 	spinlock_t roam_list_lock; /* protects roam_list */
 	atomic_t local_entry_num;
 	uint16_t local_crc;
 	unsigned char *last_changeset;
 	int16_t last_changeset_len;
 	spinlock_t last_changeset_lock; /* protects last_changeset */
 	struct delayed_work work;
 };
 #ifdef CONFIG_BATMAN_ADV_BLA
 struct batadv_priv_bla {
 	atomic_t num_requests; /* number of bla requests in flight */
 	struct batadv_hashtable *claim_hash;
 	struct batadv_hashtable *backbone_hash;
 	struct batadv_bcast_duplist_entry bcast_duplist[BATADV_DUPLIST_SIZE];
 	int bcast_duplist_curr;
 	/* protects bcast_duplist and bcast_duplist_curr */
 	spinlock_t bcast_duplist_lock;
 	struct batadv_bla_claim_dst claim_dest;
 	struct delayed_work work;
 };
 #endif
 struct batadv_priv_gw {
 	struct hlist_head list;
 	spinlock_t list_lock; /* protects gw_list and curr_gw */
 	struct batadv_gw_node __rcu *curr_gw;  /* rcu protected pointer */
 	atomic_t reselect;
 };
 struct batadv_priv_vis {
 	struct list_head send_list;
 	struct batadv_hashtable *hash;
 	spinlock_t hash_lock; /* protects hash */
 	spinlock_t list_lock; /* protects info::recv_list */
 	struct delayed_work work;
 	struct batadv_vis_info *my_info;
 };
 /**
  * struct batadv_priv_dat - per mesh interface DAT private data
  * @addr: node DAT address
  * @hash: hashtable representing the local ARP cache
  * @work: work queue callback item for cache purging
  */
 #ifdef CONFIG_BATMAN_ADV_DAT
 struct batadv_priv_dat {
 	batadv_dat_addr_t addr;
 	struct batadv_hashtable *hash;
 	struct delayed_work work;
 };
 #endif
 struct batadv_priv {
 	atomic_t mesh_state;
 	struct net_device_stats stats;
 	uint64_t __percpu *bat_counters; /* Per cpu counters */
 	atomic_t aggregated_ogms;	/* boolean */
 	atomic_t bonding;		/* boolean */
 	atomic_t fragmentation;		/* boolean */
 	atomic_t ap_isolation;		/* boolean */
 	atomic_t bridge_loop_avoidance;	/* boolean */
 #ifdef CONFIG_BATMAN_ADV_DAT
 	atomic_t distributed_arp_table;	/* boolean */
 #endif
 	atomic_t vis_mode;		/* VIS_TYPE_* */
 	atomic_t gw_mode;		/* GW_MODE_* */
 	atomic_t gw_sel_class;		/* uint */
 	atomic_t gw_bandwidth;		/* gw bandwidth */
 	atomic_t orig_interval;		/* uint */
 	atomic_t hop_penalty;		/* uint */
 	atomic_t log_level;		/* uint */
 	atomic_t bcast_seqno;
 	atomic_t bcast_queue_left;
 	atomic_t batman_queue_left;
 	char num_ifaces;
 	struct batadv_debug_log *debug_log;
 	struct kobject *mesh_obj;
 	struct dentry *debug_dir;
 	struct hlist_head forw_bat_list;
 	struct hlist_head forw_bcast_list;
 	struct batadv_hashtable *orig_hash;
 	spinlock_t forw_bat_list_lock; /* protects forw_bat_list */
 	spinlock_t forw_bcast_list_lock; /* protects forw_bcast_list */
 	struct delayed_work orig_work;
 	struct batadv_hard_iface __rcu *primary_if;  /* rcu protected pointer */
 	struct batadv_algo_ops *bat_algo_ops;
 #ifdef CONFIG_BATMAN_ADV_BLA
 	struct batadv_priv_bla bla;
 #endif
 	struct batadv_priv_gw gw;
 	struct batadv_priv_tt tt;
 	struct batadv_priv_vis vis;
 #ifdef CONFIG_BATMAN_ADV_DAT
 	struct batadv_priv_dat dat;
 #endif
 };
 struct batadv_socket_client {
 	struct list_head queue_list;
 	unsigned int queue_len;
 	unsigned char index;
 	spinlock_t lock; /* protects queue_list, queue_len, index */
 	wait_queue_head_t queue_wait;
 	struct batadv_priv *bat_priv;
 };
 struct batadv_socket_packet {
 	struct list_head list;
 	size_t icmp_len;
 	struct batadv_icmp_packet_rr icmp_packet;
 };
 struct batadv_tt_common_entry {
 	uint8_t addr[ETH_ALEN];
 	struct hlist_node hash_entry;
 	uint16_t flags;
 	unsigned long added_at;
 	atomic_t refcount;
 	struct rcu_head rcu;
 };
 struct batadv_tt_local_entry {
 	struct batadv_tt_common_entry common;
 	unsigned long last_seen;
 };
 struct batadv_tt_global_entry {
 	struct batadv_tt_common_entry common;
 	struct hlist_head orig_list;
 	spinlock_t list_lock;	/* protects the list */
 	unsigned long roam_at; /* time at which TT_GLOBAL_ROAM was set */
 };
 struct batadv_tt_orig_list_entry {
 	struct batadv_orig_node *orig_node;
 	uint8_t ttvn;
 	atomic_t refcount;
 	struct rcu_head rcu;
 	struct hlist_node list;
 };
 #ifdef CONFIG_BATMAN_ADV_BLA
 struct batadv_backbone_gw {
 	uint8_t orig[ETH_ALEN];
 	short vid;		/* used VLAN ID */
 	struct hlist_node hash_entry;
 	struct batadv_priv *bat_priv;
 	unsigned long lasttime;	/* last time we heard of this backbone gw */
 	atomic_t wait_periods;
 	atomic_t request_sent;
 	atomic_t refcount;
 	struct rcu_head rcu;
 	uint16_t crc;		/* crc checksum over all claims */
 };
 struct batadv_claim {
 	uint8_t addr[ETH_ALEN];
 	short vid;
 	struct batadv_backbone_gw *backbone_gw;
 	unsigned long lasttime;	/* last time we heard of claim (locals only) */
 	struct rcu_head rcu;
 	atomic_t refcount;
 	struct hlist_node hash_entry;
 };
 #endif
 struct batadv_tt_change_node {
 	struct list_head list;
 	struct batadv_tt_change change;
 };
 struct batadv_tt_req_node {
 	uint8_t addr[ETH_ALEN];
 	unsigned long issued_at;
 	struct list_head list;
 };
 struct batadv_tt_roam_node {
 	uint8_t addr[ETH_ALEN];
 	atomic_t counter;
 	unsigned long first_time;
 	struct list_head list;
 };
 /*	forw_packet - structure for forw_list maintaining packets to be
  *	              send/forwarded
  */
 struct batadv_forw_packet {
 	struct hlist_node list;
 	unsigned long send_time;
 	uint8_t own;
 	struct sk_buff *skb;
 	uint16_t packet_len;
 	uint32_t direct_link_flags;
 	uint8_t num_packets;
 	struct delayed_work delayed_work;
 	struct batadv_hard_iface *if_incoming;
 };
 /* While scanning for vis-entries of a particular vis-originator
  * this list collects its interfaces to create a subgraph/cluster
  * out of them later
  */
 struct batadv_if_list_entry {
 	uint8_t addr[ETH_ALEN];
 	bool primary;
 	struct hlist_node list;
 };
 struct batadv_debug_log {
 	char log_buff[BATADV_LOG_BUF_LEN];
 	unsigned long log_start;
 	unsigned long log_end;
 	spinlock_t lock; /* protects log_buff, log_start and log_end */
 	wait_queue_head_t queue_wait;
 };
 struct batadv_frag_packet_list_entry {
 	struct list_head list;
 	uint16_t seqno;
 	struct sk_buff *skb;
 };
 struct batadv_vis_info {
 	unsigned long first_seen;
 	/* list of server-neighbors we received a vis-packet
 	 * from.  we should not reply to them.
 	 */
 	struct list_head recv_list;
 	struct list_head send_list;
 	struct kref refcount;
 	struct hlist_node hash_entry;
 	struct batadv_priv *bat_priv;
 	/* this packet might be part of the vis send queue. */
 	struct sk_buff *skb_packet;
 	/* vis_info may follow here */
 } __packed;
 struct batadv_vis_info_entry {
 	uint8_t  src[ETH_ALEN];
 	uint8_t  dest[ETH_ALEN];
 	uint8_t  quality;	/* quality = 0 client */
 } __packed;
 struct batadv_recvlist_node {
 	struct list_head list;
 	uint8_t mac[ETH_ALEN];
 };
 struct batadv_algo_ops {
 	struct hlist_node list;
 	char *name;
 	/* init routing info when hard-interface is enabled */
 	int (*bat_iface_enable)(struct batadv_hard_iface *hard_iface);
 	/* de-init routing info when hard-interface is disabled */
 	void (*bat_iface_disable)(struct batadv_hard_iface *hard_iface);
 	/* (re-)init mac addresses of the protocol information
 	 * belonging to this hard-interface
 	 */
 	void (*bat_iface_update_mac)(struct batadv_hard_iface *hard_iface);
 	/* called when primary interface is selected / changed */
 	void (*bat_primary_iface_set)(struct batadv_hard_iface *hard_iface);
 	/* prepare a new outgoing OGM for the send queue */
 	void (*bat_ogm_schedule)(struct batadv_hard_iface *hard_iface);
 	/* send scheduled OGM */
 	void (*bat_ogm_emit)(struct batadv_forw_packet *forw_packet);
 };
 /**
  * struct batadv_dat_entry - it is a single entry of batman-adv ARP backend. It
  * is used to stored ARP entries needed for the global DAT cache
  * @ip: the IPv4 corresponding to this DAT/ARP entry
  * @mac_addr: the MAC address associated to the stored IPv4
  * @last_update: time in jiffies when this entry was refreshed last time
  * @hash_entry: hlist node for batadv_priv_dat::hash
  * @refcount: number of contexts the object is used
  * @rcu: struct used for freeing in an RCU-safe manner
  */
 struct batadv_dat_entry {
 	__be32 ip;
 	uint8_t mac_addr[ETH_ALEN];
 	unsigned long last_update;
 	struct hlist_node hash_entry;
 	atomic_t refcount;
 	struct rcu_head rcu;
 };
 /**
  * struct batadv_dat_candidate - candidate destination for DAT operations
  * @type: the type of the selected candidate. It can one of the following:
  *	  - BATADV_DAT_CANDIDATE_NOT_FOUND
  *	  - BATADV_DAT_CANDIDATE_ORIG
  * @orig_node: if type is BATADV_DAT_CANDIDATE_ORIG this field points to the
  *	       corresponding originator node structure
  */
 struct batadv_dat_candidate {
 	int type;
 	struct batadv_orig_node *orig_node;
 };
 #endif /* _NET_BATMAN_ADV_TYPES_H_ */