Eric Lee / smarc-fsl-linux-kernel

Commit 30da63a6af1dbf60e6d989faa4b984b1c6c9dfaf

Authored by Marek Lindner 2012-08-03 23:15:46 +0800

Committed by Antonio Quartulli 2012-10-29 16:42:29 +0800

batman-adv: consolidate duplicated primary_if checking code

Signed-off-by: Marek Lindner <lindner_marek@yahoo.de>
Signed-off-by: Antonio Quartulli <ordex@autistici.org>

Showing 6 changed files with 57 additions and 91 deletions Inline Diff

net/batman-adv/bridge_loop_avoidance.c
net/batman-adv/gateway_client.c
net/batman-adv/main.c
net/batman-adv/main.h
net/batman-adv/originator.c
net/batman-adv/translation-table.c

net/batman-adv/bridge_loop_avoidance.c

Diff comments View file @ 30da63a

 /* Copyright (C) 2011-2012 B.A.T.M.A.N. contributors:
  *
  * 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 "hash.h"
 #include "hard-interface.h"
 #include "originator.h"
 #include "bridge_loop_avoidance.h"
 #include "translation-table.h"
 #include "send.h"
 #include <linux/etherdevice.h>
 #include <linux/crc16.h>
 #include <linux/if_arp.h>
 #include <net/arp.h>
 #include <linux/if_vlan.h>
 static const uint8_t batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
 static void batadv_bla_periodic_work(struct work_struct *work);
 static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
 				     struct batadv_backbone_gw *backbone_gw);
 /* return the index of the claim */
 static inline uint32_t batadv_choose_claim(const void *data, uint32_t size)
 {
 	const unsigned char *key = data;
 	uint32_t hash = 0;
 	size_t i;
 	for (i = 0; i < ETH_ALEN + sizeof(short); i++) {
 		hash += key[i];
 		hash += (hash << 10);
 		hash ^= (hash >> 6);
 	}
 	hash += (hash << 3);
 	hash ^= (hash >> 11);
 	hash += (hash << 15);
 	return hash % size;
 }
 /* return the index of the backbone gateway */
 static inline uint32_t batadv_choose_backbone_gw(const void *data,
 						 uint32_t size)
 {
 	const unsigned char *key = data;
 	uint32_t hash = 0;
 	size_t i;
 	for (i = 0; i < ETH_ALEN + sizeof(short); i++) {
 		hash += key[i];
 		hash += (hash << 10);
 		hash ^= (hash >> 6);
 	}
 	hash += (hash << 3);
 	hash ^= (hash >> 11);
 	hash += (hash << 15);
 	return hash % size;
 }
 /* compares address and vid of two backbone gws */
 static int batadv_compare_backbone_gw(const struct hlist_node *node,
 				      const void *data2)
 {
 	const void *data1 = container_of(node, struct batadv_backbone_gw,
 					 hash_entry);
 	return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0);
 }
 /* compares address and vid of two claims */
 static int batadv_compare_claim(const struct hlist_node *node,
 				const void *data2)
 {
 	const void *data1 = container_of(node, struct batadv_claim,
 					 hash_entry);
 	return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0);
 }
 /* free a backbone gw */
 static void batadv_backbone_gw_free_ref(struct batadv_backbone_gw *backbone_gw)
 {
 	if (atomic_dec_and_test(&backbone_gw->refcount))
 		kfree_rcu(backbone_gw, rcu);
 }
 /* finally deinitialize the claim */
 static void batadv_claim_free_rcu(struct rcu_head *rcu)
 {
 	struct batadv_claim *claim;
 	claim = container_of(rcu, struct batadv_claim, rcu);
 	batadv_backbone_gw_free_ref(claim->backbone_gw);
 	kfree(claim);
 }
 /* free a claim, call claim_free_rcu if its the last reference */
 static void batadv_claim_free_ref(struct batadv_claim *claim)
 {
 	if (atomic_dec_and_test(&claim->refcount))
 		call_rcu(&claim->rcu, batadv_claim_free_rcu);
 }
 /* @bat_priv: the bat priv with all the soft interface information
  * @data: search data (may be local/static data)
  *
  * looks for a claim in the hash, and returns it if found
  * or NULL otherwise.
  */
 static struct batadv_claim *batadv_claim_hash_find(struct batadv_priv *bat_priv,
 						   struct batadv_claim *data)
 {
 	struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
 	struct hlist_head *head;
 	struct hlist_node *node;
 	struct batadv_claim *claim;
 	struct batadv_claim *claim_tmp = NULL;
 	int index;
 	if (!hash)
 		return NULL;
 	index = batadv_choose_claim(data, hash->size);
 	head = &hash->table[index];
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
 		if (!batadv_compare_claim(&claim->hash_entry, data))
 			continue;
 		if (!atomic_inc_not_zero(&claim->refcount))
 			continue;
 		claim_tmp = claim;
 		break;
 	}
 	rcu_read_unlock();
 	return claim_tmp;
 }
 /**
  * batadv_backbone_hash_find - looks for a claim in the hash
  * @bat_priv: the bat priv with all the soft interface information
  * @addr: the address of the originator
  * @vid: the VLAN ID
  *
  * Returns claim if found or NULL otherwise.
  */
 static struct batadv_backbone_gw *
 batadv_backbone_hash_find(struct batadv_priv *bat_priv,
 			  uint8_t *addr, short vid)
 {
 	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
 	struct hlist_head *head;
 	struct hlist_node *node;
 	struct batadv_backbone_gw search_entry, *backbone_gw;
 	struct batadv_backbone_gw *backbone_gw_tmp = NULL;
 	int index;
 	if (!hash)
 		return NULL;
 	memcpy(search_entry.orig, addr, ETH_ALEN);
 	search_entry.vid = vid;
 	index = batadv_choose_backbone_gw(&search_entry, hash->size);
 	head = &hash->table[index];
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
 		if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
 						&search_entry))
 			continue;
 		if (!atomic_inc_not_zero(&backbone_gw->refcount))
 			continue;
 		backbone_gw_tmp = backbone_gw;
 		break;
 	}
 	rcu_read_unlock();
 	return backbone_gw_tmp;
 }
 /* delete all claims for a backbone */
 static void
 batadv_bla_del_backbone_claims(struct batadv_backbone_gw *backbone_gw)
 {
 	struct batadv_hashtable *hash;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	struct batadv_claim *claim;
 	int i;
 	spinlock_t *list_lock;	/* protects write access to the hash lists */
 	hash = backbone_gw->bat_priv->bla.claim_hash;
 	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(claim, node, node_tmp,
 					  head, hash_entry) {
 			if (claim->backbone_gw != backbone_gw)
 				continue;
 			batadv_claim_free_ref(claim);
 			hlist_del_rcu(node);
 		}
 		spin_unlock_bh(list_lock);
 	}
 	/* all claims gone, intialize CRC */
 	backbone_gw->crc = BATADV_BLA_CRC_INIT;
 }
 /**
  * batadv_bla_send_claim - sends a claim frame according to the provided info
  * @bat_priv: the bat priv with all the soft interface information
  * @orig: the mac address to be announced within the claim
  * @vid: the VLAN ID
  * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
  */
 static void batadv_bla_send_claim(struct batadv_priv *bat_priv, uint8_t *mac,
 				  short vid, int claimtype)
 {
 	struct sk_buff *skb;
 	struct ethhdr *ethhdr;
 	struct batadv_hard_iface *primary_if;
 	struct net_device *soft_iface;
 	uint8_t *hw_src;
 	struct batadv_bla_claim_dst local_claim_dest;
 	__be32 zeroip = 0;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		return;
 	memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
 	       sizeof(local_claim_dest));
 	local_claim_dest.type = claimtype;
 	soft_iface = primary_if->soft_iface;
 	skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
 			 /* IP DST: 0.0.0.0 */
 			 zeroip,
 			 primary_if->soft_iface,
 			 /* IP SRC: 0.0.0.0 */
 			 zeroip,
 			 /* Ethernet DST: Broadcast */
 			 NULL,
 			 /* Ethernet SRC/HW SRC:  originator mac */
 			 primary_if->net_dev->dev_addr,
 			 /* HW DST: FF:43:05:XX:YY:YY
 			  * with XX   = claim type
 			  * and YY:YY = group id
 			  */
 			 (uint8_t *)&local_claim_dest);
 	if (!skb)
 		goto out;
 	ethhdr = (struct ethhdr *)skb->data;
 	hw_src = (uint8_t *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
 	/* now we pretend that the client would have sent this ... */
 	switch (claimtype) {
 	case BATADV_CLAIM_TYPE_CLAIM:
 		/* normal claim frame
 		 * set Ethernet SRC to the clients mac
 		 */
 		memcpy(ethhdr->h_source, mac, ETH_ALEN);
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid);
 		break;
 	case BATADV_CLAIM_TYPE_UNCLAIM:
 		/* unclaim frame
 		 * set HW SRC to the clients mac
 		 */
 		memcpy(hw_src, mac, ETH_ALEN);
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_send_claim(): UNCLAIM %pM on vid %d\n", mac,
 			   vid);
 		break;
 	case BATADV_CLAIM_TYPE_ANNOUNCE:
 		/* announcement frame
 		 * set HW SRC to the special mac containg the crc
 		 */
 		memcpy(hw_src, mac, ETH_ALEN);
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
 			   ethhdr->h_source, vid);
 		break;
 	case BATADV_CLAIM_TYPE_REQUEST:
 		/* request frame
 		 * set HW SRC and header destination to the receiving backbone
 		 * gws mac
 		 */
 		memcpy(hw_src, mac, ETH_ALEN);
 		memcpy(ethhdr->h_dest, mac, ETH_ALEN);
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",
 			   ethhdr->h_source, ethhdr->h_dest, vid);
 		break;
 	}
 	if (vid != -1)
 		skb = vlan_insert_tag(skb, vid);
 	skb_reset_mac_header(skb);
 	skb->protocol = eth_type_trans(skb, soft_iface);
 	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;
 	netif_rx(skb);
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 }
 /**
  * batadv_bla_get_backbone_gw
  * @bat_priv: the bat priv with all the soft interface information
  * @orig: the mac address of the originator
  * @vid: the VLAN ID
  *
  * searches for the backbone gw or creates a new one if it could not
  * be found.
  */
 static struct batadv_backbone_gw *
 batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, uint8_t *orig,
 			   short vid)
 {
 	struct batadv_backbone_gw *entry;
 	struct batadv_orig_node *orig_node;
 	int hash_added;
 	entry = batadv_backbone_hash_find(bat_priv, orig, vid);
 	if (entry)
 		return entry;
 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
 		   "bla_get_backbone_gw(): not found (%pM, %d), creating new entry\n",
 		   orig, vid);
 	entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 	if (!entry)
 		return NULL;
 	entry->vid = vid;
 	entry->lasttime = jiffies;
 	entry->crc = BATADV_BLA_CRC_INIT;
 	entry->bat_priv = bat_priv;
 	atomic_set(&entry->request_sent, 0);
 	memcpy(entry->orig, orig, ETH_ALEN);
 	/* one for the hash, one for returning */
 	atomic_set(&entry->refcount, 2);
 	hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
 				     batadv_compare_backbone_gw,
 				     batadv_choose_backbone_gw, entry,
 				     &entry->hash_entry);
 	if (unlikely(hash_added != 0)) {
 		/* hash failed, free the structure */
 		kfree(entry);
 		return NULL;
 	}
 	/* this is a gateway now, remove any tt entries */
 	orig_node = batadv_orig_hash_find(bat_priv, orig);
 	if (orig_node) {
 		batadv_tt_global_del_orig(bat_priv, orig_node,
 					  "became a backbone gateway");
 		batadv_orig_node_free_ref(orig_node);
 	}
 	return entry;
 }
 /* update or add the own backbone gw to make sure we announce
  * where we receive other backbone gws
  */
 static void
 batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
 				  struct batadv_hard_iface *primary_if,
 				  short vid)
 {
 	struct batadv_backbone_gw *backbone_gw;
 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
 						 primary_if->net_dev->dev_addr,
 						 vid);
 	if (unlikely(!backbone_gw))
 		return;
 	backbone_gw->lasttime = jiffies;
 	batadv_backbone_gw_free_ref(backbone_gw);
 }
 /* @bat_priv: the bat priv with all the soft interface information
  * @vid: the vid where the request came on
  *
  * Repeat all of our own claims, and finally send an ANNOUNCE frame
  * to allow the requester another check if the CRC is correct now.
  */
 static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
 				      struct batadv_hard_iface *primary_if,
 				      short vid)
 {
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct batadv_hashtable *hash;
 	struct batadv_claim *claim;
 	struct batadv_backbone_gw *backbone_gw;
 	int i;
 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
 		   "bla_answer_request(): received a claim request, send all of our own claims again\n");
 	backbone_gw = batadv_backbone_hash_find(bat_priv,
 						primary_if->net_dev->dev_addr,
 						vid);
 	if (!backbone_gw)
 		return;
 	hash = bat_priv->bla.claim_hash;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
 			/* only own claims are interesting */
 			if (claim->backbone_gw != backbone_gw)
 				continue;
 			batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
 					      BATADV_CLAIM_TYPE_CLAIM);
 		}
 		rcu_read_unlock();
 	}
 	/* finally, send an announcement frame */
 	batadv_bla_send_announce(bat_priv, backbone_gw);
 	batadv_backbone_gw_free_ref(backbone_gw);
 }
 /* @backbone_gw: the backbone gateway from whom we are out of sync
  *
  * When the crc is wrong, ask the backbone gateway for a full table update.
  * After the request, it will repeat all of his own claims and finally
  * send an announcement claim with which we can check again.
  */
 static void batadv_bla_send_request(struct batadv_backbone_gw *backbone_gw)
 {
 	/* first, remove all old entries */
 	batadv_bla_del_backbone_claims(backbone_gw);
 	batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 		   "Sending REQUEST to %pM\n", backbone_gw->orig);
 	/* send request */
 	batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
 			      backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
 	/* no local broadcasts should be sent or received, for now. */
 	if (!atomic_read(&backbone_gw->request_sent)) {
 		atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
 		atomic_set(&backbone_gw->request_sent, 1);
 	}
 }
 /* @bat_priv: the bat priv with all the soft interface information
  * @backbone_gw: our backbone gateway which should be announced
  *
  * This function sends an announcement. It is called from multiple
  * places.
  */
 static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
 				     struct batadv_backbone_gw *backbone_gw)
 {
 	uint8_t mac[ETH_ALEN];
 	__be16 crc;
 	memcpy(mac, batadv_announce_mac, 4);
 	crc = htons(backbone_gw->crc);
 	memcpy(&mac[4], &crc, 2);
 	batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
 			      BATADV_CLAIM_TYPE_ANNOUNCE);
 }
 /**
  * batadv_bla_add_claim - Adds a claim in the claim hash
  * @bat_priv: the bat priv with all the soft interface information
  * @mac: the mac address of the claim
  * @vid: the VLAN ID of the frame
  * @backbone_gw: the backbone gateway which claims it
  */
 static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
 				 const uint8_t *mac, const short vid,
 				 struct batadv_backbone_gw *backbone_gw)
 {
 	struct batadv_claim *claim;
 	struct batadv_claim search_claim;
 	int hash_added;
 	memcpy(search_claim.addr, mac, ETH_ALEN);
 	search_claim.vid = vid;
 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
 	/* create a new claim entry if it does not exist yet. */
 	if (!claim) {
 		claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
 		if (!claim)
 			return;
 		memcpy(claim->addr, mac, ETH_ALEN);
 		claim->vid = vid;
 		claim->lasttime = jiffies;
 		claim->backbone_gw = backbone_gw;
 		atomic_set(&claim->refcount, 2);
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
 			   mac, vid);
 		hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
 					     batadv_compare_claim,
 					     batadv_choose_claim, claim,
 					     &claim->hash_entry);
 		if (unlikely(hash_added != 0)) {
 			/* only local changes happened. */
 			kfree(claim);
 			return;
 		}
 	} else {
 		claim->lasttime = jiffies;
 		if (claim->backbone_gw == backbone_gw)
 			/* no need to register a new backbone */
 			goto claim_free_ref;
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_add_claim(): changing ownership for %pM, vid %d\n",
 			   mac, vid);
 		claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 		batadv_backbone_gw_free_ref(claim->backbone_gw);
 	}
 	/* set (new) backbone gw */
 	atomic_inc(&backbone_gw->refcount);
 	claim->backbone_gw = backbone_gw;
 	backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 	backbone_gw->lasttime = jiffies;
 claim_free_ref:
 	batadv_claim_free_ref(claim);
 }
 /* Delete a claim from the claim hash which has the
  * given mac address and vid.
  */
 static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
 				 const uint8_t *mac, const short vid)
 {
 	struct batadv_claim search_claim, *claim;
 	memcpy(search_claim.addr, mac, ETH_ALEN);
 	search_claim.vid = vid;
 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
 	if (!claim)
 		return;
 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n",
 		   mac, vid);
 	batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim,
 			   batadv_choose_claim, claim);
 	batadv_claim_free_ref(claim); /* reference from the hash is gone */
 	claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 	/* don't need the reference from hash_find() anymore */
 	batadv_claim_free_ref(claim);
 }
 /* check for ANNOUNCE frame, return 1 if handled */
 static int batadv_handle_announce(struct batadv_priv *bat_priv,
 				  uint8_t *an_addr, uint8_t *backbone_addr,
 				  short vid)
 {
 	struct batadv_backbone_gw *backbone_gw;
 	uint16_t crc;
 	if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
 		return 0;
 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid);
 	if (unlikely(!backbone_gw))
 		return 1;
 	/* handle as ANNOUNCE frame */
 	backbone_gw->lasttime = jiffies;
 	crc = ntohs(*((__be16 *)(&an_addr[4])));
 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
 		   "handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %04x\n",
 		   vid, backbone_gw->orig, crc);
 	if (backbone_gw->crc != crc) {
 		batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 			   "handle_announce(): CRC FAILED for %pM/%d (my = %04x, sent = %04x)\n",
 			   backbone_gw->orig, backbone_gw->vid,
 			   backbone_gw->crc, crc);
 		batadv_bla_send_request(backbone_gw);
 	} else {
 		/* if we have sent a request and the crc was OK,
 		 * we can allow traffic again.
 		 */
 		if (atomic_read(&backbone_gw->request_sent)) {
 			atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
 			atomic_set(&backbone_gw->request_sent, 0);
 		}
 	}
 	batadv_backbone_gw_free_ref(backbone_gw);
 	return 1;
 }
 /* check for REQUEST frame, return 1 if handled */
 static int batadv_handle_request(struct batadv_priv *bat_priv,
 				 struct batadv_hard_iface *primary_if,
 				 uint8_t *backbone_addr,
 				 struct ethhdr *ethhdr, short vid)
 {
 	/* check for REQUEST frame */
 	if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
 		return 0;
 	/* sanity check, this should not happen on a normal switch,
 	 * we ignore it in this case.
 	 */
 	if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
 		return 1;
 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
 		   "handle_request(): REQUEST vid %d (sent by %pM)...\n",
 		   vid, ethhdr->h_source);
 	batadv_bla_answer_request(bat_priv, primary_if, vid);
 	return 1;
 }
 /* check for UNCLAIM frame, return 1 if handled */
 static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
 				 struct batadv_hard_iface *primary_if,
 				 uint8_t *backbone_addr,
 				 uint8_t *claim_addr, short vid)
 {
 	struct batadv_backbone_gw *backbone_gw;
 	/* unclaim in any case if it is our own */
 	if (primary_if && batadv_compare_eth(backbone_addr,
 					     primary_if->net_dev->dev_addr))
 		batadv_bla_send_claim(bat_priv, claim_addr, vid,
 				      BATADV_CLAIM_TYPE_UNCLAIM);
 	backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
 	if (!backbone_gw)
 		return 1;
 	/* this must be an UNCLAIM frame */
 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
 		   "handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
 		   claim_addr, vid, backbone_gw->orig);
 	batadv_bla_del_claim(bat_priv, claim_addr, vid);
 	batadv_backbone_gw_free_ref(backbone_gw);
 	return 1;
 }
 /* check for CLAIM frame, return 1 if handled */
 static int batadv_handle_claim(struct batadv_priv *bat_priv,
 			       struct batadv_hard_iface *primary_if,
 			       uint8_t *backbone_addr, uint8_t *claim_addr,
 			       short vid)
 {
 	struct batadv_backbone_gw *backbone_gw;
 	/* register the gateway if not yet available, and add the claim. */
 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid);
 	if (unlikely(!backbone_gw))
 		return 1;
 	/* this must be a CLAIM frame */
 	batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
 	if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
 		batadv_bla_send_claim(bat_priv, claim_addr, vid,
 				      BATADV_CLAIM_TYPE_CLAIM);
 	/* TODO: we could call something like tt_local_del() here. */
 	batadv_backbone_gw_free_ref(backbone_gw);
 	return 1;
 }
 /**
  * batadv_check_claim_group
  * @bat_priv: the bat priv with all the soft interface information
  * @hw_src: the Hardware source in the ARP Header
  * @hw_dst: the Hardware destination in the ARP Header
  * @ethhdr: pointer to the Ethernet header of the claim frame
  *
  * checks if it is a claim packet and if its on the same group.
  * This function also applies the group ID of the sender
  * if it is in the same mesh.
  *
  * returns:
  *	2  - if it is a claim packet and on the same group
  *	1  - if is a claim packet from another group
  *	0  - if it is not a claim packet
  */
 static int batadv_check_claim_group(struct batadv_priv *bat_priv,
 				    struct batadv_hard_iface *primary_if,
 				    uint8_t *hw_src, uint8_t *hw_dst,
 				    struct ethhdr *ethhdr)
 {
 	uint8_t *backbone_addr;
 	struct batadv_orig_node *orig_node;
 	struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
 	bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
 	bla_dst_own = &bat_priv->bla.claim_dest;
 	/* check if it is a claim packet in general */
 	if (memcmp(bla_dst->magic, bla_dst_own->magic,
 		   sizeof(bla_dst->magic)) != 0)
 		return 0;
 	/* if announcement packet, use the source,
 	 * otherwise assume it is in the hw_src
 	 */
 	switch (bla_dst->type) {
 	case BATADV_CLAIM_TYPE_CLAIM:
 		backbone_addr = hw_src;
 		break;
 	case BATADV_CLAIM_TYPE_REQUEST:
 	case BATADV_CLAIM_TYPE_ANNOUNCE:
 	case BATADV_CLAIM_TYPE_UNCLAIM:
 		backbone_addr = ethhdr->h_source;
 		break;
 	default:
 		return 0;
 	}
 	/* don't accept claim frames from ourselves */
 	if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
 		return 0;
 	/* if its already the same group, it is fine. */
 	if (bla_dst->group == bla_dst_own->group)
 		return 2;
 	/* lets see if this originator is in our mesh */
 	orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
 	/* dont accept claims from gateways which are not in
 	 * the same mesh or group.
 	 */
 	if (!orig_node)
 		return 1;
 	/* if our mesh friends mac is bigger, use it for ourselves. */
 	if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "taking other backbones claim group: %04x\n",
 			   ntohs(bla_dst->group));
 		bla_dst_own->group = bla_dst->group;
 	}
 	batadv_orig_node_free_ref(orig_node);
 	return 2;
 }
 /* @bat_priv: the bat priv with all the soft interface information
  * @skb: the frame to be checked
  *
  * Check if this is a claim frame, and process it accordingly.
  *
  * returns 1 if it was a claim frame, otherwise return 0 to
  * tell the callee that it can use the frame on its own.
  */
 static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
 				    struct batadv_hard_iface *primary_if,
 				    struct sk_buff *skb)
 {
 	struct ethhdr *ethhdr;
 	struct vlan_ethhdr *vhdr;
 	struct arphdr *arphdr;
 	uint8_t *hw_src, *hw_dst;
 	struct batadv_bla_claim_dst *bla_dst;
 	uint16_t proto;
 	int headlen;
 	short vid = -1;
 	int ret;
 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 	if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
 		vhdr = (struct vlan_ethhdr *)ethhdr;
 		vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
 		proto = ntohs(vhdr->h_vlan_encapsulated_proto);
 		headlen = sizeof(*vhdr);
 	} else {
 		proto = ntohs(ethhdr->h_proto);
 		headlen = ETH_HLEN;
 	}
 	if (proto != ETH_P_ARP)
 		return 0; /* not a claim frame */
 	/* this must be a ARP frame. check if it is a claim. */
 	if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
 		return 0;
 	/* pskb_may_pull() may have modified the pointers, get ethhdr again */
 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 	arphdr = (struct arphdr *)((uint8_t *)ethhdr + headlen);
 	/* Check whether the ARP frame carries a valid
 	 * IP information
 	 */
 	if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
 		return 0;
 	if (arphdr->ar_pro != htons(ETH_P_IP))
 		return 0;
 	if (arphdr->ar_hln != ETH_ALEN)
 		return 0;
 	if (arphdr->ar_pln != 4)
 		return 0;
 	hw_src = (uint8_t *)arphdr + sizeof(struct arphdr);
 	hw_dst = hw_src + ETH_ALEN + 4;
 	bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
 	/* check if it is a claim frame. */
 	ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
 				       ethhdr);
 	if (ret == 1)
 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 			   "bla_process_claim(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
 			   ethhdr->h_source, vid, hw_src, hw_dst);
 	if (ret < 2)
 		return ret;
 	/* become a backbone gw ourselves on this vlan if not happened yet */
 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
 	/* check for the different types of claim frames ... */
 	switch (bla_dst->type) {
 	case BATADV_CLAIM_TYPE_CLAIM:
 		if (batadv_handle_claim(bat_priv, primary_if, hw_src,
 					ethhdr->h_source, vid))
 			return 1;
 		break;
 	case BATADV_CLAIM_TYPE_UNCLAIM:
 		if (batadv_handle_unclaim(bat_priv, primary_if,
 					  ethhdr->h_source, hw_src, vid))
 			return 1;
 		break;
 	case BATADV_CLAIM_TYPE_ANNOUNCE:
 		if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
 					   vid))
 			return 1;
 		break;
 	case BATADV_CLAIM_TYPE_REQUEST:
 		if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
 					  vid))
 			return 1;
 		break;
 	}
 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
 		   "bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
 		   ethhdr->h_source, vid, hw_src, hw_dst);
 	return 1;
 }
 /* Check when we last heard from other nodes, and remove them in case of
  * a time out, or clean all backbone gws if now is set.
  */
 static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
 {
 	struct batadv_backbone_gw *backbone_gw;
 	struct hlist_node *node, *node_tmp;
 	struct hlist_head *head;
 	struct batadv_hashtable *hash;
 	spinlock_t *list_lock;	/* protects write access to the hash lists */
 	int i;
 	hash = bat_priv->bla.backbone_hash;
 	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(backbone_gw, node, node_tmp,
 					  head, hash_entry) {
 			if (now)
 				goto purge_now;
 			if (!batadv_has_timed_out(backbone_gw->lasttime,
 						  BATADV_BLA_BACKBONE_TIMEOUT))
 				continue;
 			batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 				   "bla_purge_backbone_gw(): backbone gw %pM timed out\n",
 				   backbone_gw->orig);
 purge_now:
 			/* don't wait for the pending request anymore */
 			if (atomic_read(&backbone_gw->request_sent))
 				atomic_dec(&bat_priv->bla.num_requests);
 			batadv_bla_del_backbone_claims(backbone_gw);
 			hlist_del_rcu(node);
 			batadv_backbone_gw_free_ref(backbone_gw);
 		}
 		spin_unlock_bh(list_lock);
 	}
 }
 /**
  * batadv_bla_purge_claims
  * @bat_priv: the bat priv with all the soft interface information
  * @primary_if: the selected primary interface, may be NULL if now is set
  * @now: whether the whole hash shall be wiped now
  *
  * Check when we heard last time from our own claims, and remove them in case of
  * a time out, or clean all claims if now is set
  */
 static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
 				    struct batadv_hard_iface *primary_if,
 				    int now)
 {
 	struct batadv_claim *claim;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct batadv_hashtable *hash;
 	int i;
 	hash = bat_priv->bla.claim_hash;
 	if (!hash)
 		return;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
 			if (now)
 				goto purge_now;
 			if (!batadv_compare_eth(claim->backbone_gw->orig,
 						primary_if->net_dev->dev_addr))
 				continue;
 			if (!batadv_has_timed_out(claim->lasttime,
 						  BATADV_BLA_CLAIM_TIMEOUT))
 				continue;
 			batadv_dbg(BATADV_DBG_BLA, bat_priv,
 				   "bla_purge_claims(): %pM, vid %d, time out\n",
 				   claim->addr, claim->vid);
 purge_now:
 			batadv_handle_unclaim(bat_priv, primary_if,
 					      claim->backbone_gw->orig,
 					      claim->addr, claim->vid);
 		}
 		rcu_read_unlock();
 	}
 }
 /**
  * batadv_bla_update_orig_address
  * @bat_priv: the bat priv with all the soft interface information
  * @primary_if: the new selected primary_if
  * @oldif: the old primary interface, may be NULL
  *
  * Update the backbone gateways when the own orig address changes.
  */
 void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
 				    struct batadv_hard_iface *primary_if,
 				    struct batadv_hard_iface *oldif)
 {
 	struct batadv_backbone_gw *backbone_gw;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct batadv_hashtable *hash;
 	__be16 group;
 	int i;
 	/* reset bridge loop avoidance group id */
 	group = htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
 	bat_priv->bla.claim_dest.group = group;
 	if (!oldif) {
 		batadv_bla_purge_claims(bat_priv, NULL, 1);
 		batadv_bla_purge_backbone_gw(bat_priv, 1);
 		return;
 	}
 	hash = bat_priv->bla.backbone_hash;
 	if (!hash)
 		return;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
 			/* own orig still holds the old value. */
 			if (!batadv_compare_eth(backbone_gw->orig,
 						oldif->net_dev->dev_addr))
 				continue;
 			memcpy(backbone_gw->orig,
 			       primary_if->net_dev->dev_addr, ETH_ALEN);
 			/* send an announce frame so others will ask for our
 			 * claims and update their tables.
 			 */
 			batadv_bla_send_announce(bat_priv, backbone_gw);
 		}
 		rcu_read_unlock();
 	}
 }
 /* (re)start the timer */
 static void batadv_bla_start_timer(struct batadv_priv *bat_priv)
 {
 	INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
 	queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
 			   msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
 }
 /* periodic work to do:
  *  * purge structures when they are too old
  *  * send announcements
  */
 static void batadv_bla_periodic_work(struct work_struct *work)
 {
 	struct delayed_work *delayed_work;
 	struct batadv_priv *bat_priv;
 	struct batadv_priv_bla *priv_bla;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	struct batadv_backbone_gw *backbone_gw;
 	struct batadv_hashtable *hash;
 	struct batadv_hard_iface *primary_if;
 	int i;
 	delayed_work = container_of(work, struct delayed_work, work);
 	priv_bla = container_of(delayed_work, struct batadv_priv_bla, work);
 	bat_priv = container_of(priv_bla, struct batadv_priv, bla);
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	batadv_bla_purge_claims(bat_priv, primary_if, 0);
 	batadv_bla_purge_backbone_gw(bat_priv, 0);
 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
 		goto out;
 	hash = bat_priv->bla.backbone_hash;
 	if (!hash)
 		goto out;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
 			if (!batadv_compare_eth(backbone_gw->orig,
 						primary_if->net_dev->dev_addr))
 				continue;
 			backbone_gw->lasttime = jiffies;
 			batadv_bla_send_announce(bat_priv, backbone_gw);
 		}
 		rcu_read_unlock();
 	}
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	batadv_bla_start_timer(bat_priv);
 }
 /* The hash for claim and backbone hash receive the same key because they
  * are getting initialized by hash_new with the same key. Reinitializing
  * them with to different keys to allow nested locking without generating
  * lockdep warnings
  */
 static struct lock_class_key batadv_claim_hash_lock_class_key;
 static struct lock_class_key batadv_backbone_hash_lock_class_key;
 /* initialize all bla structures */
 int batadv_bla_init(struct batadv_priv *bat_priv)
 {
 	int i;
 	uint8_t claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
 	struct batadv_hard_iface *primary_if;
 	uint16_t crc;
 	unsigned long entrytime;
 	spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
 	/* setting claim destination address */
 	memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
 	bat_priv->bla.claim_dest.type = 0;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (primary_if) {
 		crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
 		bat_priv->bla.claim_dest.group = htons(crc);
 		batadv_hardif_free_ref(primary_if);
 	} else {
 		bat_priv->bla.claim_dest.group = 0; /* will be set later */
 	}
 	/* initialize the duplicate list */
 	entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
 	for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
 		bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
 	bat_priv->bla.bcast_duplist_curr = 0;
 	if (bat_priv->bla.claim_hash)
 		return 0;
 	bat_priv->bla.claim_hash = batadv_hash_new(128);
 	bat_priv->bla.backbone_hash = batadv_hash_new(32);
 	if (!bat_priv->bla.claim_hash || !bat_priv->bla.backbone_hash)
 		return -ENOMEM;
 	batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
 				   &batadv_claim_hash_lock_class_key);
 	batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
 				   &batadv_backbone_hash_lock_class_key);
 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
 	batadv_bla_start_timer(bat_priv);
 	return 0;
 }
 /**
  * batadv_bla_check_bcast_duplist
  * @bat_priv: the bat priv with all the soft interface information
  * @bcast_packet: encapsulated broadcast frame plus batman header
  * @bcast_packet_len: length of encapsulated broadcast frame plus batman header
  *
  * check if it is on our broadcast list. Another gateway might
  * have sent the same packet because it is connected to the same backbone,
  * so we have to remove this duplicate.
  *
  * This is performed by checking the CRC, which will tell us
  * with a good chance that it is the same packet. If it is furthermore
  * sent by another host, drop it. We allow equal packets from
  * the same host however as this might be intended.
  */
 int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
 				   struct batadv_bcast_packet *bcast_packet,
 				   int bcast_packet_len)
 {
 	int i, length, curr, ret = 0;
 	uint8_t *content;
 	uint16_t crc;
 	struct batadv_bcast_duplist_entry *entry;
 	length = bcast_packet_len - sizeof(*bcast_packet);
 	content = (uint8_t *)bcast_packet;
 	content += sizeof(*bcast_packet);
 	/* calculate the crc ... */
 	crc = crc16(0, content, length);
 	spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
 	for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
 		curr = (bat_priv->bla.bcast_duplist_curr + i);
 		curr %= BATADV_DUPLIST_SIZE;
 		entry = &bat_priv->bla.bcast_duplist[curr];
 		/* we can stop searching if the entry is too old ;
 		 * later entries will be even older
 		 */
 		if (batadv_has_timed_out(entry->entrytime,
 					 BATADV_DUPLIST_TIMEOUT))
 			break;
 		if (entry->crc != crc)
 			continue;
 		if (batadv_compare_eth(entry->orig, bcast_packet->orig))
 			continue;
 		/* this entry seems to match: same crc, not too old,
 		 * and from another gw. therefore return 1 to forbid it.
 		 */
 		ret = 1;
 		goto out;
 	}
 	/* not found, add a new entry (overwrite the oldest entry)
 	 * and allow it, its the first occurence.
 	 */
 	curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
 	curr %= BATADV_DUPLIST_SIZE;
 	entry = &bat_priv->bla.bcast_duplist[curr];
 	entry->crc = crc;
 	entry->entrytime = jiffies;
 	memcpy(entry->orig, bcast_packet->orig, ETH_ALEN);
 	bat_priv->bla.bcast_duplist_curr = curr;
 out:
 	spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
 	return ret;
 }
 /* @bat_priv: the bat priv with all the soft interface information
  * @orig: originator mac address
  *
  * check if the originator is a gateway for any VLAN ID.
  *
  * returns 1 if it is found, 0 otherwise
  */
 int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig)
 {
 	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
 	struct hlist_head *head;
 	struct hlist_node *node;
 	struct batadv_backbone_gw *backbone_gw;
 	int i;
 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
 		return 0;
 	if (!hash)
 		return 0;
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
 			if (batadv_compare_eth(backbone_gw->orig, orig)) {
 				rcu_read_unlock();
 				return 1;
 			}
 		}
 		rcu_read_unlock();
 	}
 	return 0;
 }
 /**
  * batadv_bla_is_backbone_gw
  * @skb: the frame to be checked
  * @orig_node: the orig_node of the frame
  * @hdr_size: maximum length of the frame
  *
  * bla_is_backbone_gw inspects the skb for the VLAN ID and returns 1
  * if the orig_node is also a gateway on the soft interface, otherwise it
  * returns 0.
  */
 int batadv_bla_is_backbone_gw(struct sk_buff *skb,
 			      struct batadv_orig_node *orig_node, int hdr_size)
 {
 	struct ethhdr *ethhdr;
 	struct vlan_ethhdr *vhdr;
 	struct batadv_backbone_gw *backbone_gw;
 	short vid = -1;
 	if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
 		return 0;
 	/* first, find out the vid. */
 	if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
 		return 0;
 	ethhdr = (struct ethhdr *)(((uint8_t *)skb->data) + hdr_size);
 	if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
 		if (!pskb_may_pull(skb, hdr_size + sizeof(struct vlan_ethhdr)))
 			return 0;
 		vhdr = (struct vlan_ethhdr *)(skb->data + hdr_size);
 		vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
 	}
 	/* see if this originator is a backbone gw for this VLAN */
 	backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
 						orig_node->orig, vid);
 	if (!backbone_gw)
 		return 0;
 	batadv_backbone_gw_free_ref(backbone_gw);
 	return 1;
 }
 /* free all bla structures (for softinterface free or module unload) */
 void batadv_bla_free(struct batadv_priv *bat_priv)
 {
 	struct batadv_hard_iface *primary_if;
 	cancel_delayed_work_sync(&bat_priv->bla.work);
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (bat_priv->bla.claim_hash) {
 		batadv_bla_purge_claims(bat_priv, primary_if, 1);
 		batadv_hash_destroy(bat_priv->bla.claim_hash);
 		bat_priv->bla.claim_hash = NULL;
 	}
 	if (bat_priv->bla.backbone_hash) {
 		batadv_bla_purge_backbone_gw(bat_priv, 1);
 		batadv_hash_destroy(bat_priv->bla.backbone_hash);
 		bat_priv->bla.backbone_hash = NULL;
 	}
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 }
 /**
  * batadv_bla_rx
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: the frame to be checked
  * @vid: the VLAN ID of the frame
  * @is_bcast: the packet came in a broadcast packet type.
  *
  * bla_rx avoidance checks if:
  *  * we have to race for a claim
  *  * if the frame is allowed on the LAN
  *
  * in these cases, the skb is further handled by this function and
  * returns 1, otherwise it returns 0 and the caller shall further
  * process the skb.
  */
 int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid,
 		  bool is_bcast)
 {
 	struct ethhdr *ethhdr;
 	struct batadv_claim search_claim, *claim = NULL;
 	struct batadv_hard_iface *primary_if;
 	int ret;
 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto handled;
 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
 		goto allow;
 	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
 		/* don't allow broadcasts while requests are in flight */
 		if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast)
 			goto handled;
 	memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN);
 	search_claim.vid = vid;
 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
 	if (!claim) {
 		/* possible optimization: race for a claim */
 		/* No claim exists yet, claim it for us!
 		 */
 		batadv_handle_claim(bat_priv, primary_if,
 				    primary_if->net_dev->dev_addr,
 				    ethhdr->h_source, vid);
 		goto allow;
 	}
 	/* if it is our own claim ... */
 	if (batadv_compare_eth(claim->backbone_gw->orig,
 			       primary_if->net_dev->dev_addr)) {
 		/* ... allow it in any case */
 		claim->lasttime = jiffies;
 		goto allow;
 	}
 	/* if it is a broadcast ... */
 	if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast) {
 		/* ... drop it. the responsible gateway is in charge.
 		 *
 		 * We need to check is_bcast because with the gateway
 		 * feature, broadcasts (like DHCP requests) may be sent
 		 * using a unicast packet type.
 		 */
 		goto handled;
 	} else {
 		/* seems the client considers us as its best gateway.
 		 * send a claim and update the claim table
 		 * immediately.
 		 */
 		batadv_handle_claim(bat_priv, primary_if,
 				    primary_if->net_dev->dev_addr,
 				    ethhdr->h_source, vid);
 		goto allow;
 	}
 allow:
 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
 	ret = 0;
 	goto out;
 handled:
 	kfree_skb(skb);
 	ret = 1;
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	if (claim)
 		batadv_claim_free_ref(claim);
 	return ret;
 }
 /**
  * batadv_bla_tx
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: the frame to be checked
  * @vid: the VLAN ID of the frame
  *
  * bla_tx checks if:
  *  * a claim was received which has to be processed
  *  * the frame is allowed on the mesh
  *
  * in these cases, the skb is further handled by this function and
  * returns 1, otherwise it returns 0 and the caller shall further
  * process the skb.
  */
 int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid)
 {
 	struct ethhdr *ethhdr;
 	struct batadv_claim search_claim, *claim = NULL;
 	struct batadv_hard_iface *primary_if;
 	int ret = 0;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
 		goto allow;
 	/* in VLAN case, the mac header might not be set. */
 	skb_reset_mac_header(skb);
 	if (batadv_bla_process_claim(bat_priv, primary_if, skb))
 		goto handled;
 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
 		/* don't allow broadcasts while requests are in flight */
 		if (is_multicast_ether_addr(ethhdr->h_dest))
 			goto handled;
 	memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN);
 	search_claim.vid = vid;
 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
 	/* if no claim exists, allow it. */
 	if (!claim)
 		goto allow;
 	/* check if we are responsible. */
 	if (batadv_compare_eth(claim->backbone_gw->orig,
 			       primary_if->net_dev->dev_addr)) {
 		/* if yes, the client has roamed and we have
 		 * to unclaim it.
 		 */
 		batadv_handle_unclaim(bat_priv, primary_if,
 				      primary_if->net_dev->dev_addr,
 				      ethhdr->h_source, vid);
 		goto allow;
 	}
 	/* check if it is a multicast/broadcast frame */
 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
 		/* drop it. the responsible gateway has forwarded it into
 		 * the backbone network.
 		 */
 		goto handled;
 	} else {
 		/* we must allow it. at least if we are
 		 * responsible for the DESTINATION.
 		 */
 		goto allow;
 	}
 allow:
 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
 	ret = 0;
 	goto out;
 handled:
 	ret = 1;
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	if (claim)
 		batadv_claim_free_ref(claim);
 	return ret;
 }
 int batadv_bla_claim_table_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->bla.claim_hash;
 	struct batadv_claim *claim;
 	struct batadv_hard_iface *primary_if;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	uint32_t i;
 	bool is_own;
-	int ret = 0;
 	uint8_t *primary_addr;
-	primary_if = batadv_primary_if_get_selected(bat_priv);
+	primary_if = batadv_seq_print_text_primary_if_get(seq);
-	if (!primary_if) {
+	if (!primary_if)
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
-				 net_dev->name);
 		goto out;
-	}
-	if (primary_if->if_status != BATADV_IF_ACTIVE) {
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - primary interface not active\n",
-				 net_dev->name);
-		goto out;
-	}
 	primary_addr = primary_if->net_dev->dev_addr;
 	seq_printf(seq,
 		   "Claims announced for the mesh %s (orig %pM, group id %04x)\n",
 		   net_dev->name, primary_addr,
 		   ntohs(bat_priv->bla.claim_dest.group));
 	seq_printf(seq, "   %-17s    %-5s    %-17s [o] (%-4s)\n",
 		   "Client", "VID", "Originator", "CRC");
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
 			is_own = batadv_compare_eth(claim->backbone_gw->orig,
 						    primary_addr);
 			seq_printf(seq,	" * %pM on % 5d by %pM [%c] (%04x)\n",
 				   claim->addr, claim->vid,
 				   claim->backbone_gw->orig,
 				   (is_own ? 'x' : ' '),
 				   claim->backbone_gw->crc);
 		}
 		rcu_read_unlock();
 	}
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
-	return ret;
+	return 0;
 }
 int batadv_bla_backbone_table_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->bla.backbone_hash;
 	struct batadv_backbone_gw *backbone_gw;
 	struct batadv_hard_iface *primary_if;
 	struct hlist_node *node;
 	struct hlist_head *head;
 	int secs, msecs;
 	uint32_t i;
 	bool is_own;
-	int ret = 0;
 	uint8_t *primary_addr;
-	primary_if = batadv_primary_if_get_selected(bat_priv);
+	primary_if = batadv_seq_print_text_primary_if_get(seq);
-	if (!primary_if) {
+	if (!primary_if)
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
-				 net_dev->name);
 		goto out;
-	}
-	if (primary_if->if_status != BATADV_IF_ACTIVE) {
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - primary interface not active\n",
-				 net_dev->name);
-		goto out;
-	}
 	primary_addr = primary_if->net_dev->dev_addr;
 	seq_printf(seq,
 		   "Backbones announced for the mesh %s (orig %pM, group id %04x)\n",
 		   net_dev->name, primary_addr,
 		   ntohs(bat_priv->bla.claim_dest.group));
 	seq_printf(seq, "   %-17s    %-5s %-9s (%-4s)\n",
 		   "Originator", "VID", "last seen", "CRC");
 	for (i = 0; i < hash->size; i++) {
 		head = &hash->table[i];
 		rcu_read_lock();
 		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
 			msecs = jiffies_to_msecs(jiffies -
 						 backbone_gw->lasttime);
 			secs = msecs / 1000;
 			msecs = msecs % 1000;
 			is_own = batadv_compare_eth(backbone_gw->orig,
 						    primary_addr);
 			if (is_own)
 				continue;
 			seq_printf(seq,
 				   " * %pM on % 5d % 4i.%03is (%04x)\n",
 				   backbone_gw->orig, backbone_gw->vid,
 				   secs, msecs, backbone_gw->crc);
 		}
 		rcu_read_unlock();
 	}
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
-	return ret;
+	return 0;
 }

net/batman-adv/gateway_client.c

Diff comments View file @ 30da63a

 /* Copyright (C) 2009-2012 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner
  *
  * 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 "sysfs.h"
 #include "gateway_client.h"
 #include "gateway_common.h"
 #include "hard-interface.h"
 #include "originator.h"
 #include "translation-table.h"
 #include "routing.h"
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/udp.h>
 #include <linux/if_vlan.h>
 /* This is the offset of the options field in a dhcp packet starting at
  * the beginning of the dhcp header
  */
 #define BATADV_DHCP_OPTIONS_OFFSET 240
 #define BATADV_DHCP_REQUEST 3
 static void batadv_gw_node_free_ref(struct batadv_gw_node *gw_node)
 {
 	if (atomic_dec_and_test(&gw_node->refcount))
 		kfree_rcu(gw_node, rcu);
 }
 static struct batadv_gw_node *
 batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *gw_node;
 	rcu_read_lock();
 	gw_node = rcu_dereference(bat_priv->gw.curr_gw);
 	if (!gw_node)
 		goto out;
 	if (!atomic_inc_not_zero(&gw_node->refcount))
 		gw_node = NULL;
 out:
 	rcu_read_unlock();
 	return gw_node;
 }
 struct batadv_orig_node *
 batadv_gw_get_selected_orig(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *gw_node;
 	struct batadv_orig_node *orig_node = NULL;
 	gw_node = batadv_gw_get_selected_gw_node(bat_priv);
 	if (!gw_node)
 		goto out;
 	rcu_read_lock();
 	orig_node = gw_node->orig_node;
 	if (!orig_node)
 		goto unlock;
 	if (!atomic_inc_not_zero(&orig_node->refcount))
 		orig_node = NULL;
 unlock:
 	rcu_read_unlock();
 out:
 	if (gw_node)
 		batadv_gw_node_free_ref(gw_node);
 	return orig_node;
 }
 static void batadv_gw_select(struct batadv_priv *bat_priv,
 			     struct batadv_gw_node *new_gw_node)
 {
 	struct batadv_gw_node *curr_gw_node;
 	spin_lock_bh(&bat_priv->gw.list_lock);
 	if (new_gw_node && !atomic_inc_not_zero(&new_gw_node->refcount))
 		new_gw_node = NULL;
 	curr_gw_node = rcu_dereference_protected(bat_priv->gw.curr_gw, 1);
 	rcu_assign_pointer(bat_priv->gw.curr_gw, new_gw_node);
 	if (curr_gw_node)
 		batadv_gw_node_free_ref(curr_gw_node);
 	spin_unlock_bh(&bat_priv->gw.list_lock);
 }
 void batadv_gw_deselect(struct batadv_priv *bat_priv)
 {
 	atomic_set(&bat_priv->gw.reselect, 1);
 }
 static struct batadv_gw_node *
 batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
 {
 	struct batadv_neigh_node *router;
 	struct hlist_node *node;
 	struct batadv_gw_node *gw_node, *curr_gw = NULL;
 	uint32_t max_gw_factor = 0, tmp_gw_factor = 0;
 	uint32_t gw_divisor;
 	uint8_t max_tq = 0;
 	int down, up;
 	uint8_t tq_avg;
 	struct batadv_orig_node *orig_node;
 	gw_divisor = BATADV_TQ_LOCAL_WINDOW_SIZE * BATADV_TQ_LOCAL_WINDOW_SIZE;
 	gw_divisor *= 64;
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
 		if (gw_node->deleted)
 			continue;
 		orig_node = gw_node->orig_node;
 		router = batadv_orig_node_get_router(orig_node);
 		if (!router)
 			continue;
 		if (!atomic_inc_not_zero(&gw_node->refcount))
 			goto next;
 		tq_avg = router->tq_avg;
 		switch (atomic_read(&bat_priv->gw_sel_class)) {
 		case 1: /* fast connection */
 			batadv_gw_bandwidth_to_kbit(orig_node->gw_flags,
 						    &down, &up);
 			tmp_gw_factor = tq_avg * tq_avg * down * 100 * 100;
 			tmp_gw_factor /= gw_divisor;
 			if ((tmp_gw_factor > max_gw_factor) ||
 			    ((tmp_gw_factor == max_gw_factor) &&
 			     (tq_avg > max_tq))) {
 				if (curr_gw)
 					batadv_gw_node_free_ref(curr_gw);
 				curr_gw = gw_node;
 				atomic_inc(&curr_gw->refcount);
 			}
 			break;
 		default: /* 2:  stable connection (use best statistic)
 			  * 3:  fast-switch (use best statistic but change as
 			  *     soon as a better gateway appears)
 			  * XX: late-switch (use best statistic but change as
 			  *     soon as a better gateway appears which has
 			  *     $routing_class more tq points)
 			  */
 			if (tq_avg > max_tq) {
 				if (curr_gw)
 					batadv_gw_node_free_ref(curr_gw);
 				curr_gw = gw_node;
 				atomic_inc(&curr_gw->refcount);
 			}
 			break;
 		}
 		if (tq_avg > max_tq)
 			max_tq = tq_avg;
 		if (tmp_gw_factor > max_gw_factor)
 			max_gw_factor = tmp_gw_factor;
 		batadv_gw_node_free_ref(gw_node);
 next:
 		batadv_neigh_node_free_ref(router);
 	}
 	rcu_read_unlock();
 	return curr_gw;
 }
 void batadv_gw_election(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *curr_gw = NULL, *next_gw = NULL;
 	struct batadv_neigh_node *router = NULL;
 	char gw_addr[18] = { '\0' };
 	/* The batman daemon checks here if we already passed a full originator
 	 * cycle in order to make sure we don't choose the first gateway we
 	 * hear about. This check is based on the daemon's uptime which we
 	 * don't have.
 	 */
 	if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT)
 		goto out;
 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 	if (!batadv_atomic_dec_not_zero(&bat_priv->gw.reselect) && curr_gw)
 		goto out;
 	next_gw = batadv_gw_get_best_gw_node(bat_priv);
 	if (curr_gw == next_gw)
 		goto out;
 	if (next_gw) {
 		sprintf(gw_addr, "%pM", next_gw->orig_node->orig);
 		router = batadv_orig_node_get_router(next_gw->orig_node);
 		if (!router) {
 			batadv_gw_deselect(bat_priv);
 			goto out;
 		}
 	}
 	if ((curr_gw) && (!next_gw)) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Removing selected gateway - no gateway in range\n");
 		batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL,
 				    NULL);
 	} else if ((!curr_gw) && (next_gw)) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Adding route to gateway %pM (gw_flags: %i, tq: %i)\n",
 			   next_gw->orig_node->orig,
 			   next_gw->orig_node->gw_flags, router->tq_avg);
 		batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_ADD,
 				    gw_addr);
 	} else {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Changing route to gateway %pM (gw_flags: %i, tq: %i)\n",
 			   next_gw->orig_node->orig,
 			   next_gw->orig_node->gw_flags, router->tq_avg);
 		batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_CHANGE,
 				    gw_addr);
 	}
 	batadv_gw_select(bat_priv, next_gw);
 out:
 	if (curr_gw)
 		batadv_gw_node_free_ref(curr_gw);
 	if (next_gw)
 		batadv_gw_node_free_ref(next_gw);
 	if (router)
 		batadv_neigh_node_free_ref(router);
 }
 void batadv_gw_check_election(struct batadv_priv *bat_priv,
 			      struct batadv_orig_node *orig_node)
 {
 	struct batadv_orig_node *curr_gw_orig;
 	struct batadv_neigh_node *router_gw = NULL, *router_orig = NULL;
 	uint8_t gw_tq_avg, orig_tq_avg;
 	curr_gw_orig = batadv_gw_get_selected_orig(bat_priv);
 	if (!curr_gw_orig)
 		goto deselect;
 	router_gw = batadv_orig_node_get_router(curr_gw_orig);
 	if (!router_gw)
 		goto deselect;
 	/* this node already is the gateway */
 	if (curr_gw_orig == orig_node)
 		goto out;
 	router_orig = batadv_orig_node_get_router(orig_node);
 	if (!router_orig)
 		goto out;
 	gw_tq_avg = router_gw->tq_avg;
 	orig_tq_avg = router_orig->tq_avg;
 	/* the TQ value has to be better */
 	if (orig_tq_avg < gw_tq_avg)
 		goto out;
 	/* if the routing class is greater than 3 the value tells us how much
 	 * greater the TQ value of the new gateway must be
 	 */
 	if ((atomic_read(&bat_priv->gw_sel_class) > 3) &&
 	    (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class)))
 		goto out;
 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 		   "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n",
 		   gw_tq_avg, orig_tq_avg);
 deselect:
 	batadv_gw_deselect(bat_priv);
 out:
 	if (curr_gw_orig)
 		batadv_orig_node_free_ref(curr_gw_orig);
 	if (router_gw)
 		batadv_neigh_node_free_ref(router_gw);
 	if (router_orig)
 		batadv_neigh_node_free_ref(router_orig);
 	return;
 }
 static void batadv_gw_node_add(struct batadv_priv *bat_priv,
 			       struct batadv_orig_node *orig_node,
 			       uint8_t new_gwflags)
 {
 	struct batadv_gw_node *gw_node;
 	int down, up;
 	gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC);
 	if (!gw_node)
 		return;
 	INIT_HLIST_NODE(&gw_node->list);
 	gw_node->orig_node = orig_node;
 	atomic_set(&gw_node->refcount, 1);
 	spin_lock_bh(&bat_priv->gw.list_lock);
 	hlist_add_head_rcu(&gw_node->list, &bat_priv->gw.list);
 	spin_unlock_bh(&bat_priv->gw.list_lock);
 	batadv_gw_bandwidth_to_kbit(new_gwflags, &down, &up);
 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 		   "Found new gateway %pM -> gw_class: %i - %i%s/%i%s\n",
 		   orig_node->orig, new_gwflags,
 		   (down > 2048 ? down / 1024 : down),
 		   (down > 2048 ? "MBit" : "KBit"),
 		   (up > 2048 ? up / 1024 : up),
 		   (up > 2048 ? "MBit" : "KBit"));
 }
 void batadv_gw_node_update(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node,
 			   uint8_t new_gwflags)
 {
 	struct hlist_node *node;
 	struct batadv_gw_node *gw_node, *curr_gw;
 	/* Note: We don't need a NULL check here, since curr_gw never gets
 	 * dereferenced. If curr_gw is NULL we also should not exit as we may
 	 * have this gateway in our list (duplication check!) even though we
 	 * have no currently selected gateway.
 	 */
 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
 		if (gw_node->orig_node != orig_node)
 			continue;
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Gateway class of originator %pM changed from %i to %i\n",
 			   orig_node->orig, gw_node->orig_node->gw_flags,
 			   new_gwflags);
 		gw_node->deleted = 0;
 		if (new_gwflags == BATADV_NO_FLAGS) {
 			gw_node->deleted = jiffies;
 			batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 				   "Gateway %pM removed from gateway list\n",
 				   orig_node->orig);
 			if (gw_node == curr_gw)
 				goto deselect;
 		}
 		goto unlock;
 	}
 	if (new_gwflags == BATADV_NO_FLAGS)
 		goto unlock;
 	batadv_gw_node_add(bat_priv, orig_node, new_gwflags);
 	goto unlock;
 deselect:
 	batadv_gw_deselect(bat_priv);
 unlock:
 	rcu_read_unlock();
 	if (curr_gw)
 		batadv_gw_node_free_ref(curr_gw);
 }
 void batadv_gw_node_delete(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node)
 {
 	batadv_gw_node_update(bat_priv, orig_node, 0);
 }
 void batadv_gw_node_purge(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *gw_node, *curr_gw;
 	struct hlist_node *node, *node_tmp;
 	unsigned long timeout = msecs_to_jiffies(2 * BATADV_PURGE_TIMEOUT);
 	int do_deselect = 0;
 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 	spin_lock_bh(&bat_priv->gw.list_lock);
 	hlist_for_each_entry_safe(gw_node, node, node_tmp,
 				  &bat_priv->gw.list, list) {
 		if (((!gw_node->deleted) ||
 		     (time_before(jiffies, gw_node->deleted + timeout))) &&
 		    atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE)
 			continue;
 		if (curr_gw == gw_node)
 			do_deselect = 1;
 		hlist_del_rcu(&gw_node->list);
 		batadv_gw_node_free_ref(gw_node);
 	}
 	spin_unlock_bh(&bat_priv->gw.list_lock);
 	/* gw_deselect() needs to acquire the gw_list_lock */
 	if (do_deselect)
 		batadv_gw_deselect(bat_priv);
 	if (curr_gw)
 		batadv_gw_node_free_ref(curr_gw);
 }
 /* fails if orig_node has no router */
 static int batadv_write_buffer_text(struct batadv_priv *bat_priv,
 				    struct seq_file *seq,
 				    const struct batadv_gw_node *gw_node)
 {
 	struct batadv_gw_node *curr_gw;
 	struct batadv_neigh_node *router;
 	int down, up, ret = -1;
 	batadv_gw_bandwidth_to_kbit(gw_node->orig_node->gw_flags, &down, &up);
 	router = batadv_orig_node_get_router(gw_node->orig_node);
 	if (!router)
 		goto out;
 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 	ret = seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %3i - %i%s/%i%s\n",
 			 (curr_gw == gw_node ? "=>" : "  "),
 			 gw_node->orig_node->orig,
 			 router->tq_avg, router->addr,
 			 router->if_incoming->net_dev->name,
 			 gw_node->orig_node->gw_flags,
 			 (down > 2048 ? down / 1024 : down),
 			 (down > 2048 ? "MBit" : "KBit"),
 			 (up > 2048 ? up / 1024 : up),
 			 (up > 2048 ? "MBit" : "KBit"));
 	batadv_neigh_node_free_ref(router);
 	if (curr_gw)
 		batadv_gw_node_free_ref(curr_gw);
 out:
 	return ret;
 }
 int batadv_gw_client_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_hard_iface *primary_if;
 	struct batadv_gw_node *gw_node;
 	struct hlist_node *node;
-	int gw_count = 0, ret = 0;
+	int gw_count = 0;
-	primary_if = batadv_primary_if_get_selected(bat_priv);
+	primary_if = batadv_seq_print_text_primary_if_get(seq);
-	if (!primary_if) {
+	if (!primary_if)
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
-				 net_dev->name);
 		goto out;
-	}
-	if (primary_if->if_status != BATADV_IF_ACTIVE) {
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - primary interface not active\n",
-				 net_dev->name);
-		goto out;
-	}
 	seq_printf(seq,
 		   "      %-12s (%s/%i) %17s [%10s]: gw_class ... [B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",
 		   "Gateway", "#", BATADV_TQ_MAX_VALUE, "Nexthop", "outgoingIF",
 		   BATADV_SOURCE_VERSION, primary_if->net_dev->name,
 		   primary_if->net_dev->dev_addr, net_dev->name);
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
 		if (gw_node->deleted)
 			continue;
 		/* fails if orig_node has no router */
 		if (batadv_write_buffer_text(bat_priv, seq, gw_node) < 0)
 			continue;
 		gw_count++;
 	}
 	rcu_read_unlock();
 	if (gw_count == 0)
 		seq_printf(seq, "No gateways in range ...\n");
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
-	return ret;
+	return 0;
 }
 static bool batadv_is_type_dhcprequest(struct sk_buff *skb, int header_len)
 {
 	int ret = false;
 	unsigned char *p;
 	int pkt_len;
 	if (skb_linearize(skb) < 0)
 		goto out;
 	pkt_len = skb_headlen(skb);
 	if (pkt_len < header_len + BATADV_DHCP_OPTIONS_OFFSET + 1)
 		goto out;
 	p = skb->data + header_len + BATADV_DHCP_OPTIONS_OFFSET;
 	pkt_len -= header_len + BATADV_DHCP_OPTIONS_OFFSET + 1;
 	/* Access the dhcp option lists. Each entry is made up by:
 	 * - octet 1: option type
 	 * - octet 2: option data len (only if type != 255 and 0)
 	 * - octet 3: option data
 	 */
 	while (*p != 255 && !ret) {
 		/* p now points to the first octet: option type */
 		if (*p == 53) {
 			/* type 53 is the message type option.
 			 * Jump the len octet and go to the data octet
 			 */
 			if (pkt_len < 2)
 				goto out;
 			p += 2;
 			/* check if the message type is what we need */
 			if (*p == BATADV_DHCP_REQUEST)
 				ret = true;
 			break;
 		} else if (*p == 0) {
 			/* option type 0 (padding), just go forward */
 			if (pkt_len < 1)
 				goto out;
 			pkt_len--;
 			p++;
 		} else {
 			/* This is any other option. So we get the length... */
 			if (pkt_len < 1)
 				goto out;
 			pkt_len--;
 			p++;
 			/* ...and then we jump over the data */
 			if (pkt_len < 1 + (*p))
 				goto out;
 			pkt_len -= 1 + (*p);
 			p += 1 + (*p);
 		}
 	}
 out:
 	return ret;
 }
 bool batadv_gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len)
 {
 	struct ethhdr *ethhdr;
 	struct iphdr *iphdr;
 	struct ipv6hdr *ipv6hdr;
 	struct udphdr *udphdr;
 	/* check for ethernet header */
 	if (!pskb_may_pull(skb, *header_len + ETH_HLEN))
 		return false;
 	ethhdr = (struct ethhdr *)skb->data;
 	*header_len += ETH_HLEN;
 	/* check for initial vlan header */
 	if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
 		if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))
 			return false;
 		ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);
 		*header_len += VLAN_HLEN;
 	}
 	/* check for ip header */
 	switch (ntohs(ethhdr->h_proto)) {
 	case ETH_P_IP:
 		if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))
 			return false;
 		iphdr = (struct iphdr *)(skb->data + *header_len);
 		*header_len += iphdr->ihl * 4;
 		/* check for udp header */
 		if (iphdr->protocol != IPPROTO_UDP)
 			return false;
 		break;
 	case ETH_P_IPV6:
 		if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))
 			return false;
 		ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);
 		*header_len += sizeof(*ipv6hdr);
 		/* check for udp header */
 		if (ipv6hdr->nexthdr != IPPROTO_UDP)
 			return false;
 		break;
 	default:
 		return false;
 	}
 	if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
 		return false;
 	udphdr = (struct udphdr *)(skb->data + *header_len);
 	*header_len += sizeof(*udphdr);
 	/* check for bootp port */
 	if ((ntohs(ethhdr->h_proto) == ETH_P_IP) &&
 	    (ntohs(udphdr->dest) != 67))
 		return false;
 	if ((ntohs(ethhdr->h_proto) == ETH_P_IPV6) &&
 	    (ntohs(udphdr->dest) != 547))
 		return false;
 	return true;
 }
 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
 			    struct sk_buff *skb, struct ethhdr *ethhdr)
 {
 	struct batadv_neigh_node *neigh_curr = NULL, *neigh_old = NULL;
 	struct batadv_orig_node *orig_dst_node = NULL;
 	struct batadv_gw_node *curr_gw = NULL;
 	bool ret, out_of_range = false;
 	unsigned int header_len = 0;
 	uint8_t curr_tq_avg;
 	ret = batadv_gw_is_dhcp_target(skb, &header_len);
 	if (!ret)
 		goto out;
 	orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
 						 ethhdr->h_dest);
 	if (!orig_dst_node)
 		goto out;
 	if (!orig_dst_node->gw_flags)
 		goto out;
 	ret = batadv_is_type_dhcprequest(skb, header_len);
 	if (!ret)
 		goto out;
 	switch (atomic_read(&bat_priv->gw_mode)) {
 	case BATADV_GW_MODE_SERVER:
 		/* If we are a GW then we are our best GW. We can artificially
 		 * set the tq towards ourself as the maximum value
 		 */
 		curr_tq_avg = BATADV_TQ_MAX_VALUE;
 		break;
 	case BATADV_GW_MODE_CLIENT:
 		curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 		if (!curr_gw)
 			goto out;
 		/* packet is going to our gateway */
 		if (curr_gw->orig_node == orig_dst_node)
 			goto out;
 		/* If the dhcp packet has been sent to a different gw,
 		 * we have to evaluate whether the old gw is still
 		 * reliable enough
 		 */
 		neigh_curr = batadv_find_router(bat_priv, curr_gw->orig_node,
 						NULL);
 		if (!neigh_curr)
 			goto out;
 		curr_tq_avg = neigh_curr->tq_avg;
 		break;
 	case BATADV_GW_MODE_OFF:
 	default:
 		goto out;
 	}
 	neigh_old = batadv_find_router(bat_priv, orig_dst_node, NULL);
 	if (!neigh_old)
 		goto out;
 	if (curr_tq_avg - neigh_old->tq_avg > BATADV_GW_THRESHOLD)
 		out_of_range = true;
 out:
 	if (orig_dst_node)
 		batadv_orig_node_free_ref(orig_dst_node);
 	if (curr_gw)
 		batadv_gw_node_free_ref(curr_gw);
 	if (neigh_old)
 		batadv_neigh_node_free_ref(neigh_old);
 	if (neigh_curr)
 		batadv_neigh_node_free_ref(neigh_curr);
 	return out_of_range;
 }

net/batman-adv/main.c

Diff comments View file @ 30da63a

 /* 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 "sysfs.h"
 #include "debugfs.h"
 #include "routing.h"
 #include "send.h"
 #include "originator.h"
 #include "soft-interface.h"
 #include "icmp_socket.h"
 #include "translation-table.h"
 #include "hard-interface.h"
 #include "gateway_client.h"
 #include "bridge_loop_avoidance.h"
 #include "vis.h"
 #include "hash.h"
 #include "bat_algo.h"
 /* List manipulations on hardif_list have to be rtnl_lock()'ed,
  * list traversals just rcu-locked
  */
 struct list_head batadv_hardif_list;
 static int (*batadv_rx_handler[256])(struct sk_buff *,
 				     struct batadv_hard_iface *);
 char batadv_routing_algo[20] = "BATMAN_IV";
 static struct hlist_head batadv_algo_list;
 unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 struct workqueue_struct *batadv_event_workqueue;
 static void batadv_recv_handler_init(void);
 static int __init batadv_init(void)
 {
 	INIT_LIST_HEAD(&batadv_hardif_list);
 	INIT_HLIST_HEAD(&batadv_algo_list);
 	batadv_recv_handler_init();
 	batadv_iv_init();
 	batadv_event_workqueue = create_singlethread_workqueue("bat_events");
 	if (!batadv_event_workqueue)
 		return -ENOMEM;
 	batadv_socket_init();
 	batadv_debugfs_init();
 	register_netdevice_notifier(&batadv_hard_if_notifier);
 	pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
 		BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
 	return 0;
 }
 static void __exit batadv_exit(void)
 {
 	batadv_debugfs_destroy();
 	unregister_netdevice_notifier(&batadv_hard_if_notifier);
 	batadv_hardif_remove_interfaces();
 	flush_workqueue(batadv_event_workqueue);
 	destroy_workqueue(batadv_event_workqueue);
 	batadv_event_workqueue = NULL;
 	rcu_barrier();
 }
 int batadv_mesh_init(struct net_device *soft_iface)
 {
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	int ret;
 	spin_lock_init(&bat_priv->forw_bat_list_lock);
 	spin_lock_init(&bat_priv->forw_bcast_list_lock);
 	spin_lock_init(&bat_priv->tt.changes_list_lock);
 	spin_lock_init(&bat_priv->tt.req_list_lock);
 	spin_lock_init(&bat_priv->tt.roam_list_lock);
 	spin_lock_init(&bat_priv->tt.last_changeset_lock);
 	spin_lock_init(&bat_priv->gw.list_lock);
 	spin_lock_init(&bat_priv->vis.hash_lock);
 	spin_lock_init(&bat_priv->vis.list_lock);
 	INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
 	INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
 	INIT_HLIST_HEAD(&bat_priv->gw.list);
 	INIT_LIST_HEAD(&bat_priv->tt.changes_list);
 	INIT_LIST_HEAD(&bat_priv->tt.req_list);
 	INIT_LIST_HEAD(&bat_priv->tt.roam_list);
 	ret = batadv_originator_init(bat_priv);
 	if (ret < 0)
 		goto err;
 	ret = batadv_tt_init(bat_priv);
 	if (ret < 0)
 		goto err;
 	batadv_tt_local_add(soft_iface, soft_iface->dev_addr,
 			    BATADV_NULL_IFINDEX);
 	ret = batadv_vis_init(bat_priv);
 	if (ret < 0)
 		goto err;
 	ret = batadv_bla_init(bat_priv);
 	if (ret < 0)
 		goto err;
 	atomic_set(&bat_priv->gw.reselect, 0);
 	atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
 	return 0;
 err:
 	batadv_mesh_free(soft_iface);
 	return ret;
 }
 void batadv_mesh_free(struct net_device *soft_iface)
 {
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
 	batadv_purge_outstanding_packets(bat_priv, NULL);
 	batadv_vis_quit(bat_priv);
 	batadv_gw_node_purge(bat_priv);
 	batadv_originator_free(bat_priv);
 	batadv_tt_free(bat_priv);
 	batadv_bla_free(bat_priv);
 	free_percpu(bat_priv->bat_counters);
 	atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
 }
 void batadv_inc_module_count(void)
 {
 	try_module_get(THIS_MODULE);
 }
 void batadv_dec_module_count(void)
 {
 	module_put(THIS_MODULE);
 }
 int batadv_is_my_mac(const uint8_t *addr)
 {
 	const struct batadv_hard_iface *hard_iface;
 	rcu_read_lock();
 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
 		if (hard_iface->if_status != BATADV_IF_ACTIVE)
 			continue;
 		if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
 			rcu_read_unlock();
 			return 1;
 		}
 	}
 	rcu_read_unlock();
 	return 0;
 }
+/**
+ * batadv_seq_print_text_primary_if_get - called from debugfs table printing
+ *  function that requires the primary interface
+ * @seq: debugfs table seq_file struct
+ *
+ * Returns primary interface if found or NULL otherwise.
+ */
+struct batadv_hard_iface *
+batadv_seq_print_text_primary_if_get(struct seq_file *seq)
+{
+	struct net_device *net_dev = (struct net_device *)seq->private;
+	struct batadv_priv *bat_priv = netdev_priv(net_dev);
+	struct batadv_hard_iface *primary_if;
+	primary_if = batadv_primary_if_get_selected(bat_priv);
+	if (!primary_if) {
+		seq_printf(seq,
+			   "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
+			   net_dev->name);
+		goto out;
+	}
+	if (primary_if->if_status == BATADV_IF_ACTIVE)
+		goto out;
+	seq_printf(seq,
+		   "BATMAN mesh %s disabled - primary interface not active\n",
+		   net_dev->name);
+	batadv_hardif_free_ref(primary_if);
+	primary_if = NULL;
+out:
+	return primary_if;
+}
 static int batadv_recv_unhandled_packet(struct sk_buff *skb,
 					struct batadv_hard_iface *recv_if)
 {
 	return NET_RX_DROP;
 }
 /* incoming packets with the batman ethertype received on any active hard
  * interface
  */
 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
 			   struct packet_type *ptype,
 			   struct net_device *orig_dev)
 {
 	struct batadv_priv *bat_priv;
 	struct batadv_ogm_packet *batadv_ogm_packet;
 	struct batadv_hard_iface *hard_iface;
 	uint8_t idx;
 	int ret;
 	hard_iface = container_of(ptype, struct batadv_hard_iface,
 				  batman_adv_ptype);
 	skb = skb_share_check(skb, GFP_ATOMIC);
 	/* skb was released by skb_share_check() */
 	if (!skb)
 		goto err_out;
 	/* packet should hold at least type and version */
 	if (unlikely(!pskb_may_pull(skb, 2)))
 		goto err_free;
 	/* expect a valid ethernet header here. */
 	if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
 		goto err_free;
 	if (!hard_iface->soft_iface)
 		goto err_free;
 	bat_priv = netdev_priv(hard_iface->soft_iface);
 	if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 		goto err_free;
 	/* discard frames on not active interfaces */
 	if (hard_iface->if_status != BATADV_IF_ACTIVE)
 		goto err_free;
 	batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
 	if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Drop packet: incompatible batman version (%i)\n",
 			   batadv_ogm_packet->header.version);
 		goto err_free;
 	}
 	/* all receive handlers return whether they received or reused
 	 * the supplied skb. if not, we have to free the skb.
 	 */
 	idx = batadv_ogm_packet->header.packet_type;
 	ret = (*batadv_rx_handler[idx])(skb, hard_iface);
 	if (ret == NET_RX_DROP)
 		kfree_skb(skb);
 	/* return NET_RX_SUCCESS in any case as we
 	 * most probably dropped the packet for
 	 * routing-logical reasons.
 	 */
 	return NET_RX_SUCCESS;
 err_free:
 	kfree_skb(skb);
 err_out:
 	return NET_RX_DROP;
 }
 static void batadv_recv_handler_init(void)
 {
 	int i;
 	for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
 		batadv_rx_handler[i] = batadv_recv_unhandled_packet;
 	/* batman icmp packet */
 	batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
 	/* unicast packet */
 	batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
 	/* fragmented unicast packet */
 	batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_ucast_frag_packet;
 	/* broadcast packet */
 	batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
 	/* vis packet */
 	batadv_rx_handler[BATADV_VIS] = batadv_recv_vis_packet;
 	/* Translation table query (request or response) */
 	batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query;
 	/* Roaming advertisement */
 	batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv;
 }
 int
 batadv_recv_handler_register(uint8_t packet_type,
 			     int (*recv_handler)(struct sk_buff *,
 						 struct batadv_hard_iface *))
 {
 	if (batadv_rx_handler[packet_type] != &batadv_recv_unhandled_packet)
 		return -EBUSY;
 	batadv_rx_handler[packet_type] = recv_handler;
 	return 0;
 }
 void batadv_recv_handler_unregister(uint8_t packet_type)
 {
 	batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
 }
 static struct batadv_algo_ops *batadv_algo_get(char *name)
 {
 	struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
 	struct hlist_node *node;
 	hlist_for_each_entry(bat_algo_ops_tmp, node, &batadv_algo_list, list) {
 		if (strcmp(bat_algo_ops_tmp->name, name) != 0)
 			continue;
 		bat_algo_ops = bat_algo_ops_tmp;
 		break;
 	}
 	return bat_algo_ops;
 }
 int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
 {
 	struct batadv_algo_ops *bat_algo_ops_tmp;
 	int ret;
 	bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
 	if (bat_algo_ops_tmp) {
 		pr_info("Trying to register already registered routing algorithm: %s\n",
 			bat_algo_ops->name);
 		ret = -EEXIST;
 		goto out;
 	}
 	/* all algorithms must implement all ops (for now) */
 	if (!bat_algo_ops->bat_iface_enable ||
 	    !bat_algo_ops->bat_iface_disable ||
 	    !bat_algo_ops->bat_iface_update_mac ||
 	    !bat_algo_ops->bat_primary_iface_set ||
 	    !bat_algo_ops->bat_ogm_schedule ||
 	    !bat_algo_ops->bat_ogm_emit) {
 		pr_info("Routing algo '%s' does not implement required ops\n",
 			bat_algo_ops->name);
 		ret = -EINVAL;
 		goto out;
 	}
 	INIT_HLIST_NODE(&bat_algo_ops->list);
 	hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
 	ret = 0;
 out:
 	return ret;
 }
 int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
 {
 	struct batadv_algo_ops *bat_algo_ops;
 	int ret = -EINVAL;
 	bat_algo_ops = batadv_algo_get(name);
 	if (!bat_algo_ops)
 		goto out;
 	bat_priv->bat_algo_ops = bat_algo_ops;
 	ret = 0;
 out:
 	return ret;
 }
 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
 {
 	struct batadv_algo_ops *bat_algo_ops;
 	struct hlist_node *node;
 	seq_printf(seq, "Available routing algorithms:\n");
 	hlist_for_each_entry(bat_algo_ops, node, &batadv_algo_list, list) {
 		seq_printf(seq, "%s\n", bat_algo_ops->name);
 	}
 	return 0;
 }
 static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
 {
 	struct batadv_algo_ops *bat_algo_ops;
 	char *algo_name = (char *)val;
 	size_t name_len = strlen(algo_name);
 	if (algo_name[name_len - 1] == '\n')
 		algo_name[name_len - 1] = '\0';
 	bat_algo_ops = batadv_algo_get(algo_name);
 	if (!bat_algo_ops) {
 		pr_err("Routing algorithm '%s' is not supported\n", algo_name);
 		return -EINVAL;
 	}
 	return param_set_copystring(algo_name, kp);
 }
 static const struct kernel_param_ops batadv_param_ops_ra = {
 	.set = batadv_param_set_ra,
 	.get = param_get_string,
 };
 static struct kparam_string batadv_param_string_ra = {
 	.maxlen = sizeof(batadv_routing_algo),
 	.string = batadv_routing_algo,
 };
 module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
 		0644);
 module_init(batadv_init);
 module_exit(batadv_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
 MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
 MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
 MODULE_VERSION(BATADV_SOURCE_VERSION);

net/batman-adv/main.h

Diff comments View file @ 30da63a

 /* 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_MAIN_H_
 #define _NET_BATMAN_ADV_MAIN_H_
 #define BATADV_DRIVER_AUTHOR "Marek Lindner <lindner_marek@yahoo.de>, " \
 			     "Simon Wunderlich <siwu@hrz.tu-chemnitz.de>"
 #define BATADV_DRIVER_DESC   "B.A.T.M.A.N. advanced"
 #define BATADV_DRIVER_DEVICE "batman-adv"
 #ifndef BATADV_SOURCE_VERSION
 #define BATADV_SOURCE_VERSION "2012.4.0"
 #endif
 /* B.A.T.M.A.N. parameters */
 #define BATADV_TQ_MAX_VALUE 255
 #define BATADV_JITTER 20
 /* Time To Live of broadcast messages */
 #define BATADV_TTL 50
 /* purge originators after time in seconds if no valid packet comes in
  * -> TODO: check influence on BATADV_TQ_LOCAL_WINDOW_SIZE
  */
 #define BATADV_PURGE_TIMEOUT 200000 /* 200 seconds */
 #define BATADV_TT_LOCAL_TIMEOUT 3600000 /* in milliseconds */
 #define BATADV_TT_CLIENT_ROAM_TIMEOUT 600000 /* in milliseconds */
 #define BATADV_TT_CLIENT_TEMP_TIMEOUT 600000 /* in milliseconds */
 /* sliding packet range of received originator messages in sequence numbers
  * (should be a multiple of our word size)
  */
 #define BATADV_TQ_LOCAL_WINDOW_SIZE 64
 /* milliseconds we have to keep pending tt_req */
 #define BATADV_TT_REQUEST_TIMEOUT 3000
 #define BATADV_TQ_GLOBAL_WINDOW_SIZE 5
 #define BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM 1
 #define BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM 1
 #define BATADV_TQ_TOTAL_BIDRECT_LIMIT 1
 /* number of OGMs sent with the last tt diff */
 #define BATADV_TT_OGM_APPEND_MAX 3
 /* Time in which a client can roam at most ROAMING_MAX_COUNT times in
  * milliseconds
  */
 #define BATADV_ROAMING_MAX_TIME 20000
 #define BATADV_ROAMING_MAX_COUNT 5
 #define BATADV_NO_FLAGS 0
 #define BATADV_NULL_IFINDEX 0 /* dummy ifindex used to avoid iface checks */
 #define BATADV_NUM_WORDS BITS_TO_LONGS(BATADV_TQ_LOCAL_WINDOW_SIZE)
 #define BATADV_LOG_BUF_LEN 8192	  /* has to be a power of 2 */
 #define BATADV_VIS_INTERVAL 5000	/* 5 seconds */
 /* how much worse secondary interfaces may be to be considered as bonding
  * candidates
  */
 #define BATADV_BONDING_TQ_THRESHOLD	50
 /* should not be bigger than 512 bytes or change the size of
  * forw_packet->direct_link_flags
  */
 #define BATADV_MAX_AGGREGATION_BYTES 512
 #define BATADV_MAX_AGGREGATION_MS 100
 #define BATADV_BLA_PERIOD_LENGTH	10000	/* 10 seconds */
 #define BATADV_BLA_BACKBONE_TIMEOUT	(BATADV_BLA_PERIOD_LENGTH * 3)
 #define BATADV_BLA_CLAIM_TIMEOUT	(BATADV_BLA_PERIOD_LENGTH * 10)
 #define BATADV_DUPLIST_SIZE		16
 #define BATADV_DUPLIST_TIMEOUT		500	/* 500 ms */
 /* don't reset again within 30 seconds */
 #define BATADV_RESET_PROTECTION_MS 30000
 #define BATADV_EXPECTED_SEQNO_RANGE	65536
 enum batadv_mesh_state {
 	BATADV_MESH_INACTIVE,
 	BATADV_MESH_ACTIVE,
 	BATADV_MESH_DEACTIVATING,
 };
 #define BATADV_BCAST_QUEUE_LEN		256
 #define BATADV_BATMAN_QUEUE_LEN	256
 enum batadv_uev_action {
 	BATADV_UEV_ADD = 0,
 	BATADV_UEV_DEL,
 	BATADV_UEV_CHANGE,
 };
 enum batadv_uev_type {
 	BATADV_UEV_GW = 0,
 };
 #define BATADV_GW_THRESHOLD	50
 /* Debug Messages */
 #ifdef pr_fmt
 #undef pr_fmt
 #endif
 /* Append 'batman-adv: ' before kernel messages */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 /* Kernel headers */
 #include <linux/mutex.h>	/* mutex */
 #include <linux/module.h>	/* needed by all modules */
 #include <linux/netdevice.h>	/* netdevice */
 #include <linux/etherdevice.h>  /* ethernet address classification */
 #include <linux/if_ether.h>	/* ethernet header */
 #include <linux/poll.h>		/* poll_table */
 #include <linux/kthread.h>	/* kernel threads */
 #include <linux/pkt_sched.h>	/* schedule types */
 #include <linux/workqueue.h>	/* workqueue */
 #include <linux/percpu.h>
 #include <linux/slab.h>
 #include <net/sock.h>		/* struct sock */
 #include <linux/jiffies.h>
 #include <linux/seq_file.h>
 #include "types.h"
 extern char batadv_routing_algo[];
 extern struct list_head batadv_hardif_list;
 extern unsigned char batadv_broadcast_addr[];
 extern struct workqueue_struct *batadv_event_workqueue;
 int batadv_mesh_init(struct net_device *soft_iface);
 void batadv_mesh_free(struct net_device *soft_iface);
 void batadv_inc_module_count(void);
 void batadv_dec_module_count(void);
 int batadv_is_my_mac(const uint8_t *addr);
+struct batadv_hard_iface *
+batadv_seq_print_text_primary_if_get(struct seq_file *seq);
 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
 			   struct packet_type *ptype,
 			   struct net_device *orig_dev);
 int
 batadv_recv_handler_register(uint8_t packet_type,
 			     int (*recv_handler)(struct sk_buff *,
 						 struct batadv_hard_iface *));
 void batadv_recv_handler_unregister(uint8_t packet_type);
 int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops);
 int batadv_algo_select(struct batadv_priv *bat_priv, char *name);
 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset);
 /* all messages related to routing / flooding / broadcasting / etc */
 enum batadv_dbg_level {
 	BATADV_DBG_BATMAN = BIT(0),
 	BATADV_DBG_ROUTES = BIT(1), /* route added / changed / deleted */
 	BATADV_DBG_TT	  = BIT(2), /* translation table operations */
 	BATADV_DBG_BLA    = BIT(3), /* bridge loop avoidance */
 	BATADV_DBG_ALL    = 15,
 };
 #ifdef CONFIG_BATMAN_ADV_DEBUG
 int batadv_debug_log(struct batadv_priv *bat_priv, const char *fmt, ...)
 __printf(2, 3);
 #define batadv_dbg(type, bat_priv, fmt, arg...)			\
 	do {							\
 		if (atomic_read(&bat_priv->log_level) & type)	\
 			batadv_debug_log(bat_priv, fmt, ## arg);\
 	}							\
 	while (0)
 #else /* !CONFIG_BATMAN_ADV_DEBUG */
 __printf(3, 4)
 static inline void batadv_dbg(int type __always_unused,
 			      struct batadv_priv *bat_priv __always_unused,
 			      const char *fmt __always_unused, ...)
 {
 }
 #endif
 #define batadv_info(net_dev, fmt, arg...)				\
 	do {								\
 		struct net_device *_netdev = (net_dev);                 \
 		struct batadv_priv *_batpriv = netdev_priv(_netdev);    \
 		batadv_dbg(BATADV_DBG_ALL, _batpriv, fmt, ## arg);	\
 		pr_info("%s: " fmt, _netdev->name, ## arg);		\
 	} while (0)
 #define batadv_err(net_dev, fmt, arg...)				\
 	do {								\
 		struct net_device *_netdev = (net_dev);                 \
 		struct batadv_priv *_batpriv = netdev_priv(_netdev);    \
 		batadv_dbg(BATADV_DBG_ALL, _batpriv, fmt, ## arg);	\
 		pr_err("%s: " fmt, _netdev->name, ## arg);		\
 	} while (0)
 /* returns 1 if they are the same ethernet addr
  *
  * note: can't use compare_ether_addr() as it requires aligned memory
  */
 static inline int batadv_compare_eth(const void *data1, const void *data2)
 {
 	return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
 }
 /**
  * has_timed_out - compares current time (jiffies) and timestamp + timeout
  * @timestamp:		base value to compare with (in jiffies)
  * @timeout:		added to base value before comparing (in milliseconds)
  *
  * Returns true if current time is after timestamp + timeout
  */
 static inline bool batadv_has_timed_out(unsigned long timestamp,
 					unsigned int timeout)
 {
 	return time_is_before_jiffies(timestamp + msecs_to_jiffies(timeout));
 }
 #define batadv_atomic_dec_not_zero(v)	atomic_add_unless((v), -1, 0)
 /* Returns the smallest signed integer in two's complement with the sizeof x */
 #define batadv_smallest_signed_int(x) (1u << (7u + 8u * (sizeof(x) - 1u)))
 /* Checks if a sequence number x is a predecessor/successor of y.
  * they handle overflows/underflows and can correctly check for a
  * predecessor/successor unless the variable sequence number has grown by
  * more then 2**(bitwidth(x)-1)-1.
  * This means that for a uint8_t with the maximum value 255, it would think:
  *  - when adding nothing - it is neither a predecessor nor a successor
  *  - before adding more than 127 to the starting value - it is a predecessor,
  *  - when adding 128 - it is neither a predecessor nor a successor,
  *  - after adding more than 127 to the starting value - it is a successor
  */
 #define batadv_seq_before(x, y) ({typeof(x) _d1 = (x); \
 				 typeof(y) _d2 = (y); \
 				 typeof(x) _dummy = (_d1 - _d2); \
 				 (void) (&_d1 == &_d2); \
 				 _dummy > batadv_smallest_signed_int(_dummy); })
 #define batadv_seq_after(x, y) batadv_seq_before(y, x)
 /* Stop preemption on local cpu while incrementing the counter */
 static inline void batadv_add_counter(struct batadv_priv *bat_priv, size_t idx,
 				      size_t count)
 {
 	int cpu = get_cpu();
 	per_cpu_ptr(bat_priv->bat_counters, cpu)[idx] += count;
 	put_cpu();
 }
 #define batadv_inc_counter(b, i) batadv_add_counter(b, i, 1)
 /* Sum and return the cpu-local counters for index 'idx' */
 static inline uint64_t batadv_sum_counter(struct batadv_priv *bat_priv,
 					  size_t idx)
 {
 	uint64_t *counters, sum = 0;
 	int cpu;
 	for_each_possible_cpu(cpu) {
 		counters = per_cpu_ptr(bat_priv->bat_counters, cpu);
 		sum += counters[idx];
 	}
 	return sum;
 }
 #endif /* _NET_BATMAN_ADV_MAIN_H_ */

net/batman-adv/originator.c

Diff comments View file @ 30da63a

1	/* Copyright (C) 2009-2012 B.A.T.M.A.N. contributors:	1	/* Copyright (C) 2009-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 "originator.h"	21	#include "originator.h"
22	#include "hash.h"	22	#include "hash.h"
23	#include "translation-table.h"	23	#include "translation-table.h"
24	#include "routing.h"	24	#include "routing.h"
25	#include "gateway_client.h"	25	#include "gateway_client.h"
26	#include "hard-interface.h"	26	#include "hard-interface.h"
27	#include "unicast.h"	27	#include "unicast.h"
28	#include "soft-interface.h"	28	#include "soft-interface.h"
29	#include "bridge_loop_avoidance.h"	29	#include "bridge_loop_avoidance.h"
30		30
31	static void batadv_purge_orig(struct work_struct *work);	31	static void batadv_purge_orig(struct work_struct *work);
32		32
33	static void batadv_start_purge_timer(struct batadv_priv *bat_priv)	33	static void batadv_start_purge_timer(struct batadv_priv *bat_priv)
34	{	34	{
35	INIT_DELAYED_WORK(&bat_priv->orig_work, batadv_purge_orig);	35	INIT_DELAYED_WORK(&bat_priv->orig_work, batadv_purge_orig);
36	queue_delayed_work(batadv_event_workqueue,	36	queue_delayed_work(batadv_event_workqueue,
37	&bat_priv->orig_work, msecs_to_jiffies(1000));	37	&bat_priv->orig_work, msecs_to_jiffies(1000));
38	}	38	}
39		39
40	/* returns 1 if they are the same originator */	40	/* returns 1 if they are the same originator */
41	static int batadv_compare_orig(const struct hlist_node node, const void data2)	41	static int batadv_compare_orig(const struct hlist_node node, const void data2)
42	{	42	{
43	const void *data1 = container_of(node, struct batadv_orig_node,	43	const void *data1 = container_of(node, struct batadv_orig_node,
44	hash_entry);	44	hash_entry);
45		45
46	return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);	46	return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
47	}	47	}
48		48
49	int batadv_originator_init(struct batadv_priv *bat_priv)	49	int batadv_originator_init(struct batadv_priv *bat_priv)
50	{	50	{
51	if (bat_priv->orig_hash)	51	if (bat_priv->orig_hash)
52	return 0;	52	return 0;
53		53
54	bat_priv->orig_hash = batadv_hash_new(1024);	54	bat_priv->orig_hash = batadv_hash_new(1024);
55		55
56	if (!bat_priv->orig_hash)	56	if (!bat_priv->orig_hash)
57	goto err;	57	goto err;
58		58
59	batadv_start_purge_timer(bat_priv);	59	batadv_start_purge_timer(bat_priv);
60	return 0;	60	return 0;
61		61
62	err:	62	err:
63	return -ENOMEM;	63	return -ENOMEM;
64	}	64	}
65		65
66	void batadv_neigh_node_free_ref(struct batadv_neigh_node *neigh_node)	66	void batadv_neigh_node_free_ref(struct batadv_neigh_node *neigh_node)
67	{	67	{
68	if (atomic_dec_and_test(&neigh_node->refcount))	68	if (atomic_dec_and_test(&neigh_node->refcount))
69	kfree_rcu(neigh_node, rcu);	69	kfree_rcu(neigh_node, rcu);
70	}	70	}
71		71
72	/* increases the refcounter of a found router */	72	/* increases the refcounter of a found router */
73	struct batadv_neigh_node *	73	struct batadv_neigh_node *
74	batadv_orig_node_get_router(struct batadv_orig_node *orig_node)	74	batadv_orig_node_get_router(struct batadv_orig_node *orig_node)
75	{	75	{
76	struct batadv_neigh_node *router;	76	struct batadv_neigh_node *router;
77		77
78	rcu_read_lock();	78	rcu_read_lock();
79	router = rcu_dereference(orig_node->router);	79	router = rcu_dereference(orig_node->router);
80		80
81	if (router && !atomic_inc_not_zero(&router->refcount))	81	if (router && !atomic_inc_not_zero(&router->refcount))
82	router = NULL;	82	router = NULL;
83		83
84	rcu_read_unlock();	84	rcu_read_unlock();
85	return router;	85	return router;
86	}	86	}
87		87
88	struct batadv_neigh_node *	88	struct batadv_neigh_node *
89	batadv_neigh_node_new(struct batadv_hard_iface *hard_iface,	89	batadv_neigh_node_new(struct batadv_hard_iface *hard_iface,
90	const uint8_t *neigh_addr, uint32_t seqno)	90	const uint8_t *neigh_addr, uint32_t seqno)
91	{	91	{
92	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);	92	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
93	struct batadv_neigh_node *neigh_node;	93	struct batadv_neigh_node *neigh_node;
94		94
95	neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);	95	neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
96	if (!neigh_node)	96	if (!neigh_node)
97	goto out;	97	goto out;
98		98
99	INIT_HLIST_NODE(&neigh_node->list);	99	INIT_HLIST_NODE(&neigh_node->list);
100		100
101	memcpy(neigh_node->addr, neigh_addr, ETH_ALEN);	101	memcpy(neigh_node->addr, neigh_addr, ETH_ALEN);
102	spin_lock_init(&neigh_node->lq_update_lock);	102	spin_lock_init(&neigh_node->lq_update_lock);
103		103
104	/* extra reference for return */	104	/* extra reference for return */
105	atomic_set(&neigh_node->refcount, 2);	105	atomic_set(&neigh_node->refcount, 2);
106		106
107	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,	107	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
108	"Creating new neighbor %pM, initial seqno %d\n",	108	"Creating new neighbor %pM, initial seqno %d\n",
109	neigh_addr, seqno);	109	neigh_addr, seqno);
110		110
111	out:	111	out:
112	return neigh_node;	112	return neigh_node;
113	}	113	}
114		114
115	static void batadv_orig_node_free_rcu(struct rcu_head *rcu)	115	static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
116	{	116	{
117	struct hlist_node node, node_tmp;	117	struct hlist_node node, node_tmp;
118	struct batadv_neigh_node neigh_node, tmp_neigh_node;	118	struct batadv_neigh_node neigh_node, tmp_neigh_node;
119	struct batadv_orig_node *orig_node;	119	struct batadv_orig_node *orig_node;
120		120
121	orig_node = container_of(rcu, struct batadv_orig_node, rcu);	121	orig_node = container_of(rcu, struct batadv_orig_node, rcu);
122		122
123	spin_lock_bh(&orig_node->neigh_list_lock);	123	spin_lock_bh(&orig_node->neigh_list_lock);
124		124
125	/* for all bonding members ... */	125	/* for all bonding members ... */
126	list_for_each_entry_safe(neigh_node, tmp_neigh_node,	126	list_for_each_entry_safe(neigh_node, tmp_neigh_node,
127	&orig_node->bond_list, bonding_list) {	127	&orig_node->bond_list, bonding_list) {
128	list_del_rcu(&neigh_node->bonding_list);	128	list_del_rcu(&neigh_node->bonding_list);
129	batadv_neigh_node_free_ref(neigh_node);	129	batadv_neigh_node_free_ref(neigh_node);
130	}	130	}
131		131
132	/* for all neighbors towards this originator ... */	132	/* for all neighbors towards this originator ... */
133	hlist_for_each_entry_safe(neigh_node, node, node_tmp,	133	hlist_for_each_entry_safe(neigh_node, node, node_tmp,
134	&orig_node->neigh_list, list) {	134	&orig_node->neigh_list, list) {
135	hlist_del_rcu(&neigh_node->list);	135	hlist_del_rcu(&neigh_node->list);
136	batadv_neigh_node_free_ref(neigh_node);	136	batadv_neigh_node_free_ref(neigh_node);
137	}	137	}
138		138
139	spin_unlock_bh(&orig_node->neigh_list_lock);	139	spin_unlock_bh(&orig_node->neigh_list_lock);
140		140
141	batadv_frag_list_free(&orig_node->frag_list);	141	batadv_frag_list_free(&orig_node->frag_list);
142	batadv_tt_global_del_orig(orig_node->bat_priv, orig_node,	142	batadv_tt_global_del_orig(orig_node->bat_priv, orig_node,
143	"originator timed out");	143	"originator timed out");
144		144
145	kfree(orig_node->tt_buff);	145	kfree(orig_node->tt_buff);
146	kfree(orig_node->bcast_own);	146	kfree(orig_node->bcast_own);
147	kfree(orig_node->bcast_own_sum);	147	kfree(orig_node->bcast_own_sum);
148	kfree(orig_node);	148	kfree(orig_node);
149	}	149	}
150		150
151	void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node)	151	void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node)
152	{	152	{
153	if (atomic_dec_and_test(&orig_node->refcount))	153	if (atomic_dec_and_test(&orig_node->refcount))
154	call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu);	154	call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu);
155	}	155	}
156		156
157	void batadv_originator_free(struct batadv_priv *bat_priv)	157	void batadv_originator_free(struct batadv_priv *bat_priv)
158	{	158	{
159	struct batadv_hashtable *hash = bat_priv->orig_hash;	159	struct batadv_hashtable *hash = bat_priv->orig_hash;
160	struct hlist_node node, node_tmp;	160	struct hlist_node node, node_tmp;
161	struct hlist_head *head;	161	struct hlist_head *head;
162	spinlock_t list_lock; / spinlock to protect write access */	162	spinlock_t list_lock; / spinlock to protect write access */
163	struct batadv_orig_node *orig_node;	163	struct batadv_orig_node *orig_node;
164	uint32_t i;	164	uint32_t i;
165		165
166	if (!hash)	166	if (!hash)
167	return;	167	return;
168		168
169	cancel_delayed_work_sync(&bat_priv->orig_work);	169	cancel_delayed_work_sync(&bat_priv->orig_work);
170		170
171	bat_priv->orig_hash = NULL;	171	bat_priv->orig_hash = NULL;
172		172
173	for (i = 0; i < hash->size; i++) {	173	for (i = 0; i < hash->size; i++) {
174	head = &hash->table[i];	174	head = &hash->table[i];
175	list_lock = &hash->list_locks[i];	175	list_lock = &hash->list_locks[i];
176		176
177	spin_lock_bh(list_lock);	177	spin_lock_bh(list_lock);
178	hlist_for_each_entry_safe(orig_node, node, node_tmp,	178	hlist_for_each_entry_safe(orig_node, node, node_tmp,
179	head, hash_entry) {	179	head, hash_entry) {
180		180
181	hlist_del_rcu(node);	181	hlist_del_rcu(node);
182	batadv_orig_node_free_ref(orig_node);	182	batadv_orig_node_free_ref(orig_node);
183	}	183	}
184	spin_unlock_bh(list_lock);	184	spin_unlock_bh(list_lock);
185	}	185	}
186		186
187	batadv_hash_destroy(hash);	187	batadv_hash_destroy(hash);
188	}	188	}
189		189
190	/* this function finds or creates an originator entry for the given	190	/* this function finds or creates an originator entry for the given
191	* address if it does not exits	191	* address if it does not exits
192	*/	192	*/
193	struct batadv_orig_node batadv_get_orig_node(struct batadv_priv bat_priv,	193	struct batadv_orig_node batadv_get_orig_node(struct batadv_priv bat_priv,
194	const uint8_t *addr)	194	const uint8_t *addr)
195	{	195	{
196	struct batadv_orig_node *orig_node;	196	struct batadv_orig_node *orig_node;
197	int size;	197	int size;
198	int hash_added;	198	int hash_added;
199	unsigned long reset_time;	199	unsigned long reset_time;
200		200
201	orig_node = batadv_orig_hash_find(bat_priv, addr);	201	orig_node = batadv_orig_hash_find(bat_priv, addr);
202	if (orig_node)	202	if (orig_node)
203	return orig_node;	203	return orig_node;
204		204
205	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,	205	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
206	"Creating new originator: %pM\n", addr);	206	"Creating new originator: %pM\n", addr);
207		207
208	orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);	208	orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
209	if (!orig_node)	209	if (!orig_node)
210	return NULL;	210	return NULL;
211		211
212	INIT_HLIST_HEAD(&orig_node->neigh_list);	212	INIT_HLIST_HEAD(&orig_node->neigh_list);
213	INIT_LIST_HEAD(&orig_node->bond_list);	213	INIT_LIST_HEAD(&orig_node->bond_list);
214	spin_lock_init(&orig_node->ogm_cnt_lock);	214	spin_lock_init(&orig_node->ogm_cnt_lock);
215	spin_lock_init(&orig_node->bcast_seqno_lock);	215	spin_lock_init(&orig_node->bcast_seqno_lock);
216	spin_lock_init(&orig_node->neigh_list_lock);	216	spin_lock_init(&orig_node->neigh_list_lock);
217	spin_lock_init(&orig_node->tt_buff_lock);	217	spin_lock_init(&orig_node->tt_buff_lock);
218		218
219	/* extra reference for return */	219	/* extra reference for return */
220	atomic_set(&orig_node->refcount, 2);	220	atomic_set(&orig_node->refcount, 2);
221		221
222	orig_node->tt_initialised = false;	222	orig_node->tt_initialised = false;
223	orig_node->tt_poss_change = false;	223	orig_node->tt_poss_change = false;
224	orig_node->bat_priv = bat_priv;	224	orig_node->bat_priv = bat_priv;
225	memcpy(orig_node->orig, addr, ETH_ALEN);	225	memcpy(orig_node->orig, addr, ETH_ALEN);
226	orig_node->router = NULL;	226	orig_node->router = NULL;
227	orig_node->tt_crc = 0;	227	orig_node->tt_crc = 0;
228	atomic_set(&orig_node->last_ttvn, 0);	228	atomic_set(&orig_node->last_ttvn, 0);
229	orig_node->tt_buff = NULL;	229	orig_node->tt_buff = NULL;
230	orig_node->tt_buff_len = 0;	230	orig_node->tt_buff_len = 0;
231	atomic_set(&orig_node->tt_size, 0);	231	atomic_set(&orig_node->tt_size, 0);
232	reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);	232	reset_time = jiffies - 1 - msecs_to_jiffies(BATADV_RESET_PROTECTION_MS);
233	orig_node->bcast_seqno_reset = reset_time;	233	orig_node->bcast_seqno_reset = reset_time;
234	orig_node->batman_seqno_reset = reset_time;	234	orig_node->batman_seqno_reset = reset_time;
235		235
236	atomic_set(&orig_node->bond_candidates, 0);	236	atomic_set(&orig_node->bond_candidates, 0);
237		237
238	size = bat_priv->num_ifaces * sizeof(unsigned long) * BATADV_NUM_WORDS;	238	size = bat_priv->num_ifaces * sizeof(unsigned long) * BATADV_NUM_WORDS;
239		239
240	orig_node->bcast_own = kzalloc(size, GFP_ATOMIC);	240	orig_node->bcast_own = kzalloc(size, GFP_ATOMIC);
241	if (!orig_node->bcast_own)	241	if (!orig_node->bcast_own)
242	goto free_orig_node;	242	goto free_orig_node;
243		243
244	size = bat_priv->num_ifaces * sizeof(uint8_t);	244	size = bat_priv->num_ifaces * sizeof(uint8_t);
245	orig_node->bcast_own_sum = kzalloc(size, GFP_ATOMIC);	245	orig_node->bcast_own_sum = kzalloc(size, GFP_ATOMIC);
246		246
247	INIT_LIST_HEAD(&orig_node->frag_list);	247	INIT_LIST_HEAD(&orig_node->frag_list);
248	orig_node->last_frag_packet = 0;	248	orig_node->last_frag_packet = 0;
249		249
250	if (!orig_node->bcast_own_sum)	250	if (!orig_node->bcast_own_sum)
251	goto free_bcast_own;	251	goto free_bcast_own;
252		252
253	hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,	253	hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,
254	batadv_choose_orig, orig_node,	254	batadv_choose_orig, orig_node,
255	&orig_node->hash_entry);	255	&orig_node->hash_entry);
256	if (hash_added != 0)	256	if (hash_added != 0)
257	goto free_bcast_own_sum;	257	goto free_bcast_own_sum;
258		258
259	return orig_node;	259	return orig_node;
260	free_bcast_own_sum:	260	free_bcast_own_sum:
261	kfree(orig_node->bcast_own_sum);	261	kfree(orig_node->bcast_own_sum);
262	free_bcast_own:	262	free_bcast_own:
263	kfree(orig_node->bcast_own);	263	kfree(orig_node->bcast_own);
264	free_orig_node:	264	free_orig_node:
265	kfree(orig_node);	265	kfree(orig_node);
266	return NULL;	266	return NULL;
267	}	267	}
268		268
269	static bool	269	static bool
270	batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,	270	batadv_purge_orig_neighbors(struct batadv_priv *bat_priv,
271	struct batadv_orig_node *orig_node,	271	struct batadv_orig_node *orig_node,
272	struct batadv_neigh_node **best_neigh_node)	272	struct batadv_neigh_node **best_neigh_node)
273	{	273	{
274	struct hlist_node node, node_tmp;	274	struct hlist_node node, node_tmp;
275	struct batadv_neigh_node *neigh_node;	275	struct batadv_neigh_node *neigh_node;
276	bool neigh_purged = false;	276	bool neigh_purged = false;
277	unsigned long last_seen;	277	unsigned long last_seen;
278	struct batadv_hard_iface *if_incoming;	278	struct batadv_hard_iface *if_incoming;
279		279
280	*best_neigh_node = NULL;	280	*best_neigh_node = NULL;
281		281
282	spin_lock_bh(&orig_node->neigh_list_lock);	282	spin_lock_bh(&orig_node->neigh_list_lock);
283		283
284	/* for all neighbors towards this originator ... */	284	/* for all neighbors towards this originator ... */
285	hlist_for_each_entry_safe(neigh_node, node, node_tmp,	285	hlist_for_each_entry_safe(neigh_node, node, node_tmp,
286	&orig_node->neigh_list, list) {	286	&orig_node->neigh_list, list) {
287		287
288	last_seen = neigh_node->last_seen;	288	last_seen = neigh_node->last_seen;
289	if_incoming = neigh_node->if_incoming;	289	if_incoming = neigh_node->if_incoming;
290		290
291	if ((batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT)) \|\|	291	if ((batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT)) \|\|
292	(if_incoming->if_status == BATADV_IF_INACTIVE) \|\|	292	(if_incoming->if_status == BATADV_IF_INACTIVE) \|\|
293	(if_incoming->if_status == BATADV_IF_NOT_IN_USE) \|\|	293	(if_incoming->if_status == BATADV_IF_NOT_IN_USE) \|\|
294	(if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) {	294	(if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) {
295		295
296	if ((if_incoming->if_status == BATADV_IF_INACTIVE) \|\|	296	if ((if_incoming->if_status == BATADV_IF_INACTIVE) \|\|
297	(if_incoming->if_status == BATADV_IF_NOT_IN_USE) \|\|	297	(if_incoming->if_status == BATADV_IF_NOT_IN_USE) \|\|
298	(if_incoming->if_status == BATADV_IF_TO_BE_REMOVED))	298	(if_incoming->if_status == BATADV_IF_TO_BE_REMOVED))
299	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,	299	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
300	"neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",	300	"neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",
301	orig_node->orig, neigh_node->addr,	301	orig_node->orig, neigh_node->addr,
302	if_incoming->net_dev->name);	302	if_incoming->net_dev->name);
303	else	303	else
304	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,	304	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
305	"neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",	305	"neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",
306	orig_node->orig, neigh_node->addr,	306	orig_node->orig, neigh_node->addr,
307	jiffies_to_msecs(last_seen));	307	jiffies_to_msecs(last_seen));
308		308
309	neigh_purged = true;	309	neigh_purged = true;
310		310
311	hlist_del_rcu(&neigh_node->list);	311	hlist_del_rcu(&neigh_node->list);
312	batadv_bonding_candidate_del(orig_node, neigh_node);	312	batadv_bonding_candidate_del(orig_node, neigh_node);
313	batadv_neigh_node_free_ref(neigh_node);	313	batadv_neigh_node_free_ref(neigh_node);
314	} else {	314	} else {
315	if ((!*best_neigh_node) \|\|	315	if ((!*best_neigh_node) \|\|
316	(neigh_node->tq_avg > (*best_neigh_node)->tq_avg))	316	(neigh_node->tq_avg > (*best_neigh_node)->tq_avg))
317	*best_neigh_node = neigh_node;	317	*best_neigh_node = neigh_node;
318	}	318	}
319	}	319	}
320		320
321	spin_unlock_bh(&orig_node->neigh_list_lock);	321	spin_unlock_bh(&orig_node->neigh_list_lock);
322	return neigh_purged;	322	return neigh_purged;
323	}	323	}
324		324
325	static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,	325	static bool batadv_purge_orig_node(struct batadv_priv *bat_priv,
326	struct batadv_orig_node *orig_node)	326	struct batadv_orig_node *orig_node)
327	{	327	{
328	struct batadv_neigh_node *best_neigh_node;	328	struct batadv_neigh_node *best_neigh_node;
329		329
330	if (batadv_has_timed_out(orig_node->last_seen,	330	if (batadv_has_timed_out(orig_node->last_seen,
331	2 * BATADV_PURGE_TIMEOUT)) {	331	2 * BATADV_PURGE_TIMEOUT)) {
332	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,	332	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
333	"Originator timeout: originator %pM, last_seen %u\n",	333	"Originator timeout: originator %pM, last_seen %u\n",
334	orig_node->orig,	334	orig_node->orig,
335	jiffies_to_msecs(orig_node->last_seen));	335	jiffies_to_msecs(orig_node->last_seen));
336	return true;	336	return true;
337	} else {	337	} else {
338	if (batadv_purge_orig_neighbors(bat_priv, orig_node,	338	if (batadv_purge_orig_neighbors(bat_priv, orig_node,
339	&best_neigh_node))	339	&best_neigh_node))
340	batadv_update_route(bat_priv, orig_node,	340	batadv_update_route(bat_priv, orig_node,
341	best_neigh_node);	341	best_neigh_node);
342	}	342	}
343		343
344	return false;	344	return false;
345	}	345	}
346		346
347	static void _batadv_purge_orig(struct batadv_priv *bat_priv)	347	static void _batadv_purge_orig(struct batadv_priv *bat_priv)
348	{	348	{
349	struct batadv_hashtable *hash = bat_priv->orig_hash;	349	struct batadv_hashtable *hash = bat_priv->orig_hash;
350	struct hlist_node node, node_tmp;	350	struct hlist_node node, node_tmp;
351	struct hlist_head *head;	351	struct hlist_head *head;
352	spinlock_t list_lock; / spinlock to protect write access */	352	spinlock_t list_lock; / spinlock to protect write access */
353	struct batadv_orig_node *orig_node;	353	struct batadv_orig_node *orig_node;
354	uint32_t i;	354	uint32_t i;
355		355
356	if (!hash)	356	if (!hash)
357	return;	357	return;
358		358
359	/* for all origins... */	359	/* for all origins... */
360	for (i = 0; i < hash->size; i++) {	360	for (i = 0; i < hash->size; i++) {
361	head = &hash->table[i];	361	head = &hash->table[i];
362	list_lock = &hash->list_locks[i];	362	list_lock = &hash->list_locks[i];
363		363
364	spin_lock_bh(list_lock);	364	spin_lock_bh(list_lock);
365	hlist_for_each_entry_safe(orig_node, node, node_tmp,	365	hlist_for_each_entry_safe(orig_node, node, node_tmp,
366	head, hash_entry) {	366	head, hash_entry) {
367	if (batadv_purge_orig_node(bat_priv, orig_node)) {	367	if (batadv_purge_orig_node(bat_priv, orig_node)) {
368	if (orig_node->gw_flags)	368	if (orig_node->gw_flags)
369	batadv_gw_node_delete(bat_priv,	369	batadv_gw_node_delete(bat_priv,
370	orig_node);	370	orig_node);
371	hlist_del_rcu(node);	371	hlist_del_rcu(node);
372	batadv_orig_node_free_ref(orig_node);	372	batadv_orig_node_free_ref(orig_node);
373	continue;	373	continue;
374	}	374	}
375		375
376	if (batadv_has_timed_out(orig_node->last_frag_packet,	376	if (batadv_has_timed_out(orig_node->last_frag_packet,
377	BATADV_FRAG_TIMEOUT))	377	BATADV_FRAG_TIMEOUT))
378	batadv_frag_list_free(&orig_node->frag_list);	378	batadv_frag_list_free(&orig_node->frag_list);
379	}	379	}
380	spin_unlock_bh(list_lock);	380	spin_unlock_bh(list_lock);
381	}	381	}
382		382
383	batadv_gw_node_purge(bat_priv);	383	batadv_gw_node_purge(bat_priv);
384	batadv_gw_election(bat_priv);	384	batadv_gw_election(bat_priv);
385	}	385	}
386		386
387	static void batadv_purge_orig(struct work_struct *work)	387	static void batadv_purge_orig(struct work_struct *work)
388	{	388	{
389	struct delayed_work *delayed_work;	389	struct delayed_work *delayed_work;
390	struct batadv_priv *bat_priv;	390	struct batadv_priv *bat_priv;
391		391
392	delayed_work = container_of(work, struct delayed_work, work);	392	delayed_work = container_of(work, struct delayed_work, work);
393	bat_priv = container_of(delayed_work, struct batadv_priv, orig_work);	393	bat_priv = container_of(delayed_work, struct batadv_priv, orig_work);
394	_batadv_purge_orig(bat_priv);	394	_batadv_purge_orig(bat_priv);
395	batadv_start_purge_timer(bat_priv);	395	batadv_start_purge_timer(bat_priv);
396	}	396	}
397		397
398	void batadv_purge_orig_ref(struct batadv_priv *bat_priv)	398	void batadv_purge_orig_ref(struct batadv_priv *bat_priv)
399	{	399	{
400	_batadv_purge_orig(bat_priv);	400	_batadv_purge_orig(bat_priv);
401	}	401	}
402		402
403	int batadv_orig_seq_print_text(struct seq_file seq, void offset)	403	int batadv_orig_seq_print_text(struct seq_file seq, void offset)
404	{	404	{
405	struct net_device net_dev = (struct net_device )seq->private;	405	struct net_device net_dev = (struct net_device )seq->private;
406	struct batadv_priv *bat_priv = netdev_priv(net_dev);	406	struct batadv_priv *bat_priv = netdev_priv(net_dev);
407	struct batadv_hashtable *hash = bat_priv->orig_hash;	407	struct batadv_hashtable *hash = bat_priv->orig_hash;
408	struct hlist_node node, node_tmp;	408	struct hlist_node node, node_tmp;
409	struct hlist_head *head;	409	struct hlist_head *head;
410	struct batadv_hard_iface *primary_if;	410	struct batadv_hard_iface *primary_if;
411	struct batadv_orig_node *orig_node;	411	struct batadv_orig_node *orig_node;
412	struct batadv_neigh_node neigh_node, neigh_node_tmp;	412	struct batadv_neigh_node neigh_node, neigh_node_tmp;
413	int batman_count = 0;	413	int batman_count = 0;
414	int last_seen_secs;	414	int last_seen_secs;
415	int last_seen_msecs;	415	int last_seen_msecs;
416	unsigned long last_seen_jiffies;	416	unsigned long last_seen_jiffies;
417	uint32_t i;	417	uint32_t i;
418	int ret = 0;
419		418
420	primary_if = batadv_primary_if_get_selected(bat_priv);	419	primary_if = batadv_seq_print_text_primary_if_get(seq);
421		420	if (!primary_if)
422	if (!primary_if) {
423	ret = seq_printf(seq,
424	"BATMAN mesh %s disabled - please specify interfaces to enable it\n",
425	net_dev->name);
426	goto out;	421	goto out;
427	}
428		422
429	if (primary_if->if_status != BATADV_IF_ACTIVE) {
430	ret = seq_printf(seq,
431	"BATMAN mesh %s disabled - primary interface not active\n",
432	net_dev->name);
433	goto out;
434	}
435
436	seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",	423	seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",
437	BATADV_SOURCE_VERSION, primary_if->net_dev->name,	424	BATADV_SOURCE_VERSION, primary_if->net_dev->name,
438	primary_if->net_dev->dev_addr, net_dev->name);	425	primary_if->net_dev->dev_addr, net_dev->name);
439	seq_printf(seq, " %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",	426	seq_printf(seq, " %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
440	"Originator", "last-seen", "#", BATADV_TQ_MAX_VALUE,	427	"Originator", "last-seen", "#", BATADV_TQ_MAX_VALUE,
441	"Nexthop", "outgoingIF", "Potential nexthops");	428	"Nexthop", "outgoingIF", "Potential nexthops");
442		429
443	for (i = 0; i < hash->size; i++) {	430	for (i = 0; i < hash->size; i++) {
444	head = &hash->table[i];	431	head = &hash->table[i];
445		432
446	rcu_read_lock();	433	rcu_read_lock();
447	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {	434	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
448	neigh_node = batadv_orig_node_get_router(orig_node);	435	neigh_node = batadv_orig_node_get_router(orig_node);
449	if (!neigh_node)	436	if (!neigh_node)
450	continue;	437	continue;
451		438
452	if (neigh_node->tq_avg == 0)	439	if (neigh_node->tq_avg == 0)
453	goto next;	440	goto next;
454		441
455	last_seen_jiffies = jiffies - orig_node->last_seen;	442	last_seen_jiffies = jiffies - orig_node->last_seen;
456	last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);	443	last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
457	last_seen_secs = last_seen_msecs / 1000;	444	last_seen_secs = last_seen_msecs / 1000;
458	last_seen_msecs = last_seen_msecs % 1000;	445	last_seen_msecs = last_seen_msecs % 1000;
459		446
460	seq_printf(seq, "%pM %4i.%03is (%3i) %pM [%10s]:",	447	seq_printf(seq, "%pM %4i.%03is (%3i) %pM [%10s]:",
461	orig_node->orig, last_seen_secs,	448	orig_node->orig, last_seen_secs,
462	last_seen_msecs, neigh_node->tq_avg,	449	last_seen_msecs, neigh_node->tq_avg,
463	neigh_node->addr,	450	neigh_node->addr,
464	neigh_node->if_incoming->net_dev->name);	451	neigh_node->if_incoming->net_dev->name);
465		452
466	hlist_for_each_entry_rcu(neigh_node_tmp, node_tmp,	453	hlist_for_each_entry_rcu(neigh_node_tmp, node_tmp,
467	&orig_node->neigh_list, list) {	454	&orig_node->neigh_list, list) {
468	seq_printf(seq, " %pM (%3i)",	455	seq_printf(seq, " %pM (%3i)",
469	neigh_node_tmp->addr,	456	neigh_node_tmp->addr,
470	neigh_node_tmp->tq_avg);	457	neigh_node_tmp->tq_avg);
471	}	458	}
472		459
473	seq_printf(seq, "\n");	460	seq_printf(seq, "\n");
474	batman_count++;	461	batman_count++;
475		462
476	next:	463	next:
477	batadv_neigh_node_free_ref(neigh_node);	464	batadv_neigh_node_free_ref(neigh_node);
478	}	465	}
479	rcu_read_unlock();	466	rcu_read_unlock();
480	}	467	}
481		468
482	if (batman_count == 0)	469	if (batman_count == 0)
483	seq_printf(seq, "No batman nodes in range ...\n");	470	seq_printf(seq, "No batman nodes in range ...\n");
484		471
485	out:	472	out:
486	if (primary_if)	473	if (primary_if)
487	batadv_hardif_free_ref(primary_if);	474	batadv_hardif_free_ref(primary_if);
488	return ret;	475	return 0;
489	}	476	}
490		477
491	static int batadv_orig_node_add_if(struct batadv_orig_node *orig_node,	478	static int batadv_orig_node_add_if(struct batadv_orig_node *orig_node,
492	int max_if_num)	479	int max_if_num)
493	{	480	{
494	void *data_ptr;	481	void *data_ptr;
495	size_t data_size, old_size;	482	size_t data_size, old_size;
496		483
497	data_size = max_if_num * sizeof(unsigned long) * BATADV_NUM_WORDS;	484	data_size = max_if_num * sizeof(unsigned long) * BATADV_NUM_WORDS;
498	old_size = (max_if_num - 1) * sizeof(unsigned long) * BATADV_NUM_WORDS;	485	old_size = (max_if_num - 1) * sizeof(unsigned long) * BATADV_NUM_WORDS;
499	data_ptr = kmalloc(data_size, GFP_ATOMIC);	486	data_ptr = kmalloc(data_size, GFP_ATOMIC);
500	if (!data_ptr)	487	if (!data_ptr)
501	return -ENOMEM;	488	return -ENOMEM;
502		489
503	memcpy(data_ptr, orig_node->bcast_own, old_size);	490	memcpy(data_ptr, orig_node->bcast_own, old_size);
504	kfree(orig_node->bcast_own);	491	kfree(orig_node->bcast_own);
505	orig_node->bcast_own = data_ptr;	492	orig_node->bcast_own = data_ptr;
506		493
507	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);	494	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
508	if (!data_ptr)	495	if (!data_ptr)
509	return -ENOMEM;	496	return -ENOMEM;
510		497
511	memcpy(data_ptr, orig_node->bcast_own_sum,	498	memcpy(data_ptr, orig_node->bcast_own_sum,
512	(max_if_num - 1) * sizeof(uint8_t));	499	(max_if_num - 1) * sizeof(uint8_t));
513	kfree(orig_node->bcast_own_sum);	500	kfree(orig_node->bcast_own_sum);
514	orig_node->bcast_own_sum = data_ptr;	501	orig_node->bcast_own_sum = data_ptr;
515		502
516	return 0;	503	return 0;
517	}	504	}
518		505
519	int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,	506	int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
520	int max_if_num)	507	int max_if_num)
521	{	508	{
522	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);	509	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
523	struct batadv_hashtable *hash = bat_priv->orig_hash;	510	struct batadv_hashtable *hash = bat_priv->orig_hash;
524	struct hlist_node *node;	511	struct hlist_node *node;
525	struct hlist_head *head;	512	struct hlist_head *head;
526	struct batadv_orig_node *orig_node;	513	struct batadv_orig_node *orig_node;
527	uint32_t i;	514	uint32_t i;
528	int ret;	515	int ret;
529		516
530	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on	517	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
531	* if_num	518	* if_num
532	*/	519	*/
533	for (i = 0; i < hash->size; i++) {	520	for (i = 0; i < hash->size; i++) {
534	head = &hash->table[i];	521	head = &hash->table[i];
535		522
536	rcu_read_lock();	523	rcu_read_lock();
537	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {	524	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
538	spin_lock_bh(&orig_node->ogm_cnt_lock);	525	spin_lock_bh(&orig_node->ogm_cnt_lock);
539	ret = batadv_orig_node_add_if(orig_node, max_if_num);	526	ret = batadv_orig_node_add_if(orig_node, max_if_num);
540	spin_unlock_bh(&orig_node->ogm_cnt_lock);	527	spin_unlock_bh(&orig_node->ogm_cnt_lock);
541		528
542	if (ret == -ENOMEM)	529	if (ret == -ENOMEM)
543	goto err;	530	goto err;
544	}	531	}
545	rcu_read_unlock();	532	rcu_read_unlock();
546	}	533	}
547		534
548	return 0;	535	return 0;
549		536
550	err:	537	err:
551	rcu_read_unlock();	538	rcu_read_unlock();
552	return -ENOMEM;	539	return -ENOMEM;
553	}	540	}
554		541
555	static int batadv_orig_node_del_if(struct batadv_orig_node *orig_node,	542	static int batadv_orig_node_del_if(struct batadv_orig_node *orig_node,
556	int max_if_num, int del_if_num)	543	int max_if_num, int del_if_num)
557	{	544	{
558	void *data_ptr = NULL;	545	void *data_ptr = NULL;
559	int chunk_size;	546	int chunk_size;
560		547
561	/* last interface was removed */	548	/* last interface was removed */
562	if (max_if_num == 0)	549	if (max_if_num == 0)
563	goto free_bcast_own;	550	goto free_bcast_own;
564		551
565	chunk_size = sizeof(unsigned long) * BATADV_NUM_WORDS;	552	chunk_size = sizeof(unsigned long) * BATADV_NUM_WORDS;
566	data_ptr = kmalloc(max_if_num * chunk_size, GFP_ATOMIC);	553	data_ptr = kmalloc(max_if_num * chunk_size, GFP_ATOMIC);
567	if (!data_ptr)	554	if (!data_ptr)
568	return -ENOMEM;	555	return -ENOMEM;
569		556
570	/* copy first part */	557	/* copy first part */
571	memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);	558	memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
572		559
573	/* copy second part */	560	/* copy second part */
574	memcpy((char )data_ptr + del_if_num chunk_size,	561	memcpy((char )data_ptr + del_if_num chunk_size,
575	orig_node->bcast_own + ((del_if_num + 1) * chunk_size),	562	orig_node->bcast_own + ((del_if_num + 1) * chunk_size),
576	(max_if_num - del_if_num) * chunk_size);	563	(max_if_num - del_if_num) * chunk_size);
577		564
578	free_bcast_own:	565	free_bcast_own:
579	kfree(orig_node->bcast_own);	566	kfree(orig_node->bcast_own);
580	orig_node->bcast_own = data_ptr;	567	orig_node->bcast_own = data_ptr;
581		568
582	if (max_if_num == 0)	569	if (max_if_num == 0)
583	goto free_own_sum;	570	goto free_own_sum;
584		571
585	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);	572	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
586	if (!data_ptr)	573	if (!data_ptr)
587	return -ENOMEM;	574	return -ENOMEM;
588		575
589	memcpy(data_ptr, orig_node->bcast_own_sum,	576	memcpy(data_ptr, orig_node->bcast_own_sum,
590	del_if_num * sizeof(uint8_t));	577	del_if_num * sizeof(uint8_t));
591		578
592	memcpy((char )data_ptr + del_if_num sizeof(uint8_t),	579	memcpy((char )data_ptr + del_if_num sizeof(uint8_t),
593	orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),	580	orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),
594	(max_if_num - del_if_num) * sizeof(uint8_t));	581	(max_if_num - del_if_num) * sizeof(uint8_t));
595		582
596	free_own_sum:	583	free_own_sum:
597	kfree(orig_node->bcast_own_sum);	584	kfree(orig_node->bcast_own_sum);
598	orig_node->bcast_own_sum = data_ptr;	585	orig_node->bcast_own_sum = data_ptr;
599		586
600	return 0;	587	return 0;
601	}	588	}
602		589
603	int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,	590	int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface,
604	int max_if_num)	591	int max_if_num)
605	{	592	{
606	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);	593	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
607	struct batadv_hashtable *hash = bat_priv->orig_hash;	594	struct batadv_hashtable *hash = bat_priv->orig_hash;
608	struct hlist_node *node;	595	struct hlist_node *node;
609	struct hlist_head *head;	596	struct hlist_head *head;
610	struct batadv_hard_iface *hard_iface_tmp;	597	struct batadv_hard_iface *hard_iface_tmp;
611	struct batadv_orig_node *orig_node;	598	struct batadv_orig_node *orig_node;
612	uint32_t i;	599	uint32_t i;
613	int ret;	600	int ret;
614		601
615	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on	602	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
616	* if_num	603	* if_num
617	*/	604	*/
618	for (i = 0; i < hash->size; i++) {	605	for (i = 0; i < hash->size; i++) {
619	head = &hash->table[i];	606	head = &hash->table[i];
620		607
621	rcu_read_lock();	608	rcu_read_lock();
622	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {	609	hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
623	spin_lock_bh(&orig_node->ogm_cnt_lock);	610	spin_lock_bh(&orig_node->ogm_cnt_lock);
624	ret = batadv_orig_node_del_if(orig_node, max_if_num,	611	ret = batadv_orig_node_del_if(orig_node, max_if_num,
625	hard_iface->if_num);	612	hard_iface->if_num);
626	spin_unlock_bh(&orig_node->ogm_cnt_lock);	613	spin_unlock_bh(&orig_node->ogm_cnt_lock);
627		614
628	if (ret == -ENOMEM)	615	if (ret == -ENOMEM)
629	goto err;	616	goto err;
630	}	617	}
631	rcu_read_unlock();	618	rcu_read_unlock();
632	}	619	}
633		620
634	/* renumber remaining batman interfaces _inside_ of orig_hash_lock */	621	/* renumber remaining batman interfaces _inside_ of orig_hash_lock */
635	rcu_read_lock();	622	rcu_read_lock();
636	list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) {	623	list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) {
637	if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE)	624	if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE)
638	continue;	625	continue;
639		626
640	if (hard_iface == hard_iface_tmp)	627	if (hard_iface == hard_iface_tmp)
641	continue;	628	continue;
642		629
643	if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)	630	if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)
644	continue;	631	continue;
645		632
646	if (hard_iface_tmp->if_num > hard_iface->if_num)	633	if (hard_iface_tmp->if_num > hard_iface->if_num)
647	hard_iface_tmp->if_num--;	634	hard_iface_tmp->if_num--;
648	}	635	}
649	rcu_read_unlock();	636	rcu_read_unlock();
650		637
651	hard_iface->if_num = -1;	638	hard_iface->if_num = -1;
652	return 0;	639	return 0;
653		640
654	err:	641	err:
655	rcu_read_unlock();	642	rcu_read_unlock();
656	return -ENOMEM;	643	return -ENOMEM;
657	}	644	}
658		645

net/batman-adv/translation-table.c

Diff comments View file @ 30da63a

 /* 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;
-	int ret = 0;
-	primary_if = batadv_primary_if_get_selected(bat_priv);
+	primary_if = batadv_seq_print_text_primary_if_get(seq);
-	if (!primary_if) {
+	if (!primary_if)
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
-				 net_dev->name);
 		goto out;
-	}
-	if (primary_if->if_status != BATADV_IF_ACTIVE) {
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - primary interface not active\n",
-				 net_dev->name);
-		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 ret;
+	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);
 }
 void 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;
 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
 	if (!tt_local_entry)
 		goto out;
 	flags = BATADV_TT_CLIENT_DEL;
 	if (roaming)
 		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);
 }
 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;
 	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;
 		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);
 out_remove:
 	/* remove address from local hash if present */
 	batadv_tt_local_remove(bat_priv, tt_global_entry->common.addr,
 			       "global tt received",
 			       flags & BATADV_TT_CLIENT_ROAM);
 	ret = 1;
 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;
-	int ret = 0;
-	primary_if = batadv_primary_if_get_selected(bat_priv);
+	primary_if = batadv_seq_print_text_primary_if_get(seq);
-	if (!primary_if) {
+	if (!primary_if)
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
-				 net_dev->name);
 		goto out;
-	}
-	if (primary_if->if_status != BATADV_IF_ACTIVE) {
-		ret = seq_printf(seq,
-				 "BATMAN mesh %s disabled - primary interface not active\n",
-				 net_dev->name);
-		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 ret;
+	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);
 	if (!skb)
 		goto out;
 	skb_reserve(skb, ETH_HLEN);
 	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);
 	if (!skb)
 		goto out;
 	skb_reserve(skb, ETH_HLEN);
 	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);
 		if (!skb)
 			goto unlock;
 		skb_reserve(skb, ETH_HLEN);
 		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);
 		if (!skb)
 			goto unlock;
 		skb_reserve(skb, ETH_HLEN);
 		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)
 		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);
 	if (!skb)
 		goto out;
 	skb_reserve(skb, ETH_HLEN);
 	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;
 }
 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,
 				  BATADV_TT_CLIENT_TEMP,
 				  atomic_read(&orig_node->last_ttvn)))
 		goto out;
 	batadv_dbg(BATADV_DBG_TT, bat_priv,
 		   "Added temporary global client (addr: %pM orig: %pM)\n",
 		   addr, orig_node->orig);
 	ret = true;
 out:
 	return ret;
 }