linux integration; branch, merge/master, updated. v3.4-rc1-1291-g1e1fd6f - commits - lists.open-mesh.org

3 Apr 2012

The following commit has been merged in the merge/master branch:
commit 7b78a2e0bf71e6eab1ac0a19a5f387ed9020848b
Merge: 9e32839083f5a2b6eef04bfd02846ed4e78fdc58 48798bf0b221a86fecfe5f1da7a9e470f278d76c
Author: Antonio Quartulli ordex@autistici.org
Date:   Sat Mar 31 14:20:56 2012 +0300
Merge remote-tracking branch 'origin/standalone/next' into merge/master
Conflicts:
    	net/batman-adv/CHANGELOG
    	net/batman-adv/Makefile
    	net/batman-adv/Makefile.kbuild
    	net/batman-adv/README
    	net/batman-adv/README.external
    	net/batman-adv/compat.c
    	net/batman-adv/compat.h
    	net/batman-adv/gen-compat-autoconf.sh
    	net/batman-adv/sysfs-class-net-mesh
diff --combined Documentation/ABI/testing/sysfs-class-net-mesh
index b218e0f,c81fe89..c81fe89

--- a/Documentation/ABI/testing/sysfs-class-net-mesh
+++ b/Documentation/ABI/testing/sysfs-class-net-mesh
@@@ -14,6 -14,15 +14,15 @@@ Description
                  mesh will be sent using multiple interfaces at the
                  same time (if available).
+ What:           /sys/class/net/<mesh_iface>/mesh/bridge_loop_avoidance
+ Date:           November 2011
+ Contact:        Simon Wunderlich siwu@hrz.tu-chemnitz.de
+ Description:
+                 Indicates whether the bridge loop avoidance feature
+                 is enabled. This feature detects and avoids loops
+                 between the mesh and devices bridged with the soft
+                 interface <mesh_iface>.
+ 
  What:           /sys/class/net/<mesh_iface>/mesh/fragmentation
  Date:           October 2010
  Contact:        Andreas Langer an.langer@gmx.de
diff --combined Documentation/networking/batman-adv.txt
index 01db663,4ee2f54..4ee2f54
--- a/Documentation/networking/batman-adv.txt
+++ b/Documentation/networking/batman-adv.txt
@@@ -65,18 -65,18 +65,18 @@@ To deactivate an interface you have  t
  All  mesh  wide  settings  can be found in batman's own interface
  folder:
- #  ls  /sys/class/net/bat0/mesh/
- # aggregated_ogms   fragmentation gw_sel_class   vis_mode
- # ap_isolation      gw_bandwidth  hop_penalty
- # bonding           gw_mode       orig_interval
+ # ls /sys/class/net/bat0/mesh/
+ # aggregated_ogms        fragmentation          hop_penalty
+ # ap_isolation           gw_bandwidth           log_level
+ # bonding                gw_mode                orig_interval
+ # bridge_loop_avoidance  gw_sel_class           vis_mode
There is a special folder for debugging information:
#  ls /sys/kernel/debug/batman_adv/bat0/
- #  gateways     socket        transtable_global  vis_data
- #  originators  softif_neigh  transtable_local
- 
+ # bla_claim_table    log                socket             transtable_local
+ # gateways           originators        transtable_global  vis_data
Some of the files contain all sort of status information  regard-
  ing  the  mesh  network.  For  example, you can view the table of
@@@ -200,12 -200,14 +200,14 @@@ abled  during run time. Following log_l
  1 - Enable messages related to routing / flooding / broadcasting
  2 - Enable messages related to route added / changed / deleted
  4 - Enable messages related to translation table operations
- 7 - Enable all messages
+ 8 - Enable messages related to bridge loop avoidance
+ 16 - Enable messaged related to DAT, ARP snooping and parsing
+ 31 - Enable all messages
The debug output can be changed at runtime  using  the  file
  /sys/class/net/bat0/mesh/log_level. e.g.
- # echo 2 > /sys/class/net/bat0/mesh/log_level
+ # echo 6 > /sys/class/net/bat0/mesh/log_level
will enable debug messages for when routes change.
diff --combined net/batman-adv/Makefile
index 4e392eb,ad002cd..ad002cd
--- a/net/batman-adv/Makefile
+++ b/net/batman-adv/Makefile
@@@ -23,6 -23,8 +23,8 @@@ batman-adv-y += bat_debugfs.
  batman-adv-y += bat_iv_ogm.o
  batman-adv-y += bat_sysfs.o
  batman-adv-y += bitarray.o
+ batman-adv-$(CONFIG_BATMAN_ADV_BLA) += bridge_loop_avoidance.o
+ batman-adv-$(CONFIG_BATMAN_ADV_DAT) += distributed-arp-table.o
  batman-adv-y += gateway_client.o
  batman-adv-y += gateway_common.o
  batman-adv-y += hard-interface.o
diff --combined net/batman-adv/bat_debugfs.c
index c3b0548,3b588f8..3b588f8
--- a/net/batman-adv/bat_debugfs.c
+++ b/net/batman-adv/bat_debugfs.c
@@@ -32,6 -32,7 +32,7 @@@
  #include "soft-interface.h"
  #include "vis.h"
  #include "icmp_socket.h"
+ #include "bridge_loop_avoidance.h"
static struct dentry *bat_debugfs;
@@@ -82,8 -83,8 +83,8 @@@ int debug_log(struct bat_priv *bat_priv
va_start(args, fmt);
    vscnprintf(tmp_log_buf, sizeof(tmp_log_buf), fmt, args);
- 	fdebug_log(bat_priv->debug_log, "[%10lu] %s",
- 		   (jiffies / HZ), tmp_log_buf);
+ 	fdebug_log(bat_priv->debug_log, "[%10u] %s",
+ 		   jiffies_to_msecs(jiffies), tmp_log_buf);
    va_end(args);
return 0;
@@@ -238,17 -239,19 +239,19 @@@ static int gateways_open(struct inode *
    return single_open(file, gw_client_seq_print_text, net_dev);
  }
- static int softif_neigh_open(struct inode *inode, struct file *file)
+ static int transtable_global_open(struct inode *inode, struct file *file)
  {
    struct net_device *net_dev = (struct net_device *)inode->i_private;
- 	return single_open(file, softif_neigh_seq_print_text, net_dev);
+ 	return single_open(file, tt_global_seq_print_text, net_dev);
  }
- static int transtable_global_open(struct inode *inode, struct file *file)
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ static int bla_claim_table_open(struct inode *inode, struct file *file)
  {
    struct net_device *net_dev = (struct net_device *)inode->i_private;
- 	return single_open(file, tt_global_seq_print_text, net_dev);
+ 	return single_open(file, bla_claim_table_seq_print_text, net_dev);
  }
+ #endif
static int transtable_local_open(struct inode *inode, struct file *file)
  {
@@@ -282,16 -285,20 +285,20 @@@ struct bat_debuginfo bat_debuginfo_##_n
  static BAT_DEBUGINFO(routing_algos, S_IRUGO, bat_algorithms_open);
  static BAT_DEBUGINFO(originators, S_IRUGO, originators_open);
  static BAT_DEBUGINFO(gateways, S_IRUGO, gateways_open);
- static BAT_DEBUGINFO(softif_neigh, S_IRUGO, softif_neigh_open);
  static BAT_DEBUGINFO(transtable_global, S_IRUGO, transtable_global_open);
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ static BAT_DEBUGINFO(bla_claim_table, S_IRUGO, bla_claim_table_open);
+ #endif
  static BAT_DEBUGINFO(transtable_local, S_IRUGO, transtable_local_open);
  static BAT_DEBUGINFO(vis_data, S_IRUGO, vis_data_open);
static struct bat_debuginfo *mesh_debuginfos[] = {
    &bat_debuginfo_originators,
    &bat_debuginfo_gateways,
- 	&bat_debuginfo_softif_neigh,
    &bat_debuginfo_transtable_global,
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ 	&bat_debuginfo_bla_claim_table,
+ #endif
    &bat_debuginfo_transtable_local,
    &bat_debuginfo_vis_data,
    NULL,
diff --combined net/batman-adv/bat_iv_ogm.c
index a6d5d63,994369d..994369d
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@@ -30,33 -30,69 +30,69 @@@
  #include "send.h"
  #include "bat_algo.h"
- static void bat_iv_ogm_init(struct hard_iface *hard_iface)
+ static struct neigh_node *bat_iv_ogm_neigh_new(struct hard_iface *hard_iface,
+ 					       const uint8_t *neigh_addr,
+ 					       struct orig_node *orig_node,
+ 					       struct orig_node *orig_neigh,
+ 					       uint32_t seqno)
+ {
+ 	struct neigh_node *neigh_node;
+ 
+ 	neigh_node = neigh_node_new(hard_iface, neigh_addr, seqno);
+ 	if (!neigh_node)
+ 		goto out;
+ 
+ 	INIT_LIST_HEAD(&neigh_node->bonding_list);
+ 
+ 	neigh_node->orig_node = orig_neigh;
+ 	neigh_node->if_incoming = hard_iface;
+ 
+ 	spin_lock_bh(&orig_node->neigh_list_lock);
+ 	hlist_add_head_rcu(&neigh_node->list, &orig_node->neigh_list);
+ 	spin_unlock_bh(&orig_node->neigh_list_lock);
+ 
+ out:
+ 	return neigh_node;
+ }
+ 
+ static int bat_iv_ogm_iface_enable(struct hard_iface *hard_iface)
  {
    struct batman_ogm_packet *batman_ogm_packet;
+ 	unsigned long random_seqno;
+ 	int res = -1;
- 	hard_iface->packet_len = BATMAN_OGM_LEN;
+ 	/* randomize initial seqno to avoid collision */
+ 	get_random_bytes(&random_seqno, sizeof(unsigned long));
+ 	atomic_set(&hard_iface->seqno, (uint32_t)random_seqno);
+ 
+ 	hard_iface->packet_len = BATMAN_OGM_HLEN;
    hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC);
+ 	if (!hard_iface->packet_buff)
+ 		goto out;
+ 
    batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
- 	batman_ogm_packet->header.packet_type = BAT_OGM;
+ 	batman_ogm_packet->header.packet_type = BAT_IV_OGM;
    batman_ogm_packet->header.version = COMPAT_VERSION;
    batman_ogm_packet->header.ttl = 2;
    batman_ogm_packet->flags = NO_FLAGS;
    batman_ogm_packet->tq = TQ_MAX_VALUE;
    batman_ogm_packet->tt_num_changes = 0;
    batman_ogm_packet->ttvn = 0;
+ 
+ 	res = 0;
+ 
+ out:
+ 	return res;
  }
- static void bat_iv_ogm_init_primary(struct hard_iface *hard_iface)
+ static void bat_iv_ogm_iface_disable(struct hard_iface *hard_iface)
  {
- 	struct batman_ogm_packet *batman_ogm_packet;
- 
- 	batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
- 	batman_ogm_packet->flags = PRIMARIES_FIRST_HOP;
- 	batman_ogm_packet->header.ttl = TTL;
+ 	kfree(hard_iface->packet_buff);
+ 	hard_iface->packet_buff = NULL;
  }
- static void bat_iv_ogm_update_mac(struct hard_iface *hard_iface)
+ static void bat_iv_ogm_iface_update_mac(struct hard_iface *hard_iface)
  {
    struct batman_ogm_packet *batman_ogm_packet;
@@@ -67,6 -103,15 +103,15 @@@
           hard_iface->net_dev->dev_addr, ETH_ALEN);
  }
+ static void bat_iv_ogm_primary_iface_set(struct hard_iface *hard_iface)
+ {
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
+ 	batman_ogm_packet->flags = PRIMARIES_FIRST_HOP;
+ 	batman_ogm_packet->header.ttl = TTL;
+ }
+ 
  /* when do we schedule our own ogm to be sent */
  static unsigned long bat_iv_ogm_emit_send_time(const struct bat_priv *bat_priv)
  {
@@@ -92,7 -137,7 +137,7 @@@ static uint8_t hop_penalty(uint8_t tq, 
  static int bat_iv_ogm_aggr_packet(int buff_pos, int packet_len,
    			  int tt_num_changes)
  {
- 	int next_buff_pos = buff_pos + BATMAN_OGM_LEN + tt_len(tt_num_changes);
+ 	int next_buff_pos = buff_pos + BATMAN_OGM_HLEN + tt_len(tt_num_changes);
return (next_buff_pos <= packet_len) &&
    	(next_buff_pos <= MAX_AGGREGATION_BYTES);
@@@ -132,7 -177,7 +177,7 @@@ static void bat_iv_ogm_send_to_if(struc
    						    "Sending own" :
    						    "Forwarding"));
    	bat_dbg(DBG_BATMAN, bat_priv,
- 			"%s %spacket (originator %pM, seqno %d, TQ %d, TTL %d, IDF %s, ttvn %d) on interface %s [%pM]\n",
+ 			"%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s, ttvn %d) on interface %s [%pM]\n",
    		fwd_str, (packet_num > 0 ? "aggregated " : ""),
    		batman_ogm_packet->orig,
    		ntohl(batman_ogm_packet->seqno),
@@@ -142,7 -187,7 +187,7 @@@
    		batman_ogm_packet->ttvn, hard_iface->net_dev->name,
    		hard_iface->net_dev->dev_addr);
- 		buff_pos += BATMAN_OGM_LEN +
+ 		buff_pos += BATMAN_OGM_HLEN +
    			tt_len(batman_ogm_packet->tt_num_changes);
    	packet_num++;
    	batman_ogm_packet = (struct batman_ogm_packet *)
@@@ -191,7 -236,7 +236,7 @@@ static void bat_iv_ogm_emit(struct forw
/* FIXME: what about aggregated packets ? */
    	bat_dbg(DBG_BATMAN, bat_priv,
- 			"%s packet (originator %pM, seqno %d, TTL %d) on interface %s [%pM]\n",
+ 			"%s packet (originator %pM, seqno %u, TTL %d) on interface %s [%pM]\n",
    		(forw_packet->own ? "Sending own" : "Forwarding"),
    		batman_ogm_packet->orig,
    		ntohl(batman_ogm_packet->seqno),
@@@ -335,10 -380,9 +380,9 @@@ static void bat_iv_ogm_aggregate_new(co
    if ((atomic_read(&bat_priv->aggregated_ogms)) &&
        (packet_len < MAX_AGGREGATION_BYTES))
    	forw_packet_aggr->skb = dev_alloc_skb(MAX_AGGREGATION_BYTES +
- 						      sizeof(struct ethhdr));
+ 						      ETH_HLEN);
    else
- 		forw_packet_aggr->skb = dev_alloc_skb(packet_len +
- 						      sizeof(struct ethhdr));
+ 		forw_packet_aggr->skb = dev_alloc_skb(packet_len + ETH_HLEN);
if (!forw_packet_aggr->skb) {
    	if (!own_packet)
@@@ -346,7 -390,7 +390,7 @@@
    	kfree(forw_packet_aggr);
    	goto out;
    }
- 	skb_reserve(forw_packet_aggr->skb, sizeof(struct ethhdr));
+ 	skb_reserve(forw_packet_aggr->skb, ETH_HLEN);
INIT_HLIST_NODE(&forw_packet_aggr->list);
@@@ -461,11 -505,11 +505,11 @@@ static void bat_iv_ogm_queue_add(struc
  static void bat_iv_ogm_forward(struct orig_node *orig_node,
    		       const struct ethhdr *ethhdr,
    		       struct batman_ogm_packet *batman_ogm_packet,
- 			       int directlink, struct hard_iface *if_incoming)
+ 			       bool is_single_hop_neigh,
+ 			       bool is_from_best_next_hop,
+ 			       struct hard_iface *if_incoming)
  {
    struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
- 	struct neigh_node *router;
- 	uint8_t in_tq, in_ttl, tq_avg = 0;
    uint8_t tt_num_changes;
if (batman_ogm_packet->header.ttl <= 1) {
@@@ -473,54 -517,44 +517,44 @@@
    	return;
    }
- 	router = orig_node_get_router(orig_node);
+ 	if (!is_from_best_next_hop) {
+ 		/**
+ 		* Mark the forwarded packet when it is not coming from our best
+ 		* next hop. We still need to forward the packet for our neighbor
+ 		* link quality detection to work in case the packet originated
+ 		* from a single hop neighbor. Otherwise we can simply drop the
+ 		* ogm.
+ 		*/
+ 		if (is_single_hop_neigh)
+ 			batman_ogm_packet->flags |= NOT_BEST_NEXT_HOP;
+ 		else
+ 			return;
+ 	}
- 	in_tq = batman_ogm_packet->tq;
- 	in_ttl = batman_ogm_packet->header.ttl;
    tt_num_changes = batman_ogm_packet->tt_num_changes;
batman_ogm_packet->header.ttl--;
    memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
- 	/* rebroadcast tq of our best ranking neighbor to ensure the rebroadcast
- 	 * of our best tq value */
- 	if (router && router->tq_avg != 0) {
- 
- 		/* rebroadcast ogm of best ranking neighbor as is */
- 		if (!compare_eth(router->addr, ethhdr->h_source)) {
- 			batman_ogm_packet->tq = router->tq_avg;
- 
- 			if (router->last_ttl)
- 				batman_ogm_packet->header.ttl =
- 					router->last_ttl - 1;
- 		}
- 
- 		tq_avg = router->tq_avg;
- 	}
- 
- 	if (router)
- 		neigh_node_free_ref(router);
- 
    /* apply hop penalty */
    batman_ogm_packet->tq = hop_penalty(batman_ogm_packet->tq, bat_priv);
bat_dbg(DBG_BATMAN, bat_priv,
- 		"Forwarding packet: tq_orig: %i, tq_avg: %i, tq_forw: %i, ttl_orig: %i, ttl_forw: %i\n",
- 		in_tq, tq_avg, batman_ogm_packet->tq, in_ttl - 1,
- 		batman_ogm_packet->header.ttl);
+ 		"Forwarding packet: tq: %i, ttl: %i\n",
+ 		batman_ogm_packet->tq, batman_ogm_packet->header.ttl);
batman_ogm_packet->seqno = htonl(batman_ogm_packet->seqno);
    batman_ogm_packet->tt_crc = htons(batman_ogm_packet->tt_crc);
/* switch of primaries first hop flag when forwarding */
    batman_ogm_packet->flags &= ~PRIMARIES_FIRST_HOP;
- 	if (directlink)
+ 	if (is_single_hop_neigh)
    	batman_ogm_packet->flags |= DIRECTLINK;
    else
    	batman_ogm_packet->flags &= ~DIRECTLINK;
bat_iv_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
- 			     BATMAN_OGM_LEN + tt_len(tt_num_changes),
+ 			     BATMAN_OGM_HLEN + tt_len(tt_num_changes),
    		     if_incoming, 0, bat_iv_ogm_fwd_send_time());
  }
@@@ -603,12 -637,12 +637,12 @@@ static void bat_iv_ogm_orig_update(stru
    	if (is_duplicate)
    		continue;
- 		spin_lock_bh(&tmp_neigh_node->tq_lock);
+ 		spin_lock_bh(&tmp_neigh_node->lq_update_lock);
    	ring_buffer_set(tmp_neigh_node->tq_recv,
    			&tmp_neigh_node->tq_index, 0);
    	tmp_neigh_node->tq_avg =
    		ring_buffer_avg(tmp_neigh_node->tq_recv);
- 		spin_unlock_bh(&tmp_neigh_node->tq_lock);
+ 		spin_unlock_bh(&tmp_neigh_node->lq_update_lock);
    }
if (!neigh_node) {
@@@ -618,8 -652,9 +652,9 @@@
    	if (!orig_tmp)
    		goto unlock;
- 		neigh_node = create_neighbor(orig_node, orig_tmp,
- 					     ethhdr->h_source, if_incoming);
+ 		neigh_node = bat_iv_ogm_neigh_new(if_incoming, ethhdr->h_source,
+ 						  orig_node, orig_tmp,
+ 						  batman_ogm_packet->seqno);
orig_node_free_ref(orig_tmp);
    	if (!neigh_node)
@@@ -631,14 -666,14 +666,14 @@@
    rcu_read_unlock();
orig_node->flags = batman_ogm_packet->flags;
- 	neigh_node->last_valid = jiffies;
+ 	neigh_node->last_seen = jiffies;
- 	spin_lock_bh(&neigh_node->tq_lock);
+ 	spin_lock_bh(&neigh_node->lq_update_lock);
    ring_buffer_set(neigh_node->tq_recv,
    		&neigh_node->tq_index,
    		batman_ogm_packet->tq);
    neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv);
- 	spin_unlock_bh(&neigh_node->tq_lock);
+ 	spin_unlock_bh(&neigh_node->lq_update_lock);
if (!is_duplicate) {
    	orig_node->last_ttl = batman_ogm_packet->header.ttl;
@@@ -744,19 -779,20 +779,20 @@@ static int bat_iv_ogm_calc_tq(struct or
    rcu_read_unlock();
if (!neigh_node)
- 		neigh_node = create_neighbor(orig_neigh_node,
- 					     orig_neigh_node,
- 					     orig_neigh_node->orig,
- 					     if_incoming);
+ 		neigh_node = bat_iv_ogm_neigh_new(if_incoming,
+ 						  orig_neigh_node->orig,
+ 						  orig_neigh_node,
+ 						  orig_neigh_node,
+ 						  batman_ogm_packet->seqno);
if (!neigh_node)
    	goto out;
- 	/* if orig_node is direct neighbor update neigh_node last_valid */
+ 	/* if orig_node is direct neighbor update neigh_node last_seen */
    if (orig_node == orig_neigh_node)
- 		neigh_node->last_valid = jiffies;
+ 		neigh_node->last_seen = jiffies;
- 	orig_node->last_valid = jiffies;
+ 	orig_node->last_seen = jiffies;
/* find packet count of corresponding one hop neighbor */
    spin_lock_bh(&orig_node->ogm_cnt_lock);
@@@ -842,7 -878,8 +878,8 @@@ static int bat_iv_ogm_update_seqnos(con
    seq_diff = batman_ogm_packet->seqno - orig_node->last_real_seqno;
/* signalize caller that the packet is to be dropped. */
- 	if (window_protected(bat_priv, seq_diff,
+ 	if (!hlist_empty(&orig_node->neigh_list) &&
+ 	    window_protected(bat_priv, seq_diff,
    		     &orig_node->batman_seqno_reset))
    	goto out;
@@@ -850,9 -887,9 +887,9 @@@
    hlist_for_each_entry_rcu(tmp_neigh_node, node,
    			 &orig_node->neigh_list, list) {
- 		is_duplicate |= get_bit_status(tmp_neigh_node->real_bits,
- 					       orig_node->last_real_seqno,
- 					       batman_ogm_packet->seqno);
+ 		is_duplicate |= bat_test_bit(tmp_neigh_node->real_bits,
+ 					     orig_node->last_real_seqno,
+ 					     batman_ogm_packet->seqno);
if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
    	    (tmp_neigh_node->if_incoming == if_incoming))
@@@ -866,13 -903,14 +903,14 @@@
    				      seq_diff, set_mark);
tmp_neigh_node->real_packet_count =
- 			bit_packet_count(tmp_neigh_node->real_bits);
+ 			bitmap_weight(tmp_neigh_node->real_bits,
+ 				      TQ_LOCAL_WINDOW_SIZE);
    }
    rcu_read_unlock();
if (need_update) {
    	bat_dbg(DBG_BATMAN, bat_priv,
- 			"updating last_seqno: old %d, new %d\n",
+ 			"updating last_seqno: old %u, new %u\n",
    		orig_node->last_real_seqno, batman_ogm_packet->seqno);
    	orig_node->last_real_seqno = batman_ogm_packet->seqno;
    }
@@@ -897,7 -935,9 +935,9 @@@ static void bat_iv_ogm_process(const st
    struct neigh_node *orig_neigh_router = NULL;
    int has_directlink_flag;
    int is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0;
- 	int is_broadcast = 0, is_bidirectional, is_single_hop_neigh;
+ 	int is_broadcast = 0, is_bidirectional;
+ 	bool is_single_hop_neigh = false;
+ 	bool is_from_best_next_hop = false;
    int is_duplicate;
    uint32_t if_incoming_seqno;
@@@ -913,7 -953,7 +953,7 @@@
     * packet in an aggregation.  Here we expect that the padding
     * is always zero (or not 0x01)
     */
- 	if (batman_ogm_packet->header.packet_type != BAT_OGM)
+ 	if (batman_ogm_packet->header.packet_type != BAT_IV_OGM)
    	return;
/* could be changed by schedule_own_packet() */
@@@ -921,11 -961,11 +961,11 @@@
has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);
- 	is_single_hop_neigh = (compare_eth(ethhdr->h_source,
- 					   batman_ogm_packet->orig) ? 1 : 0);
+ 	if (compare_eth(ethhdr->h_source, batman_ogm_packet->orig))
+ 		is_single_hop_neigh = true;
bat_dbg(DBG_BATMAN, bat_priv,
- 		"Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %d, ttvn %u, crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n",
+ 		"Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, ttvn %u, crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n",
    	ethhdr->h_source, if_incoming->net_dev->name,
    	if_incoming->net_dev->dev_addr, batman_ogm_packet->orig,
    	batman_ogm_packet->prev_sender, batman_ogm_packet->seqno,
@@@ -998,11 -1038,11 +1038,11 @@@
spin_lock_bh(&orig_neigh_node->ogm_cnt_lock);
    		word = &(orig_neigh_node->bcast_own[offset]);
- 			bit_mark(word,
- 				 if_incoming_seqno -
+ 			bat_set_bit(word,
+ 				    if_incoming_seqno -
    					batman_ogm_packet->seqno - 2);
    		orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
- 				bit_packet_count(word);
+ 				bitmap_weight(word, TQ_LOCAL_WINDOW_SIZE);
    		spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
    	}
@@@ -1019,6 -1059,13 +1059,13 @@@
    	return;
    }
+ 	if (batman_ogm_packet->flags & NOT_BEST_NEXT_HOP) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
+ 			ethhdr->h_source);
+ 		return;
+ 	}
+ 
    orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig);
    if (!orig_node)
    	return;
@@@ -1043,6 -1090,10 +1090,10 @@@
    if (router)
    	router_router = orig_node_get_router(router->orig_node);
+ 	if ((router && router->tq_avg != 0) &&
+ 	    (compare_eth(router->addr, ethhdr->h_source)))
+ 		is_from_best_next_hop = true;
+ 
    /* avoid temporary routing loops */
    if (router && router_router &&
        (compare_eth(router->addr, batman_ogm_packet->prev_sender)) &&
@@@ -1093,7 -1144,8 +1144,8 @@@
/* mark direct link on incoming interface */
    	bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
- 				   1, if_incoming);
+ 				   is_single_hop_neigh, is_from_best_next_hop,
+ 				   if_incoming);
bat_dbg(DBG_BATMAN, bat_priv,
    		"Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
@@@ -1116,7 -1168,8 +1168,8 @@@
    bat_dbg(DBG_BATMAN, bat_priv,
    	"Forwarding packet: rebroadcast originator packet\n");
    bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
- 			   0, if_incoming);
+ 			   is_single_hop_neigh, is_from_best_next_hop,
+ 			   if_incoming);
out_neigh:
    if ((orig_neigh_node) && (!is_single_hop_neigh))
@@@ -1132,13 -1185,24 +1185,24 @@@ out
    orig_node_free_ref(orig_node);
  }
- static void bat_iv_ogm_receive(struct hard_iface *if_incoming,
- 			       struct sk_buff *skb)
+ static int bat_iv_ogm_receive(struct sk_buff *skb,
+ 			      struct hard_iface *if_incoming)
  {
+ 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
    struct batman_ogm_packet *batman_ogm_packet;
    struct ethhdr *ethhdr;
    int buff_pos = 0, packet_len;
    unsigned char *tt_buff, *packet_buff;
+ 	bool ret;
+ 
+ 	ret = check_management_packet(skb, if_incoming, BATMAN_OGM_HLEN);
+ 	if (!ret)
+ 		return NET_RX_DROP;
+ 
+ 	/* did we receive a B.A.T.M.A.N. IV OGM packet on an interface
+ 	 * that does not have B.A.T.M.A.N. IV enabled ? */
+ 	if (bat_priv->bat_algo_ops->bat_ogm_emit != bat_iv_ogm_emit)
+ 		return NET_RX_DROP;
packet_len = skb_headlen(skb);
    ethhdr = (struct ethhdr *)skb_mac_header(skb);
@@@ -1152,31 -1216,50 +1216,50 @@@
    	batman_ogm_packet->seqno = ntohl(batman_ogm_packet->seqno);
    	batman_ogm_packet->tt_crc = ntohs(batman_ogm_packet->tt_crc);
- 		tt_buff = packet_buff + buff_pos + BATMAN_OGM_LEN;
+ 		tt_buff = packet_buff + buff_pos + BATMAN_OGM_HLEN;
bat_iv_ogm_process(ethhdr, batman_ogm_packet,
    			   tt_buff, if_incoming);
- 		buff_pos += BATMAN_OGM_LEN +
+ 		buff_pos += BATMAN_OGM_HLEN +
    			tt_len(batman_ogm_packet->tt_num_changes);
batman_ogm_packet = (struct batman_ogm_packet *)
    					(packet_buff + buff_pos);
    } while (bat_iv_ogm_aggr_packet(buff_pos, packet_len,
    				batman_ogm_packet->tt_num_changes));
+ 
+ 	kfree_skb(skb);
+ 	return NET_RX_SUCCESS;
  }
static struct bat_algo_ops batman_iv __read_mostly = {
    .name = "BATMAN IV",
- 	.bat_ogm_init = bat_iv_ogm_init,
- 	.bat_ogm_init_primary = bat_iv_ogm_init_primary,
- 	.bat_ogm_update_mac = bat_iv_ogm_update_mac,
+ 	.bat_iface_enable = bat_iv_ogm_iface_enable,
+ 	.bat_iface_disable = bat_iv_ogm_iface_disable,
+ 	.bat_iface_update_mac = bat_iv_ogm_iface_update_mac,
+ 	.bat_primary_iface_set = bat_iv_ogm_primary_iface_set,
    .bat_ogm_schedule = bat_iv_ogm_schedule,
    .bat_ogm_emit = bat_iv_ogm_emit,
- 	.bat_ogm_receive = bat_iv_ogm_receive,
  };
int __init bat_iv_init(void)
  {
- 	return bat_algo_register(&batman_iv);
+ 	int ret;
+ 
+ 	/* batman originator packet */
+ 	ret = recv_handler_register(BAT_IV_OGM, bat_iv_ogm_receive);
+ 	if (ret < 0)
+ 		goto out;
+ 
+ 	ret = bat_algo_register(&batman_iv);
+ 	if (ret < 0)
+ 		goto handler_unregister;
+ 
+ 	goto out;
+ 
+ handler_unregister:
+ 	recv_handler_unregister(BAT_IV_OGM);
+ out:
+ 	return ret;
  }
diff --combined net/batman-adv/bat_sysfs.c
index 68ff759,d0f8453..d0f8453
--- a/net/batman-adv/bat_sysfs.c
+++ b/net/batman-adv/bat_sysfs.c
@@@ -63,7 -63,7 +63,7 @@@ struct bat_attribute bat_attr_##_name 
    .store  = _store,			\
  };
- #define BAT_ATTR_STORE_BOOL(_name, _post_func)				\
+ #define BAT_ATTR_SIF_STORE_BOOL(_name, _post_func)			\
  ssize_t store_##_name(struct kobject *kobj, struct attribute *attr,	\
    	      char *buff, size_t count)				\
  {									\
@@@ -73,9 -73,9 +73,9 @@@
    			 &bat_priv->_name, net_dev);		\
  }
- #define BAT_ATTR_SHOW_BOOL(_name)					\
- ssize_t show_##_name(struct kobject *kobj, struct attribute *attr,	\
- 			    char *buff)					\
+ #define BAT_ATTR_SIF_SHOW_BOOL(_name)					\
+ ssize_t show_##_name(struct kobject *kobj,				\
+ 		     struct attribute *attr, char *buff)		\
  {									\
    struct bat_priv *bat_priv = kobj_to_batpriv(kobj);		\
    return sprintf(buff, "%s\n",					\
@@@ -83,16 -83,17 +83,17 @@@
    	       "disabled" : "enabled");				\
  }									\
- /* Use this, if you are going to turn a [name] in bat_priv on or off */
- #define BAT_ATTR_BOOL(_name, _mode, _post_func)				\
- 	static BAT_ATTR_STORE_BOOL(_name, _post_func)			\
- 	static BAT_ATTR_SHOW_BOOL(_name)				\
+ /* Use this, if you are going to turn a [name] in the soft-interface
+  * (bat_priv) on or off */
+ #define BAT_ATTR_SIF_BOOL(_name, _mode, _post_func)			\
+ 	static BAT_ATTR_SIF_STORE_BOOL(_name, _post_func)		\
+ 	static BAT_ATTR_SIF_SHOW_BOOL(_name)				\
    static BAT_ATTR(_name, _mode, show_##_name, store_##_name)
- #define BAT_ATTR_STORE_UINT(_name, _min, _max, _post_func)		\
+ #define BAT_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func)		\
  ssize_t store_##_name(struct kobject *kobj, struct attribute *attr,	\
- 			     char *buff, size_t count)			\
+ 		      char *buff, size_t count)				\
  {									\
    struct net_device *net_dev = kobj_to_netdev(kobj);		\
    struct bat_priv *bat_priv = netdev_priv(net_dev);		\
@@@ -100,19 -101,62 +101,62 @@@
    			 attr, &bat_priv->_name, net_dev);	\
  }
- #define BAT_ATTR_SHOW_UINT(_name)					\
- ssize_t show_##_name(struct kobject *kobj, struct attribute *attr,	\
- 			    char *buff)					\
+ #define BAT_ATTR_SIF_SHOW_UINT(_name)					\
+ ssize_t show_##_name(struct kobject *kobj,				\
+ 		     struct attribute *attr, char *buff)		\
  {									\
    struct bat_priv *bat_priv = kobj_to_batpriv(kobj);		\
    return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name));	\
  }									\
- /* Use this, if you are going to set [name] in bat_priv to unsigned integer
-  * values only */
- #define BAT_ATTR_UINT(_name, _mode, _min, _max, _post_func)		\
- 	static BAT_ATTR_STORE_UINT(_name, _min, _max, _post_func)	\
- 	static BAT_ATTR_SHOW_UINT(_name)				\
+ /* Use this, if you are going to set [name] in the soft-interface
+  * (bat_priv) to an unsigned integer value */
+ #define BAT_ATTR_SIF_UINT(_name, _mode, _min, _max, _post_func)		\
+ 	static BAT_ATTR_SIF_STORE_UINT(_name, _min, _max, _post_func)	\
+ 	static BAT_ATTR_SIF_SHOW_UINT(_name)				\
+ 	static BAT_ATTR(_name, _mode, show_##_name, store_##_name)
+ 
+ 
+ #define BAT_ATTR_HIF_STORE_UINT(_name, _min, _max, _post_func)		\
+ ssize_t store_##_name(struct kobject *kobj, struct attribute *attr,	\
+ 		      char *buff, size_t count)				\
+ {									\
+ 	struct net_device *net_dev = kobj_to_netdev(kobj);		\
+ 	struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev);	\
+ 	ssize_t length;							\
+ 									\
+ 	if (!hard_iface)						\
+ 		return 0;						\
+ 									\
+ 	length = __store_uint_attr(buff, count, _min, _max, _post_func,	\
+ 				   attr, &hard_iface->_name, net_dev);	\
+ 									\
+ 	hardif_free_ref(hard_iface);					\
+ 	return length;							\
+ }
+ 
+ #define BAT_ATTR_HIF_SHOW_UINT(_name)					\
+ ssize_t show_##_name(struct kobject *kobj,				\
+ 		     struct attribute *attr, char *buff)		\
+ {									\
+ 	struct net_device *net_dev = kobj_to_netdev(kobj);		\
+ 	struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev);	\
+ 	ssize_t length;							\
+ 									\
+ 	if (!hard_iface)						\
+ 		return 0;						\
+ 									\
+ 	length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_name));\
+ 									\
+ 	hardif_free_ref(hard_iface);					\
+ 	return length;							\
+ }
+ 
+ /* Use this, if you are going to set [name] in hard_iface to an
+  * unsigned integer value*/
+ #define BAT_ATTR_HIF_UINT(_name, _mode, _min, _max, _post_func)		\
+ 	static BAT_ATTR_HIF_STORE_UINT(_name, _min, _max, _post_func)	\
+ 	static BAT_ATTR_HIF_SHOW_UINT(_name)				\
    static BAT_ATTR(_name, _mode, show_##_name, store_##_name)
@@@ -384,26 -428,32 +428,32 @@@ static ssize_t store_gw_bwidth(struct k
    return gw_bandwidth_set(net_dev, buff, count);
  }
- BAT_ATTR_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
- BAT_ATTR_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
- BAT_ATTR_BOOL(fragmentation, S_IRUGO | S_IWUSR, update_min_mtu);
- BAT_ATTR_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);
+ BAT_ATTR_SIF_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL);
+ BAT_ATTR_SIF_BOOL(bonding, S_IRUGO | S_IWUSR, NULL);
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ BAT_ATTR_SIF_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR, NULL);
+ #endif
+ BAT_ATTR_SIF_BOOL(fragmentation, S_IRUGO | S_IWUSR, update_min_mtu);
+ BAT_ATTR_SIF_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL);
  static BAT_ATTR(vis_mode, S_IRUGO | S_IWUSR, show_vis_mode, store_vis_mode);
  static BAT_ATTR(routing_algo, S_IRUGO, show_bat_algo, NULL);
  static BAT_ATTR(gw_mode, S_IRUGO | S_IWUSR, show_gw_mode, store_gw_mode);
- BAT_ATTR_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * JITTER, INT_MAX, NULL);
- BAT_ATTR_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, TQ_MAX_VALUE, NULL);
- BAT_ATTR_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, TQ_MAX_VALUE,
- 	      post_gw_deselect);
+ BAT_ATTR_SIF_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * JITTER, INT_MAX, NULL);
+ BAT_ATTR_SIF_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, TQ_MAX_VALUE, NULL);
+ BAT_ATTR_SIF_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, TQ_MAX_VALUE,
+ 		  post_gw_deselect);
  static BAT_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, show_gw_bwidth,
    	store_gw_bwidth);
  #ifdef CONFIG_BATMAN_ADV_DEBUG
- BAT_ATTR_UINT(log_level, S_IRUGO | S_IWUSR, 0, 7, NULL);
+ BAT_ATTR_SIF_UINT(log_level, S_IRUGO | S_IWUSR, 0, 31, NULL);
  #endif
static struct bat_attribute *mesh_attrs[] = {
    &bat_attr_aggregated_ogms,
    &bat_attr_bonding,
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ 	&bat_attr_bridge_loop_avoidance,
+ #endif
    &bat_attr_fragmentation,
    &bat_attr_ap_isolation,
    &bat_attr_vis_mode,
diff --combined net/batman-adv/bitarray.c
index 6d0aa21,07ae6e1..07ae6e1
--- a/net/batman-adv/bitarray.c
+++ b/net/batman-adv/bitarray.c
@@@ -24,100 -24,13 +24,13 @@@
#include <linux/bitops.h>
- /* returns true if the corresponding bit in the given seq_bits indicates true
-  * and curr_seqno is within range of last_seqno */
- int get_bit_status(const unsigned long *seq_bits, uint32_t last_seqno,
- 		   uint32_t curr_seqno)
- {
- 	int32_t diff, word_offset, word_num;
- 
- 	diff = last_seqno - curr_seqno;
- 	if (diff < 0 || diff >= TQ_LOCAL_WINDOW_SIZE) {
- 		return 0;
- 	} else {
- 		/* which word */
- 		word_num = (last_seqno - curr_seqno) / WORD_BIT_SIZE;
- 		/* which position in the selected word */
- 		word_offset = (last_seqno - curr_seqno) % WORD_BIT_SIZE;
- 
- 		if (test_bit(word_offset, &seq_bits[word_num]))
- 			return 1;
- 		else
- 			return 0;
- 	}
- }
- 
- /* turn corresponding bit on, so we can remember that we got the packet */
- void bit_mark(unsigned long *seq_bits, int32_t n)
- {
- 	int32_t word_offset, word_num;
- 
- 	/* if too old, just drop it */
- 	if (n < 0 || n >= TQ_LOCAL_WINDOW_SIZE)
- 		return;
- 
- 	/* which word */
- 	word_num = n / WORD_BIT_SIZE;
- 	/* which position in the selected word */
- 	word_offset = n % WORD_BIT_SIZE;
- 
- 	set_bit(word_offset, &seq_bits[word_num]); /* turn the position on */
- }
- 
  /* shift the packet array by n places. */
- static void bit_shift(unsigned long *seq_bits, int32_t n)
+ static void bat_bitmap_shift_left(unsigned long *seq_bits, int32_t n)
  {
    if (n <= 0 || n >= TQ_LOCAL_WINDOW_SIZE)
    	return;
- 	word_offset = n % WORD_BIT_SIZE;/* shift how much inside each word */
- 	word_num = n / WORD_BIT_SIZE;	/* shift over how much (full) words */
- 
- 	for (i = NUM_WORDS - 1; i > word_num; i--) {
- 		/* going from old to new, so we don't overwrite the data we copy
- 		 * from.
- 		 *
- 		 * left is high, right is low: FEDC BA98 7654 3210
- 		 *					  ^^ ^^
- 		 *			       vvvv
- 		 * ^^^^ = from, vvvvv =to, we'd have word_num==1 and
- 		 * word_offset==WORD_BIT_SIZE/2 ????? in this example.
- 		 * (=24 bits)
- 		 *
- 		 * our desired output would be: 9876 5432 1000 0000
- 		 * */
- 
- 		seq_bits[i] =
- 			(seq_bits[i - word_num] << word_offset) +
- 			/* take the lower port from the left half, shift it left
- 			 * to its final position */
- 			(seq_bits[i - word_num - 1] >>
- 			 (WORD_BIT_SIZE-word_offset));
- 		/* and the upper part of the right half and shift it left to
- 		 * its position */
- 		/* for our example that would be: word[0] = 9800 + 0076 =
- 		 * 9876 */
- 	}
- 	/* now for our last word, i==word_num, we only have its "left" half.
- 	 * that's the 1000 word in our example.*/
- 
- 	seq_bits[i] = (seq_bits[i - word_num] << word_offset);
- 
- 	/* pad the rest with 0, if there is anything */
- 	i--;
- 
- 	for (; i >= 0; i--)
- 		seq_bits[i] = 0;
- }
- 
- static void bit_reset_window(unsigned long *seq_bits)
- {
- 	int i;
- 	for (i = 0; i < NUM_WORDS; i++)
- 		seq_bits[i] = 0;
+ 	bitmap_shift_left(seq_bits, seq_bits, n, TQ_LOCAL_WINDOW_SIZE);
  }
@@@ -137,7 -50,7 +50,7 @@@ int bit_get_packet(void *priv, unsigne
if ((seq_num_diff <= 0) && (seq_num_diff > -TQ_LOCAL_WINDOW_SIZE)) {
    	if (set_mark)
- 			bit_mark(seq_bits, -seq_num_diff);
+ 			bat_set_bit(seq_bits, -seq_num_diff);
    	return 0;
    }
@@@ -145,10 -58,10 +58,10 @@@
     * set the mark if required */
if ((seq_num_diff > 0) && (seq_num_diff < TQ_LOCAL_WINDOW_SIZE)) {
- 		bit_shift(seq_bits, seq_num_diff);
+ 		bat_bitmap_shift_left(seq_bits, seq_num_diff);
if (set_mark)
- 			bit_mark(seq_bits, 0);
+ 			bat_set_bit(seq_bits, 0);
    	return 1;
    }
@@@ -159,9 -72,9 +72,9 @@@
    	bat_dbg(DBG_BATMAN, bat_priv,
    		"We missed a lot of packets (%i) !\n",
    		seq_num_diff - 1);
- 		bit_reset_window(seq_bits);
+ 		bitmap_zero(seq_bits, TQ_LOCAL_WINDOW_SIZE);
    	if (set_mark)
- 			bit_mark(seq_bits, 0);
+ 			bat_set_bit(seq_bits, 0);
    	return 1;
    }
@@@ -176,9 -89,9 +89,9 @@@
    	bat_dbg(DBG_BATMAN, bat_priv,
    		"Other host probably restarted!\n");
- 		bit_reset_window(seq_bits);
+ 		bitmap_zero(seq_bits, TQ_LOCAL_WINDOW_SIZE);
    	if (set_mark)
- 			bit_mark(seq_bits, 0);
+ 			bat_set_bit(seq_bits, 0);
return 1;
    }
@@@ -186,16 -99,3 +99,3 @@@
    /* never reached */
    return 0;
  }
- 
- /* count the hamming weight, how many good packets did we receive? just count
-  * the 1's.
-  */
- int bit_packet_count(const unsigned long *seq_bits)
- {
- 	int i, hamming = 0;
- 
- 	for (i = 0; i < NUM_WORDS; i++)
- 		hamming += hweight_long(seq_bits[i]);
- 
- 	return hamming;
- }
diff --combined net/batman-adv/bitarray.h
index c613572,1835c15..1835c15
--- a/net/batman-adv/bitarray.h
+++ b/net/batman-adv/bitarray.h
@@@ -22,23 -22,33 +22,33 @@@
  #ifndef _NET_BATMAN_ADV_BITARRAY_H_
  #define _NET_BATMAN_ADV_BITARRAY_H_
- #define WORD_BIT_SIZE (sizeof(unsigned long) * 8)
- 
  /* returns true if the corresponding bit in the given seq_bits indicates true
   * and curr_seqno is within range of last_seqno */
- int get_bit_status(const unsigned long *seq_bits, uint32_t last_seqno,
- 		   uint32_t curr_seqno);
+ static inline int bat_test_bit(const unsigned long *seq_bits,
+ 			       uint32_t last_seqno, uint32_t curr_seqno)
+ {
+ 	int32_t diff;
+ 
+ 	diff = last_seqno - curr_seqno;
+ 	if (diff < 0 || diff >= TQ_LOCAL_WINDOW_SIZE)
+ 		return 0;
+ 	else
+ 		return  test_bit(diff, seq_bits);
+ }
/* turn corresponding bit on, so we can remember that we got the packet */
- void bit_mark(unsigned long *seq_bits, int32_t n);
+ static inline void bat_set_bit(unsigned long *seq_bits, int32_t n)
+ {
+ 	/* if too old, just drop it */
+ 	if (n < 0 || n >= TQ_LOCAL_WINDOW_SIZE)
+ 		return;
+ 	set_bit(n, seq_bits); /* turn the position on */
+ }
/* receive and process one packet, returns 1 if received seq_num is considered
   * new, 0 if old  */
  int bit_get_packet(void *priv, unsigned long *seq_bits,
    	   int32_t seq_num_diff, int set_mark);
- /* count the hamming weight, how many good packets did we receive? */
- int bit_packet_count(const unsigned long *seq_bits);
- 
  #endif /* _NET_BATMAN_ADV_BITARRAY_H_ */
diff --combined net/batman-adv/bridge_loop_avoidance.c
index 0000000,8a17a78..8a17a78
mode 000000,100644..100644
--- a/net/batman-adv/bridge_loop_avoidance.c
+++ b/net/batman-adv/bridge_loop_avoidance.c
@@@ -1,0 -1,1573 +1,1573 @@@
+ /*
+  * 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 announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
+ 
+ static void bla_periodic_work(struct work_struct *work);
+ static void bla_send_announce(struct bat_priv *bat_priv,
+ 			      struct backbone_gw *backbone_gw);
+ 
+ /* return the index of the claim */
+ static inline uint32_t 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 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 compare_backbone_gw(const struct hlist_node *node, const void *data2)
+ {
+ 	const void *data1 = container_of(node, struct backbone_gw,
+ 					 hash_entry);
+ 
+ 	return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0);
+ }
+ 
+ /* compares address and vid of two claims */
+ static int compare_claim(const struct hlist_node *node, const void *data2)
+ {
+ 	const void *data1 = container_of(node, struct claim,
+ 					 hash_entry);
+ 
+ 	return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0);
+ }
+ 
+ /* free a backbone gw */
+ static void backbone_gw_free_ref(struct backbone_gw *backbone_gw)
+ {
+ 	if (atomic_dec_and_test(&backbone_gw->refcount))
+ 		kfree_rcu(backbone_gw, rcu);
+ }
+ 
+ /* finally deinitialize the claim */
+ static void claim_free_rcu(struct rcu_head *rcu)
+ {
+ 	struct claim *claim;
+ 
+ 	claim = container_of(rcu, struct claim, rcu);
+ 
+ 	backbone_gw_free_ref(claim->backbone_gw);
+ 	kfree(claim);
+ }
+ 
+ /* free a claim, call claim_free_rcu if its the last reference */
+ static void claim_free_ref(struct claim *claim)
+ {
+ 	if (atomic_dec_and_test(&claim->refcount))
+ 		call_rcu(&claim->rcu, 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 claim *claim_hash_find(struct bat_priv *bat_priv,
+ 				     struct claim *data)
+ {
+ 	struct hashtable_t *hash = bat_priv->claim_hash;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct claim *claim;
+ 	struct claim *claim_tmp = NULL;
+ 	int index;
+ 
+ 	if (!hash)
+ 		return NULL;
+ 
+ 	index = choose_claim(data, hash->size);
+ 	head = &hash->table[index];
+ 
+ 	rcu_read_lock();
+ 	hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
+ 		if (!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;
+ }
+ 
+ /* @bat_priv: the bat priv with all the soft interface information
+  * @addr: the address of the originator
+  * @vid: the VLAN ID
+  *
+  * looks for a claim in the hash, and returns it if found
+  * or NULL otherwise.
+  */
+ 
+ static struct backbone_gw *backbone_hash_find(struct bat_priv *bat_priv,
+ 					      uint8_t *addr, short vid)
+ {
+ 	struct hashtable_t *hash = bat_priv->backbone_hash;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct backbone_gw search_entry, *backbone_gw;
+ 	struct backbone_gw *backbone_gw_tmp = NULL;
+ 	int index;
+ 
+ 	if (!hash)
+ 		return NULL;
+ 
+ 	memcpy(search_entry.orig, addr, ETH_ALEN);
+ 	search_entry.vid = vid;
+ 
+ 	index = 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 (!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 bla_del_backbone_claims(struct backbone_gw *backbone_gw)
+ {
+ 	struct hashtable_t *hash;
+ 	struct hlist_node *node, *node_tmp;
+ 	struct hlist_head *head;
+ 	struct claim *claim;
+ 	int i;
+ 	spinlock_t *list_lock;	/* protects write access to the hash lists */
+ 
+ 	hash = backbone_gw->bat_priv->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;
+ 
+ 			claim_free_ref(claim);
+ 			hlist_del_rcu(node);
+ 		}
+ 		spin_unlock_bh(list_lock);
+ 	}
+ 
+ 	/* all claims gone, intialize CRC */
+ 	backbone_gw->crc = BLA_CRC_INIT;
+ }
+ 
+ /* @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, ...)
+  *
+  * sends a claim frame according to the provided info.
+  */
+ 
+ static void bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac,
+ 			   short vid, int claimtype)
+ {
+ 	struct sk_buff *skb;
+ 	struct ethhdr *ethhdr;
+ 	struct hard_iface *primary_if;
+ 	struct net_device *soft_iface;
+ 	uint8_t *hw_src;
+ 	struct bla_claim_dst local_claim_dest;
+ 	uint32_t zeroip = 0;
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		return;
+ 
+ 	memcpy(&local_claim_dest, &bat_priv->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:00:00
+ 			  * 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 CLAIM_TYPE_ADD:
+ 		/*
+ 		 * normal claim frame
+ 		 * set Ethernet SRC to the clients mac
+ 		 */
+ 		memcpy(ethhdr->h_source, mac, ETH_ALEN);
+ 		bat_dbg(DBG_BLA, bat_priv,
+ 			"bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid);
+ 		break;
+ 	case CLAIM_TYPE_DEL:
+ 		/*
+ 		 * unclaim frame
+ 		 * set HW SRC to the clients mac
+ 		 */
+ 		memcpy(hw_src, mac, ETH_ALEN);
+ 		bat_dbg(DBG_BLA, bat_priv,
+ 			"bla_send_claim(): UNCLAIM %pM on vid %d\n", mac, vid);
+ 		break;
+ 	case CLAIM_TYPE_ANNOUNCE:
+ 		/*
+ 		 * announcement frame
+ 		 * set HW SRC to the special mac containg the crc
+ 		 */
+ 		memcpy(hw_src, mac, ETH_ALEN);
+ 		bat_dbg(DBG_BLA, bat_priv,
+ 			"bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
+ 			ethhdr->h_source, vid);
+ 		break;
+ 	case CLAIM_TYPE_REQUEST:
+ 		/*
+ 		 * request frame
+ 		 * set HW SRC to the special mac containg the crc
+ 		 */
+ 		memcpy(hw_src, mac, ETH_ALEN);
+ 		memcpy(ethhdr->h_dest, mac, ETH_ALEN);
+ 		bat_dbg(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);
+ 	bat_priv->stats.rx_packets++;
+ 	bat_priv->stats.rx_bytes += skb->len + ETH_HLEN;
+ 	soft_iface->last_rx = jiffies;
+ 
+ 	netif_rx(skb);
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ }
+ 
+ /* @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 backbone_gw *bla_get_backbone_gw(struct bat_priv *bat_priv,
+ 					       uint8_t *orig, short vid)
+ {
+ 	struct backbone_gw *entry;
+ 	struct orig_node *orig_node;
+ 	int hash_added;
+ 
+ 	entry = backbone_hash_find(bat_priv, orig, vid);
+ 
+ 	if (entry)
+ 		return entry;
+ 
+ 	bat_dbg(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 = 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 = hash_add(bat_priv->backbone_hash, compare_backbone_gw,
+ 			      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 = orig_hash_find(bat_priv, orig);
+ 	if (orig_node) {
+ 		tt_global_del_orig(bat_priv, orig_node,
+ 				   "became a backbone gateway");
+ 		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 bla_update_own_backbone_gw(struct bat_priv *bat_priv,
+ 				       struct hard_iface *primary_if,
+ 				       short vid)
+ {
+ 	struct backbone_gw *backbone_gw;
+ 
+ 	backbone_gw = bla_get_backbone_gw(bat_priv,
+ 					  primary_if->net_dev->dev_addr, vid);
+ 	if (unlikely(!backbone_gw))
+ 		return;
+ 
+ 	backbone_gw->lasttime = jiffies;
+ 	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 bla_answer_request(struct bat_priv *bat_priv,
+ 			       struct hard_iface *primary_if, short vid)
+ {
+ 	struct hlist_node *node;
+ 	struct hlist_head *head;
+ 	struct hashtable_t *hash;
+ 	struct claim *claim;
+ 	struct backbone_gw *backbone_gw;
+ 	int i;
+ 
+ 	bat_dbg(DBG_BLA, bat_priv,
+ 		"bla_answer_request(): received a claim request, send all of our own claims again\n");
+ 
+ 	backbone_gw = backbone_hash_find(bat_priv,
+ 					 primary_if->net_dev->dev_addr, vid);
+ 	if (!backbone_gw)
+ 		return;
+ 
+ 	hash = bat_priv->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;
+ 
+ 			bla_send_claim(bat_priv, claim->addr, claim->vid,
+ 				       CLAIM_TYPE_ADD);
+ 		}
+ 		rcu_read_unlock();
+ 	}
+ 
+ 	/* finally, send an announcement frame */
+ 	bla_send_announce(bat_priv, backbone_gw);
+ 	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 bla_send_request(struct backbone_gw *backbone_gw)
+ {
+ 	/* first, remove all old entries */
+ 	bla_del_backbone_claims(backbone_gw);
+ 
+ 	bat_dbg(DBG_BLA, backbone_gw->bat_priv,
+ 		"Sending REQUEST to %pM\n",
+ 		backbone_gw->orig);
+ 
+ 	/* send request */
+ 	bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
+ 		       backbone_gw->vid, 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 bla_send_announce(struct bat_priv *bat_priv,
+ 			      struct backbone_gw *backbone_gw)
+ {
+ 	uint8_t mac[ETH_ALEN];
+ 	uint16_t crc;
+ 
+ 	memcpy(mac, announce_mac, 4);
+ 	crc = htons(backbone_gw->crc);
+ 	memcpy(&mac[4], (uint8_t *)&crc, 2);
+ 
+ 	bla_send_claim(bat_priv, mac, backbone_gw->vid, CLAIM_TYPE_ANNOUNCE);
+ 
+ }
+ 
+ /* @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
+  *
+  * Adds a claim in the claim hash.
+  */
+ 
+ static void bla_add_claim(struct bat_priv *bat_priv, const uint8_t *mac,
+ 			  const short vid, struct backbone_gw *backbone_gw)
+ {
+ 	struct claim *claim;
+ 	struct claim search_claim;
+ 	int hash_added;
+ 
+ 	memcpy(search_claim.addr, mac, ETH_ALEN);
+ 	search_claim.vid = vid;
+ 	claim = 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);
+ 		bat_dbg(DBG_BLA, bat_priv,
+ 			"bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
+ 			mac, vid);
+ 		hash_added = hash_add(bat_priv->claim_hash, compare_claim,
+ 				      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;
+ 
+ 		bat_dbg(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);
+ 		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:
+ 	claim_free_ref(claim);
+ }
+ 
+ /* Delete a claim from the claim hash which has the
+  * given mac address and vid.
+  */
+ static void bla_del_claim(struct bat_priv *bat_priv, const uint8_t *mac,
+ 			  const short vid)
+ {
+ 	struct claim search_claim, *claim;
+ 
+ 	memcpy(search_claim.addr, mac, ETH_ALEN);
+ 	search_claim.vid = vid;
+ 	claim = claim_hash_find(bat_priv, &search_claim);
+ 	if (!claim)
+ 		return;
+ 
+ 	bat_dbg(DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n", mac, vid);
+ 
+ 	hash_remove(bat_priv->claim_hash, compare_claim, choose_claim, claim);
+ 	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 */
+ 	claim_free_ref(claim);
+ }
+ 
+ /* check for ANNOUNCE frame, return 1 if handled */
+ static int handle_announce(struct bat_priv *bat_priv,
+ 			   uint8_t *an_addr, uint8_t *backbone_addr, short vid)
+ {
+ 	struct backbone_gw *backbone_gw;
+ 	uint16_t crc;
+ 
+ 	if (memcmp(an_addr, announce_mac, 4) != 0)
+ 		return 0;
+ 
+ 	backbone_gw = 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(*((uint16_t *)(&an_addr[4])));
+ 
+ 	bat_dbg(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) {
+ 		bat_dbg(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);
+ 
+ 		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);
+ 		}
+ 	}
+ 
+ 	backbone_gw_free_ref(backbone_gw);
+ 	return 1;
+ }
+ 
+ /* check for REQUEST frame, return 1 if handled */
+ static int handle_request(struct bat_priv *bat_priv,
+ 			  struct hard_iface *primary_if,
+ 			  uint8_t *backbone_addr,
+ 			  struct ethhdr *ethhdr, short vid)
+ {
+ 	/* check for REQUEST frame */
+ 	if (!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 (!compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
+ 		return 1;
+ 
+ 	bat_dbg(DBG_BLA, bat_priv,
+ 		"handle_request(): REQUEST vid %d (sent by %pM)...\n",
+ 		vid, ethhdr->h_source);
+ 
+ 	bla_answer_request(bat_priv, primary_if, vid);
+ 	return 1;
+ }
+ 
+ /* check for UNCLAIM frame, return 1 if handled */
+ static int handle_unclaim(struct bat_priv *bat_priv,
+ 			  struct hard_iface *primary_if,
+ 			  uint8_t *backbone_addr,
+ 			  uint8_t *claim_addr, short vid)
+ {
+ 	struct backbone_gw *backbone_gw;
+ 
+ 	/* unclaim in any case if it is our own */
+ 	if (primary_if && compare_eth(backbone_addr,
+ 				      primary_if->net_dev->dev_addr))
+ 		bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_DEL);
+ 
+ 	backbone_gw = backbone_hash_find(bat_priv, backbone_addr, vid);
+ 
+ 	if (!backbone_gw)
+ 		return 1;
+ 
+ 	/* this must be an UNCLAIM frame */
+ 	bat_dbg(DBG_BLA, bat_priv, "handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
+ 		claim_addr, vid, backbone_gw->orig);
+ 
+ 	bla_del_claim(bat_priv, claim_addr, vid);
+ 	backbone_gw_free_ref(backbone_gw);
+ 	return 1;
+ }
+ 
+ /* check for CLAIM frame, return 1 if handled */
+ static int handle_claim(struct bat_priv *bat_priv,
+ 			struct hard_iface *primary_if, uint8_t *backbone_addr,
+ 			uint8_t *claim_addr, short vid)
+ {
+ 	struct backbone_gw *backbone_gw;
+ 
+ 	/* register the gateway if not yet available, and add the claim. */
+ 
+ 	backbone_gw = bla_get_backbone_gw(bat_priv, backbone_addr, vid);
+ 
+ 	if (unlikely(!backbone_gw))
+ 		return 1;
+ 
+ 	/* this must be a CLAIM frame */
+ 	bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
+ 	if (compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
+ 		bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_ADD);
+ 
+ 	/* TODO: we could call something like tt_local_del() here. */
+ 
+ 	backbone_gw_free_ref(backbone_gw);
+ 	return 1;
+ }
+ 
+ /**
+  *
+  * @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 check_claim_group(struct bat_priv *bat_priv,
+ 			     struct hard_iface *primary_if,
+ 			     uint8_t *hw_src, uint8_t *hw_dst,
+ 			     struct ethhdr *ethhdr)
+ {
+ 	uint8_t *backbone_addr;
+ 	struct orig_node *orig_node;
+ 	struct bla_claim_dst *bla_dst, *bla_dst_own;
+ 
+ 	bla_dst = (struct bla_claim_dst *)hw_dst;
+ 	bla_dst_own = &bat_priv->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 CLAIM_TYPE_ADD:
+ 		backbone_addr = hw_src;
+ 		break;
+ 	case CLAIM_TYPE_REQUEST:
+ 	case CLAIM_TYPE_ANNOUNCE:
+ 	case CLAIM_TYPE_DEL:
+ 		backbone_addr = ethhdr->h_source;
+ 		break;
+ 	default:
+ 		return 0;
+ 	}
+ 
+ 	/* don't accept claim frames from ourselves */
+ 	if (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 = 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)) {
+ 		bat_dbg(DBG_BLA, bat_priv,
+ 			"taking other backbones claim group: %04x\n",
+ 			ntohs(bla_dst->group));
+ 		bla_dst_own->group = bla_dst->group;
+ 	}
+ 
+ 	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 bla_process_claim(struct bat_priv *bat_priv,
+ 			     struct 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 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 bla_claim_dst *)hw_dst;
+ 
+ 	/* check if it is a claim frame. */
+ 	ret = check_claim_group(bat_priv, primary_if, hw_src, hw_dst, ethhdr);
+ 	if (ret == 1)
+ 		bat_dbg(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 */
+ 	bla_update_own_backbone_gw(bat_priv, primary_if, vid);
+ 
+ 	/* check for the different types of claim frames ... */
+ 	switch (bla_dst->type) {
+ 	case CLAIM_TYPE_ADD:
+ 		if (handle_claim(bat_priv, primary_if, hw_src,
+ 				 ethhdr->h_source, vid))
+ 			return 1;
+ 		break;
+ 	case CLAIM_TYPE_DEL:
+ 		if (handle_unclaim(bat_priv, primary_if,
+ 				   ethhdr->h_source, hw_src, vid))
+ 			return 1;
+ 		break;
+ 
+ 	case CLAIM_TYPE_ANNOUNCE:
+ 		if (handle_announce(bat_priv, hw_src, ethhdr->h_source, vid))
+ 			return 1;
+ 		break;
+ 	case CLAIM_TYPE_REQUEST:
+ 		if (handle_request(bat_priv, primary_if, hw_src, ethhdr, vid))
+ 			return 1;
+ 		break;
+ 	}
+ 
+ 	bat_dbg(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 bla_purge_backbone_gw(struct bat_priv *bat_priv, int now)
+ {
+ 	struct backbone_gw *backbone_gw;
+ 	struct hlist_node *node, *node_tmp;
+ 	struct hlist_head *head;
+ 	struct hashtable_t *hash;
+ 	spinlock_t *list_lock;	/* protects write access to the hash lists */
+ 	int i;
+ 
+ 	hash = bat_priv->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 (!has_timed_out(backbone_gw->lasttime,
+ 					   BLA_BACKBONE_TIMEOUT))
+ 				continue;
+ 
+ 			bat_dbg(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);
+ 
+ 			bla_del_backbone_claims(backbone_gw);
+ 
+ 			hlist_del_rcu(node);
+ 			backbone_gw_free_ref(backbone_gw);
+ 		}
+ 		spin_unlock_bh(list_lock);
+ 	}
+ }
+ 
+ /**
+  * @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 bla_purge_claims(struct bat_priv *bat_priv,
+ 			     struct hard_iface *primary_if, int now)
+ {
+ 	struct claim *claim;
+ 	struct hlist_node *node;
+ 	struct hlist_head *head;
+ 	struct hashtable_t *hash;
+ 	int i;
+ 
+ 	hash = bat_priv->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 (!compare_eth(claim->backbone_gw->orig,
+ 					 primary_if->net_dev->dev_addr))
+ 				continue;
+ 			if (!has_timed_out(claim->lasttime,
+ 					   BLA_CLAIM_TIMEOUT))
+ 				continue;
+ 
+ 			bat_dbg(DBG_BLA, bat_priv,
+ 				"bla_purge_claims(): %pM, vid %d, time out\n",
+ 				claim->addr, claim->vid);
+ 
+ purge_now:
+ 			handle_unclaim(bat_priv, primary_if,
+ 				       claim->backbone_gw->orig,
+ 				       claim->addr, claim->vid);
+ 		}
+ 		rcu_read_unlock();
+ 	}
+ }
+ 
+ /**
+  * @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 bla_update_orig_address(struct bat_priv *bat_priv,
+ 			     struct hard_iface *primary_if,
+ 			     struct hard_iface *oldif)
+ {
+ 	struct backbone_gw *backbone_gw;
+ 	struct hlist_node *node;
+ 	struct hlist_head *head;
+ 	struct hashtable_t *hash;
+ 	int i;
+ 
+ 	/* reset bridge loop avoidance group id */
+ 	bat_priv->claim_dest.group =
+ 		htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
+ 
+ 	if (!oldif) {
+ 		bla_purge_claims(bat_priv, NULL, 1);
+ 		bla_purge_backbone_gw(bat_priv, 1);
+ 		return;
+ 	}
+ 
+ 	hash = bat_priv->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 (!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. */
+ 			bla_send_announce(bat_priv, backbone_gw);
+ 		}
+ 		rcu_read_unlock();
+ 	}
+ }
+ 
+ 
+ 
+ /* (re)start the timer */
+ static void bla_start_timer(struct bat_priv *bat_priv)
+ {
+ 	INIT_DELAYED_WORK(&bat_priv->bla_work, bla_periodic_work);
+ 	queue_delayed_work(bat_event_workqueue, &bat_priv->bla_work,
+ 			   msecs_to_jiffies(BLA_PERIOD_LENGTH));
+ }
+ 
+ /* periodic work to do:
+  *  * purge structures when they are too old
+  *  * send announcements
+  */
+ 
+ static void bla_periodic_work(struct work_struct *work)
+ {
+ 	struct delayed_work *delayed_work =
+ 		container_of(work, struct delayed_work, work);
+ 	struct bat_priv *bat_priv =
+ 		container_of(delayed_work, struct bat_priv, bla_work);
+ 	struct hlist_node *node;
+ 	struct hlist_head *head;
+ 	struct backbone_gw *backbone_gw;
+ 	struct hashtable_t *hash;
+ 	struct hard_iface *primary_if;
+ 	int i;
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		goto out;
+ 
+ 	bla_purge_claims(bat_priv, primary_if, 0);
+ 	bla_purge_backbone_gw(bat_priv, 0);
+ 
+ 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
+ 		goto out;
+ 
+ 	hash = bat_priv->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 (!compare_eth(backbone_gw->orig,
+ 					 primary_if->net_dev->dev_addr))
+ 				continue;
+ 
+ 			backbone_gw->lasttime = jiffies;
+ 
+ 			bla_send_announce(bat_priv, backbone_gw);
+ 		}
+ 		rcu_read_unlock();
+ 	}
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 
+ 	bla_start_timer(bat_priv);
+ }
+ 
+ /* initialize all bla structures */
+ int bla_init(struct bat_priv *bat_priv)
+ {
+ 	int i;
+ 	uint8_t claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
+ 	struct hard_iface *primary_if;
+ 
+ 	bat_dbg(DBG_BLA, bat_priv, "bla hash registering\n");
+ 
+ 	/* setting claim destination address */
+ 	memcpy(&bat_priv->claim_dest.magic, claim_dest, 3);
+ 	bat_priv->claim_dest.type = 0;
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (primary_if) {
+ 		bat_priv->claim_dest.group =
+ 			htons(crc16(0, primary_if->net_dev->dev_addr,
+ 				    ETH_ALEN));
+ 		hardif_free_ref(primary_if);
+ 	} else {
+ 		bat_priv->claim_dest.group = 0; /* will be set later */
+ 	}
+ 
+ 	/* initialize the duplicate list */
+ 	for (i = 0; i < DUPLIST_SIZE; i++)
+ 		bat_priv->bcast_duplist[i].entrytime =
+ 			jiffies - msecs_to_jiffies(DUPLIST_TIMEOUT);
+ 	bat_priv->bcast_duplist_curr = 0;
+ 
+ 	if (bat_priv->claim_hash)
+ 		return 1;
+ 
+ 	bat_priv->claim_hash = hash_new(128);
+ 	bat_priv->backbone_hash = hash_new(32);
+ 
+ 	if (!bat_priv->claim_hash || !bat_priv->backbone_hash)
+ 		return -1;
+ 
+ 	bat_dbg(DBG_BLA, bat_priv, "bla hashes initialized\n");
+ 
+ 	bla_start_timer(bat_priv);
+ 	return 1;
+ }
+ 
+ /**
+  * @bat_priv: the bat priv with all the soft interface information
+  * @bcast_packet: originator mac address
+  * @hdr_size: maximum length of the frame
+  *
+  * 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 bla_check_bcast_duplist(struct bat_priv *bat_priv,
+ 			    struct bcast_packet *bcast_packet,
+ 			    int hdr_size)
+ {
+ 	int i, length, curr;
+ 	uint8_t *content;
+ 	uint16_t crc;
+ 	struct bcast_duplist_entry *entry;
+ 
+ 	length = hdr_size - sizeof(*bcast_packet);
+ 	content = (uint8_t *)bcast_packet;
+ 	content += sizeof(*bcast_packet);
+ 
+ 	/* calculate the crc ... */
+ 	crc = crc16(0, content, length);
+ 
+ 	for (i = 0 ; i < DUPLIST_SIZE; i++) {
+ 		curr = (bat_priv->bcast_duplist_curr + i) % DUPLIST_SIZE;
+ 		entry = &bat_priv->bcast_duplist[curr];
+ 
+ 		/* we can stop searching if the entry is too old ;
+ 		 * later entries will be even older */
+ 		if (has_timed_out(entry->entrytime, DUPLIST_TIMEOUT))
+ 			break;
+ 
+ 		if (entry->crc != crc)
+ 			continue;
+ 
+ 		if (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. */
+ 		return 1;
+ 	}
+ 	/* not found, add a new entry (overwrite the oldest entry) */
+ 	curr = (bat_priv->bcast_duplist_curr + DUPLIST_SIZE - 1) % DUPLIST_SIZE;
+ 	entry = &bat_priv->bcast_duplist[curr];
+ 	entry->crc = crc;
+ 	entry->entrytime = jiffies;
+ 	memcpy(entry->orig, bcast_packet->orig, ETH_ALEN);
+ 	bat_priv->bcast_duplist_curr = curr;
+ 
+ 	/* allow it, its the first occurence. */
+ 	return 0;
+ }
+ 
+ 
+ 
+ /**
+  * @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 bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig)
+ {
+ 	struct hashtable_t *hash = bat_priv->backbone_hash;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct 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 (compare_eth(backbone_gw->orig, orig)) {
+ 				rcu_read_unlock();
+ 				return 1;
+ 			}
+ 		}
+ 		rcu_read_unlock();
+ 	}
+ 
+ 	return 0;
+ }
+ 
+ 
+ /**
+  * @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 bla_is_backbone_gw(struct sk_buff *skb,
+ 		       struct orig_node *orig_node, int hdr_size)
+ {
+ 	struct ethhdr *ethhdr;
+ 	struct vlan_ethhdr *vhdr;
+ 	struct 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 *)(((uint8_t *)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 = backbone_hash_find(orig_node->bat_priv,
+ 					 orig_node->orig, vid);
+ 	if (!backbone_gw)
+ 		return 0;
+ 
+ 	backbone_gw_free_ref(backbone_gw);
+ 	return 1;
+ }
+ 
+ /* free all bla structures (for softinterface free or module unload) */
+ void bla_free(struct bat_priv *bat_priv)
+ {
+ 	struct hard_iface *primary_if;
+ 
+ 	cancel_delayed_work_sync(&bat_priv->bla_work);
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 
+ 	if (bat_priv->claim_hash) {
+ 		bla_purge_claims(bat_priv, primary_if, 1);
+ 		hash_destroy(bat_priv->claim_hash);
+ 		bat_priv->claim_hash = NULL;
+ 	}
+ 	if (bat_priv->backbone_hash) {
+ 		bla_purge_backbone_gw(bat_priv, 1);
+ 		hash_destroy(bat_priv->backbone_hash);
+ 		bat_priv->backbone_hash = NULL;
+ 	}
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ }
+ 
+ /**
+  * @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_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 bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid)
+ {
+ 	struct ethhdr *ethhdr;
+ 	struct claim search_claim, *claim = NULL;
+ 	struct hard_iface *primary_if;
+ 	int ret;
+ 
+ 	ethhdr = (struct ethhdr *)skb_mac_header(skb);
+ 
+ 	primary_if = 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))
+ 			goto handled;
+ 
+ 	memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN);
+ 	search_claim.vid = vid;
+ 	claim = claim_hash_find(bat_priv, &search_claim);
+ 
+ 	if (!claim) {
+ 		/* possible optimization: race for a claim */
+ 		/* No claim exists yet, claim it for us! */
+ 		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 (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)) {
+ 		/* ... drop it. the responsible gateway is in charge. */
+ 		goto handled;
+ 	} else {
+ 		/* seems the client considers us as its best gateway.
+ 		 * send a claim and update the claim table
+ 		 * immediately. */
+ 		handle_claim(bat_priv, primary_if,
+ 			     primary_if->net_dev->dev_addr,
+ 			     ethhdr->h_source, vid);
+ 		goto allow;
+ 	}
+ allow:
+ 	bla_update_own_backbone_gw(bat_priv, primary_if, vid);
+ 	ret = 0;
+ 	goto out;
+ 
+ handled:
+ 	kfree_skb(skb);
+ 	ret = 1;
+ 
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 	if (claim)
+ 		claim_free_ref(claim);
+ 	return ret;
+ }
+ 
+ /**
+  * @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 bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid)
+ {
+ 	struct ethhdr *ethhdr;
+ 	struct claim search_claim, *claim = NULL;
+ 	struct hard_iface *primary_if;
+ 	int ret = 0;
+ 
+ 	primary_if = 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 (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 = claim_hash_find(bat_priv, &search_claim);
+ 
+ 	/* if no claim exists, allow it. */
+ 	if (!claim)
+ 		goto allow;
+ 
+ 	/* check if we are responsible. */
+ 	if (compare_eth(claim->backbone_gw->orig,
+ 			primary_if->net_dev->dev_addr)) {
+ 		/* if yes, the client has roamed and we have
+ 		 * to unclaim it. */
+ 		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:
+ 	bla_update_own_backbone_gw(bat_priv, primary_if, vid);
+ 	ret = 0;
+ 	goto out;
+ handled:
+ 	ret = 1;
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 	if (claim)
+ 		claim_free_ref(claim);
+ 	return ret;
+ }
+ 
+ int bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
+ {
+ 	struct net_device *net_dev = (struct net_device *)seq->private;
+ 	struct bat_priv *bat_priv = netdev_priv(net_dev);
+ 	struct hashtable_t *hash = bat_priv->claim_hash;
+ 	struct claim *claim;
+ 	struct hard_iface *primary_if;
+ 	struct hlist_node *node;
+ 	struct hlist_head *head;
+ 	uint32_t i;
+ 	bool is_own;
+ 	int ret = 0;
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	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 != IF_ACTIVE) {
+ 		ret = seq_printf(seq,
+ 				 "BATMAN mesh %s disabled - primary interface not active\n",
+ 				 net_dev->name);
+ 		goto out;
+ 	}
+ 
+ 	seq_printf(seq,
+ 		   "Claims announced for the mesh %s (orig %pM, group id %04x)\n",
+ 		   net_dev->name, primary_if->net_dev->dev_addr,
+ 		   ntohs(bat_priv->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 = compare_eth(claim->backbone_gw->orig,
+ 					     primary_if->net_dev->dev_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)
+ 		hardif_free_ref(primary_if);
+ 	return ret;
+ }
diff --combined net/batman-adv/bridge_loop_avoidance.h
index 0000000,e1a2966..e1a2966
mode 000000,100644..100644
--- a/net/batman-adv/bridge_loop_avoidance.h
+++ b/net/batman-adv/bridge_loop_avoidance.h
@@@ -1,0 -1,56 +1,56 @@@
+ /*
+  * 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
+  *
+  */
+ 
+ #ifndef _NET_BATMAN_ADV_BLA_H_
+ #define _NET_BATMAN_ADV_BLA_H_
+ 
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ int bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid);
+ int bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid);
+ int bla_is_backbone_gw(struct sk_buff *skb,
+ 		       struct orig_node *orig_node, int hdr_size);
+ int bla_claim_table_seq_print_text(struct seq_file *seq, void *offset);
+ int bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig);
+ int bla_check_bcast_duplist(struct bat_priv *bat_priv,
+ 			    struct bcast_packet *bcast_packet, int hdr_size);
+ void bla_update_orig_address(struct bat_priv *bat_priv,
+ 			     struct hard_iface *primary_if,
+ 			     struct hard_iface *oldif);
+ int bla_init(struct bat_priv *bat_priv);
+ void bla_free(struct bat_priv *bat_priv);
+ 
+ #define BLA_CRC_INIT	0
+ #else /* ifdef CONFIG_BATMAN_ADV_BLA */
+ 
+ #define bla_rx(...)				(0)
+ #define bla_tx(...)				(0)
+ #define bla_is_backbone_gw(...)			(0)
+ #define bla_claim_table_seq_print_text		(0)
+ #define bla_is_backbone_gw_orig(...)		(0)
+ #define bla_check_bcast_duplist(...)		(0)
+ #define bla_update_orig_address(...)		do {} while (0)
+ #define bla_init(...)				(1)
+ #define bla_free(...)				do {} while (0)
+ 
+ 
+ #endif /* ifdef CONFIG_BATMAN_ADV_BLA */
+ 
+ #endif /* ifndef _NET_BATMAN_ADV_BLA_H_ */
diff --combined net/batman-adv/distributed-arp-table.c
index 0000000,b43bece..b43bece
mode 000000,100644..100644
--- a/net/batman-adv/distributed-arp-table.c
+++ b/net/batman-adv/distributed-arp-table.c
@@@ -1,0 -1,581 +1,581 @@@
+ /*
+  * Copyright (C) 2011-2012 B.A.T.M.A.N. contributors:
+  *
+  * 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 <linux/if_ether.h>
+ #include <linux/if_arp.h>
+ /* needed to use arp_tbl */
+ #include <net/arp.h>
+ #include <linux/inetdevice.h>
+ 
+ #include "main.h"
+ #include "distributed-arp-table.h"
+ #include "hard-interface.h"
+ #include "originator.h"
+ #include "send.h"
+ #include "types.h"
+ #include "translation-table.h"
+ #include "unicast.h"
+ 
+ #ifdef CONFIG_BATMAN_ADV_DEBUG
+ 
+ static void bat_dbg_arp(struct bat_priv *bat_priv, struct sk_buff *skb,
+ 			uint16_t type, int hdr_size, char *msg) {
+ 	struct unicast_4addr_packet *unicast_4addr_packet;
+ 
+ 	if (msg)
+ 		bat_dbg(DBG_DAT, bat_priv, "%s\n", msg);
+ 
+ 	bat_dbg(DBG_DAT, bat_priv, "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
+ 		ARP_HW_SRC(skb, hdr_size), &ARP_IP_SRC(skb, hdr_size),
+ 		ARP_HW_DST(skb, hdr_size), &ARP_IP_DST(skb, hdr_size));
+ 
+ 	if (hdr_size == 0)
+ 		return;
+ 
+ 	/* if the AP packet is encapsulated in a batman packet, let's print some
+ 	 * debug messages */
+ 	unicast_4addr_packet = (struct unicast_4addr_packet *)skb->data;
+ 
+ 	switch (unicast_4addr_packet->u.header.packet_type) {
+ 	case BAT_UNICAST:
+ 		bat_dbg(DBG_DAT, bat_priv,
+ 			"* encapsulated within a UNICAST packet\n");
+ 		break;
+ 	case BAT_UNICAST_4ADDR:
+ 		bat_dbg(DBG_DAT, bat_priv,
+ 			"* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
+ 			unicast_4addr_packet->src);
+ 		switch (unicast_4addr_packet->subtype) {
+ 		case BAT_P_DAT_DHT_PUT:
+ 			bat_dbg(DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
+ 			break;
+ 		case BAT_P_DAT_DHT_GET:
+ 			bat_dbg(DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
+ 			break;
+ 		case BAT_P_DAT_CACHE_REPLY:
+ 			bat_dbg(DBG_DAT, bat_priv, "* type: DAT_CACHE_REPLY\n");
+ 			break;
+ 		case BAT_P_DATA:
+ 			bat_dbg(DBG_DAT, bat_priv, "* type: DATA\n");
+ 			break;
+ 		default:
+ 			bat_dbg(DBG_DAT, bat_priv, "* type: Unknown!\n");
+ 		}
+ 		break;
+ 	case BAT_BCAST:
+ 		bat_dbg(DBG_DAT, bat_priv,
+ 			"* encapsulated within a BCAST packet (src: %pM)\n",
+ 			((struct bcast_packet *)unicast_4addr_packet)->orig);
+ 		break;
+ 	default:
+ 		bat_dbg(DBG_DAT, bat_priv,
+ 			"* encapsulated within an unknown packet type (0x%x)\n",
+ 			unicast_4addr_packet->u.header.packet_type);
+ 	}
+ }
+ 
+ #else
+ 
+ #define bat_dbg_arp(...)
+ 
+ #endif /* CONFIG_BATMAN_ADV_DEBUG */
+ 
+ static bool is_orig_node_eligible(struct dht_candidate *res, int select,
+ 				  dat_addr_t tmp_max, dat_addr_t max,
+ 				  dat_addr_t last_max,
+ 				  struct orig_node *candidate,
+ 				  struct orig_node *max_orig_node)
+ {
+ 	bool ret = false;
+ 	int j;
+ 
+ 	/* Check if we have already selected this neighbour... */
+ 	for (j = 0; j < select; j++)
+ 		if (res[j].orig_node == candidate)
+ 			break;
+ 	/* ..and possibly skip it */
+ 	if (j < select)
+ 		goto out;
+ 	/* sanity check: has it already been selected? This should not happen */
+ 	if (tmp_max > last_max)
+ 		goto out;
+ 	/* check if during this iteration we have already found an originator
+ 	 * with a closer dht address */
+ 	if (tmp_max < max)
+ 		goto out;
+ 	/* this is an hash collision with the temporary selected node. Choose
+ 	 * the one with the lowest address */
+ 	if ((tmp_max == max) &&
+ 	    (compare_eth(candidate->orig, max_orig_node->orig) > 0))
+ 		goto out;
+ 
+ 	ret = true;
+ out:
+ 	return ret;
+ }
+ 
+ /* selects the next candidate by populating cands[select] and modifies last_max
+  * accordingly */
+ static void choose_next_candidate(struct bat_priv *bat_priv,
+ 				  struct dht_candidate *cands, int select,
+ 				  dat_addr_t ip_key, dat_addr_t *last_max)
+ {
+ 	dat_addr_t max = 0, tmp_max = 0;
+ 	struct orig_node *orig_node, *max_orig_node = NULL;
+ 	struct hashtable_t *hash = bat_priv->orig_hash;
+ 	struct hlist_node *node;
+ 	struct hlist_head *head;
+ 	int i;
+ 
+ 	/* if no node is eligible as candidate, we will leave the candidate as
+ 	 * NOT_FOUND */
+ 	cands[select].type = DHT_CANDIDATE_NOT_FOUND;
+ 
+ 	/* iterate over the originator list and find the node with closest
+ 	 * dht_address which has not been selected yet */
+ 	for (i = 0; i < hash->size; i++) {
+ 		head = &hash->table[i];
+ 
+ 		rcu_read_lock();
+ 		hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+ 			/* the dht space is a ring and addresses are unsigned */
+ 			tmp_max = DAT_ADDR_MAX - orig_node->dht_addr + ip_key;
+ 
+ 			if (!is_orig_node_eligible(cands, select, tmp_max, max,
+ 						   *last_max, orig_node,
+ 						   max_orig_node))
+ 				continue;
+ 
+ 			if (!atomic_inc_not_zero(&orig_node->refcount))
+ 				continue;
+ 
+ 			max = tmp_max;
+ 			if (max_orig_node)
+ 				orig_node_free_ref(max_orig_node);
+ 			max_orig_node = orig_node;
+ 		}
+ 		rcu_read_unlock();
+ 	}
+ 	if (max_orig_node) {
+ 		cands[select].type = DHT_CANDIDATE_ORIG;
+ 		cands[select].orig_node = max_orig_node;
+ 		bat_dbg(DBG_DAT, bat_priv,
+ 			"dht_select_candidates() %d: selected %pM addr=%u dist=%u\n",
+ 			select, max_orig_node->orig, max_orig_node->dht_addr,
+ 			max);
+ 	}
+ 	*last_max = max;
+ }
+ 
+ /* Given a key, selects the candidates which the DHT message has to be sent to.
+  * An originator O is selected if and only if its DHT_ID value is one of three
+  * closest values (from the LEFT, with wrap around if needed) then the hash
+  * value of the key. ip_dst is the key.
+  *
+  * return an array of size DHT_CANDIDATES_NUM */
+ static struct dht_candidate *dht_select_candidates(struct bat_priv *bat_priv,
+ 						   uint32_t ip_dst)
+ {
+ 	int select;
+ 	dat_addr_t last_max = DAT_ADDR_MAX, ip_key;
+ 	struct dht_candidate *res;
+ 
+ 	if (!bat_priv->orig_hash)
+ 		return NULL;
+ 
+ 	res = kmalloc(DHT_CANDIDATES_NUM * sizeof(*res), GFP_ATOMIC);
+ 	if (!res)
+ 		return NULL;
+ 
+ 	ip_key = (dat_addr_t)hash_ipv4(&ip_dst, DAT_ADDR_MAX);
+ 
+ 	bat_dbg(DBG_DAT, bat_priv,
+ 		"dht_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst,
+ 		ip_key);
+ 
+ 	for (select = 0; select < DHT_CANDIDATES_NUM; select++)
+ 		choose_next_candidate(bat_priv, res, select, ip_key, &last_max);
+ 
+ 	return res;
+ }
+ 
+ /* Sends the skb payload passed as argument to the candidates selected for
+  * the data represented by 'ip'. The skb is copied by means of pskb_copy()
+  * and is sent as unicast packet to each of the selected candidate.
+  *
+  * If the packet is successfully sent to at least one candidate, then this
+  * function returns true */
+ static bool dht_send_data(struct bat_priv *bat_priv, struct sk_buff *skb,
+ 			  uint32_t ip, int packet_subtype)
+ {
+ 	int i;
+ 	bool ret = false;
+ 	struct neigh_node *neigh_node = NULL;
+ 	struct sk_buff *tmp_skb;
+ 	struct dht_candidate *cand = dht_select_candidates(bat_priv, ip);
+ 
+ 	if (!cand)
+ 		goto out;
+ 
+ 	bat_dbg(DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
+ 
+ 	for (i = 0; i < DHT_CANDIDATES_NUM; i++) {
+ 		if (cand[i].type == DHT_CANDIDATE_NOT_FOUND)
+ 			continue;
+ 
+ 		neigh_node = orig_node_get_router(cand[i].orig_node);
+ 		if (!neigh_node)
+ 			goto free_orig;
+ 
+ 		tmp_skb = pskb_copy(skb, GFP_ATOMIC);
+ 		if (!prepare_unicast_4addr_packet(bat_priv, tmp_skb,
+ 						  cand[i].orig_node,
+ 						  packet_subtype)) {
+ 			kfree_skb(tmp_skb);
+ 			goto free_neigh;
+ 		}
+ 		if (send_skb_packet(tmp_skb, neigh_node->if_incoming,
+ 				    neigh_node->addr) == NET_XMIT_SUCCESS)
+ 			/* packet sent to a candidate: we can return true */
+ 			ret = true;
+ free_neigh:
+ 		neigh_node_free_ref(neigh_node);
+ free_orig:
+ 		orig_node_free_ref(cand[i].orig_node);
+ 	}
+ 
+ out:
+ 	kfree(cand);
+ 	return ret;
+ }
+ 
+ /* Update the neighbour entry corresponding to the IP passed as parameter with
+  * the hw address hw. If the neighbour entry doesn't exists, then it will be
+  * created */
+ static void arp_neigh_update(struct bat_priv *bat_priv, uint32_t ip,
+ 			     uint8_t *hw)
+ {
+ 	struct neighbour *n = NULL;
+ 	struct hard_iface *primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		goto out;
+ 
+ 	n = __neigh_lookup(&arp_tbl, &ip, primary_if->soft_iface, 1);
+ 	if (!n)
+ 		goto out;
+ 
+ 	bat_dbg(DBG_DAT, bat_priv, "Updating neighbour: %pI4 - %pM\n", &ip, hw);
+ 
+ 	neigh_update(n, hw, NUD_REACHABLE, NEIGH_UPDATE_F_OVERRIDE);
+ out:
+ 	if (n && !IS_ERR(n))
+ 		neigh_release(n);
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ }
+ 
+ /* Returns arphdr->ar_op if the skb contains a valid ARP packet, otherwise
+  * returns 0 */
+ static uint16_t arp_get_type(struct bat_priv *bat_priv, struct sk_buff *skb,
+ 			     int hdr_size)
+ {
+ 	struct arphdr *arphdr;
+ 	struct ethhdr *ethhdr;
+ 	uint32_t ip_src, ip_dst;
+ 	uint16_t type = 0;
+ 
+ 	/* pull the ethernet header */
+ 	if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
+ 		goto out;
+ 
+ 	ethhdr = (struct ethhdr *)(skb->data + hdr_size);
+ 
+ 	if (ethhdr->h_proto != htons(ETH_P_ARP))
+ 		goto out;
+ 
+ 	/* pull the ARP payload */
+ 	if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
+ 				    arp_hdr_len(skb->dev))))
+ 		goto out;
+ 
+ 	arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
+ 
+ 	/* Check whether the ARP packet carries a valid
+ 	 * IP information */
+ 	if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
+ 		goto out;
+ 
+ 	if (arphdr->ar_pro != htons(ETH_P_IP))
+ 		goto out;
+ 
+ 	if (arphdr->ar_hln != ETH_ALEN)
+ 		goto out;
+ 
+ 	if (arphdr->ar_pln != 4)
+ 		goto out;
+ 
+ 	/* Check for bad reply/request. If the ARP message is not sane, DAT
+ 	 * will simply ignore it */
+ 	ip_src = ARP_IP_SRC(skb, hdr_size);
+ 	ip_dst = ARP_IP_DST(skb, hdr_size);
+ 	if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
+ 	    ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst))
+ 		goto out;
+ 
+ 	type = ntohs(arphdr->ar_op);
+ out:
+ 	return type;
+ }
+ 
+ /* return true if the message has been sent to the dht candidates, false
+  * otherwise. In case of true the message has to be enqueued to permit the
+  * fallback */
+ bool dat_snoop_outgoing_arp_request(struct bat_priv *bat_priv,
+ 				    struct sk_buff *skb)
+ {
+ 	uint16_t type = 0;
+ 	uint32_t ip_dst, ip_src;
+ 	uint8_t *hw_src;
+ 	bool ret = false;
+ 	struct neighbour *n = NULL;
+ 	struct hard_iface *primary_if = NULL;
+ 	struct sk_buff *skb_new;
+ 
+ 	type = arp_get_type(bat_priv, skb, 0);
+ 	/* If we get an ARP_REQUEST we have to send the unicast message to the
+ 	 * selected DHT candidates */
+ 	if (type != ARPOP_REQUEST)
+ 		goto out;
+ 
+ 	bat_dbg_arp(bat_priv, skb, type, 0, "Parsing outgoing ARP REQUEST");
+ 
+ 	ip_src = ARP_IP_SRC(skb, 0);
+ 	hw_src = ARP_HW_SRC(skb, 0);
+ 	ip_dst = ARP_IP_DST(skb, 0);
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		goto out;
+ 
+ 	arp_neigh_update(bat_priv, ip_src, hw_src);
+ 
+ 	n = neigh_lookup(&arp_tbl, &ip_dst, primary_if->soft_iface);
+ 	/* check if it is a valid neigh entry */
+ 	if (n && (n->nud_state & NUD_CONNECTED)) {
+ 		skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
+ 				     primary_if->soft_iface, ip_dst, hw_src,
+ 				     n->ha, hw_src);
+ 		if (!skb_new)
+ 			goto out;
+ 
+ 		skb_reset_mac_header(skb_new);
+ 		skb_new->protocol = eth_type_trans(skb_new,
+ 						   primary_if->soft_iface);
+ 		bat_priv->stats.rx_packets++;
+ 		bat_priv->stats.rx_bytes += skb->len + ETH_HLEN;
+ 		primary_if->soft_iface->last_rx = jiffies;
+ 
+ 		netif_rx(skb_new);
+ 		bat_dbg(DBG_DAT, bat_priv, "ARP request replied locally\n");
+ 	} else
+ 		/* Send the request on the DHT */
+ 		ret = dht_send_data(bat_priv, skb, ip_dst, BAT_P_DAT_DHT_GET);
+ out:
+ 	if (n)
+ 		neigh_release(n);
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 	return ret;
+ }
+ 
+ /* This function is meant to be invoked for an ARP request which is coming into
+  * the bat0 interfaces from the mesh network. It will check for the needed data
+  * into the local table. If found, an ARP reply is sent immediately, otherwise
+  * the caller has to deliver the ARP request to the upper layer */
+ bool dat_snoop_incoming_arp_request(struct bat_priv *bat_priv,
+ 				    struct sk_buff *skb, int hdr_size)
+ {
+ 	uint16_t type;
+ 	uint32_t ip_src, ip_dst;
+ 	uint8_t *hw_src;
+ 	struct hard_iface *primary_if = NULL;
+ 	struct sk_buff *skb_new;
+ 	struct neighbour *n = NULL;
+ 	bool ret = false;
+ 
+ 	type = arp_get_type(bat_priv, skb, hdr_size);
+ 	if (type != ARPOP_REQUEST)
+ 		goto out;
+ 
+ 	hw_src = ARP_HW_SRC(skb, hdr_size);
+ 	ip_src = ARP_IP_SRC(skb, hdr_size);
+ 	ip_dst = ARP_IP_DST(skb, hdr_size);
+ 
+ 	bat_dbg_arp(bat_priv, skb, type, hdr_size,
+ 		    "Parsing incoming ARP REQUEST");
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		goto out;
+ 
+ 	arp_neigh_update(bat_priv, ip_src, hw_src);
+ 
+ 	n = neigh_lookup(&arp_tbl, &ip_dst, primary_if->soft_iface);
+ 	/* check if it is a valid neigh entry */
+ 	if (!n || !(n->nud_state & NUD_CONNECTED))
+ 		goto out;
+ 
+ 	skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
+ 			     primary_if->soft_iface, ip_dst, hw_src, n->ha,
+ 			     hw_src);
+ 
+ 	if (!skb_new)
+ 		goto out;
+ 
+ 	unicast_4addr_send_skb(skb_new, bat_priv, BAT_P_DAT_CACHE_REPLY);
+ 
+ 	ret = true;
+ out:
+ 	if (n)
+ 		neigh_release(n);
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 	if (ret)
+ 		kfree_skb(skb);
+ 	return ret;
+ }
+ 
+ /* This function is meant to be invoked on an ARP reply packet going into the
+  * soft interface. The related neighbour entry has to be updated and the DHT has
+  * to be populated as well */
+ bool dat_snoop_outgoing_arp_reply(struct bat_priv *bat_priv,
+ 				  struct sk_buff *skb)
+ {
+ 	uint16_t type;
+ 	uint32_t ip_src, ip_dst;
+ 	uint8_t *hw_src, *hw_dst;
+ 	bool ret = false;
+ 
+ 	type = arp_get_type(bat_priv, skb, 0);
+ 	if (type != ARPOP_REPLY)
+ 		goto out;
+ 
+ 	bat_dbg_arp(bat_priv, skb, type, 0, "Parsing outgoing ARP REPLY");
+ 
+ 	hw_src = ARP_HW_SRC(skb, 0);
+ 	ip_src = ARP_IP_SRC(skb, 0);
+ 	hw_dst = ARP_HW_DST(skb, 0);
+ 	ip_dst = ARP_IP_DST(skb, 0);
+ 
+ 	arp_neigh_update(bat_priv, ip_src, hw_src);
+ 	arp_neigh_update(bat_priv, ip_dst, hw_dst);
+ 
+ 	/* Send the ARP reply to the candidates for both the IP addresses we
+ 	 * fetched from the ARP reply */
+ 	dht_send_data(bat_priv, skb, ip_src, BAT_P_DAT_DHT_PUT);
+ 	dht_send_data(bat_priv, skb, ip_dst, BAT_P_DAT_DHT_PUT);
+ 	ret = true;
+ out:
+ 	return ret;
+ }
+ 
+ /* This function has to be invoked on an ARP reply coming into the soft
+  * interface from the mesh network. The local table has to be updated */
+ bool dat_snoop_incoming_arp_reply(struct bat_priv *bat_priv,
+ 				  struct sk_buff *skb, int hdr_size)
+ {
+ 	uint16_t type;
+ 	uint32_t ip_src, ip_dst;
+ 	uint8_t *hw_src, *hw_dst;
+ 	bool ret = false;
+ 
+ 	type = arp_get_type(bat_priv, skb, hdr_size);
+ 	if (type != ARPOP_REPLY)
+ 		goto out;
+ 
+ 	bat_dbg_arp(bat_priv, skb, type, hdr_size,
+ 		    "Parsing incoming ARP REPLY");
+ 
+ 	hw_src = ARP_HW_SRC(skb, hdr_size);
+ 	ip_src = ARP_IP_SRC(skb, hdr_size);
+ 	hw_dst = ARP_HW_DST(skb, hdr_size);
+ 	ip_dst = ARP_IP_DST(skb, hdr_size);
+ 
+ 	/* Update our internal cache with both the IP addresses we fetched from
+ 	 * the ARP reply */
+ 	arp_neigh_update(bat_priv, ip_src, hw_src);
+ 	arp_neigh_update(bat_priv, ip_dst, hw_dst);
+ 
+ 	/* if this REPLY is directed to a client of mine, let's deliver the
+ 	 * packet to the interface */
+ 	ret = !is_my_client(bat_priv, hw_dst);
+ out:
+ 	/* if ret == false packet has to be delivered to the interface */
+ 	return ret;
+ }
+ 
+ bool dat_drop_broadcast_packet(struct bat_priv *bat_priv,
+ 			       struct forw_packet *forw_packet)
+ {
+ 	struct neighbour *n;
+ 
+ 	/* If this packet is an ARP_REQUEST and we already have the information
+ 	 * that it is going to ask, we can drop the packet */
+ 	if (!forw_packet->num_packets &&
+ 	    (ARPOP_REQUEST == arp_get_type(bat_priv, forw_packet->skb,
+ 					   sizeof(struct bcast_packet)))) {
+ 		n = neigh_lookup(&arp_tbl,
+ 				 &ARP_IP_DST(forw_packet->skb,
+ 					     sizeof(struct bcast_packet)),
+ 				 forw_packet->if_incoming->soft_iface);
+ 		/* check if we already know this neigh */
+ 		if (n && (n->nud_state & NUD_CONNECTED)) {
+ 			bat_dbg(DBG_DAT, bat_priv,
+ 				"ARP Request for %pI4: fallback prevented\n",
+ 				&ARP_IP_DST(forw_packet->skb,
+ 					    sizeof(struct bcast_packet)));
+ 			return true;
+ 		}
+ 
+ 		bat_dbg(DBG_DAT, bat_priv, "ARP Request for %pI4: fallback\n",
+ 			&ARP_IP_DST(forw_packet->skb,
+ 				    sizeof(struct bcast_packet)));
+ 	}
+ 	return false;
+ }
+ 
+ void arp_change_timeout(struct net_device *soft_iface, const char *name)
+ {
+ 	struct in_device *in_dev = in_dev_get(soft_iface);
+ 	if (!in_dev) {
+ 		pr_err("Unable to set ARP parameters for the batman interface '%s'\n",
+ 		       name);
+ 		return;
+ 	}
+ 
+ 	/* Introduce a delay in the ARP state-machine transactions. Entries
+ 	 * will be kept in the ARP table for the default time multiplied by 4 */
+ 	in_dev->arp_parms->base_reachable_time *= ARP_TIMEOUT_FACTOR;
+ 	in_dev->arp_parms->gc_staletime *= ARP_TIMEOUT_FACTOR;
+ 	in_dev->arp_parms->reachable_time *= ARP_TIMEOUT_FACTOR;
+ 
+ 	in_dev_put(in_dev);
+ }
diff --combined net/batman-adv/distributed-arp-table.h
index 0000000,26b98c0..26b98c0
mode 000000,100644..100644
--- a/net/batman-adv/distributed-arp-table.h
+++ b/net/batman-adv/distributed-arp-table.h
@@@ -1,0 -1,102 +1,102 @@@
+ /*
+  * Copyright (C) 2011-2012 B.A.T.M.A.N. contributors:
+  *
+  * Antonio Quartulli
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of version 2 of the GNU General Public
+  * License as published by the Free Software Foundation.
+  *
+  * This program is distributed in the hope that it will be useful, but
+  * WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  * General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+  * 02110-1301, USA
+  *
+  */
+ 
+ #ifndef _NET_BATMAN_ADV_ARP_H_
+ #define _NET_BATMAN_ADV_ARP_H_
+ 
+ #ifdef CONFIG_BATMAN_ADV_DAT
+ 
+ #include "types.h"
+ #include "originator.h"
+ 
+ #include <linux/if_arp.h>
+ 
+ #define DAT_ADDR_MAX biggest_unsigned_int(dat_addr_t)
+ 
+ #define ARP_HW_SRC(skb, hdr_size) ((uint8_t *)(skb->data + hdr_size) + \
+ 				   ETH_HLEN + sizeof(struct arphdr))
+ #define ARP_IP_SRC(skb, hdr_size) (*(uint32_t *)(ARP_HW_SRC(skb, hdr_size) + \
+ 				   ETH_ALEN))
+ #define ARP_HW_DST(skb, hdr_size) (ARP_HW_SRC(skb, hdr_size) + ETH_ALEN + 4)
+ #define ARP_IP_DST(skb, hdr_size) (*(uint32_t *)(ARP_HW_SRC(skb, hdr_size) + \
+ 				   ETH_ALEN * 2 + 4))
+ 
+ bool dat_snoop_outgoing_arp_request(struct bat_priv *bat_priv,
+ 				    struct sk_buff *skb);
+ bool dat_snoop_incoming_arp_request(struct bat_priv *bat_priv,
+ 				    struct sk_buff *skb, int hdr_size);
+ bool dat_snoop_outgoing_arp_reply(struct bat_priv *bat_priv,
+ 				  struct sk_buff *skb);
+ bool dat_snoop_incoming_arp_reply(struct bat_priv *bat_priv,
+ 				  struct sk_buff *skb, int hdr_size);
+ bool dat_drop_broadcast_packet(struct bat_priv *bat_priv,
+ 			       struct forw_packet *forw_packet);
+ void arp_change_timeout(struct net_device *soft_iface, const char *name);
+ 
+ /* hash function to choose an entry in a hash table of given size */
+ /* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
+ static inline uint32_t hash_ipv4(const void *data, uint32_t size)
+ {
+ 	const unsigned char *key = data;
+ 	uint32_t hash = 0;
+ 	size_t i;
+ 
+ 	for (i = 0; i < 4; i++) {
+ 		hash += key[i];
+ 		hash += (hash << 10);
+ 		hash ^= (hash >> 6);
+ 	}
+ 
+ 	hash += (hash << 3);
+ 	hash ^= (hash >> 11);
+ 	hash += (hash << 15);
+ 
+ 	return hash % size;
+ }
+ 
+ static inline void dat_init_orig_node_dht_addr(struct orig_node *orig_node)
+ {
+ 	orig_node->dht_addr = (dat_addr_t)choose_orig(orig_node->orig,
+ 						      DAT_ADDR_MAX);
+ }
+ 
+ static inline void dat_init_own_dht_addr(struct bat_priv *bat_priv,
+ 					 struct hard_iface *primary_if)
+ {
+ 	bat_priv->dht_addr = (dat_addr_t)
+ 				choose_orig(primary_if->net_dev->dev_addr,
+ 					    DAT_ADDR_MAX);
+ }
+ 
+ #else
+ 
+ #define dat_snoop_outgoing_arp_request(...) (0)
+ #define dat_snoop_incoming_arp_request(...) (0)
+ #define dat_snoop_outgoing_arp_reply(...)
+ #define dat_snoop_incoming_arp_reply(...) (0)
+ #define dat_drop_broadcast_packet(...) (0)
+ #define arp_change_timeout(...)
+ #define dat_init_orig_node_dht_addr(...)
+ #define dat_init_own_dht_addr(...)
+ 
+ #endif /* CONFIG_BATMAN_ADV_DAT */
+ 
+ #endif /* _NET_BATMAN_ADV_ARP_H_ */
diff --combined net/batman-adv/gateway_client.c
index 6f9b9b7,47f7186..47f7186
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@@ -558,10 -558,10 +558,10 @@@ static bool is_type_dhcprequest(struct 
    		p++;
/* ...and then we jump over the data */
- 			if (pkt_len < *p)
+ 			if (pkt_len < 1 + (*p))
    			goto out;
- 			pkt_len -= *p;
- 			p += (*p);
+ 			pkt_len -= 1 + (*p);
+ 			p += 1 + (*p);
    	}
    }
  out:
diff --combined net/batman-adv/hard-interface.c
index 3778977,e647a43..e647a43
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@@ -20,6 -20,7 +20,7 @@@
   */
#include "main.h"
+ #include "distributed-arp-table.h"
  #include "hard-interface.h"
  #include "soft-interface.h"
  #include "send.h"
@@@ -28,15 -29,10 +29,10 @@@
  #include "bat_sysfs.h"
  #include "originator.h"
  #include "hash.h"
+ #include "bridge_loop_avoidance.h"
#include <linux/if_arp.h>
- 
- static int batman_skb_recv(struct sk_buff *skb,
- 			   struct net_device *dev,
- 			   struct packet_type *ptype,
- 			   struct net_device *orig_dev);
- 
  void hardif_free_rcu(struct rcu_head *rcu)
  {
    struct hard_iface *hard_iface;
@@@ -107,7 -103,8 +103,8 @@@ out
    return hard_iface;
  }
- static void primary_if_update_addr(struct bat_priv *bat_priv)
+ static void primary_if_update_addr(struct bat_priv *bat_priv,
+ 				   struct hard_iface *oldif)
  {
    struct vis_packet *vis_packet;
    struct hard_iface *primary_if;
@@@ -116,12 -113,15 +113,15 @@@
    if (!primary_if)
    	goto out;
+ 	dat_init_own_dht_addr(bat_priv, primary_if);
+ 
    vis_packet = (struct vis_packet *)
    			bat_priv->my_vis_info->skb_packet->data;
    memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN);
    memcpy(vis_packet->sender_orig,
           primary_if->net_dev->dev_addr, ETH_ALEN);
+ 	bla_update_orig_address(bat_priv, primary_if, oldif);
  out:
    if (primary_if)
    	hardif_free_ref(primary_if);
@@@ -140,14 -140,15 +140,15 @@@ static void primary_if_select(struct ba
    curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1);
    rcu_assign_pointer(bat_priv->primary_if, new_hard_iface);
- 	if (curr_hard_iface)
- 		hardif_free_ref(curr_hard_iface);
- 
    if (!new_hard_iface)
- 		return;
+ 		goto out;
- 	bat_priv->bat_algo_ops->bat_ogm_init_primary(new_hard_iface);
- 	primary_if_update_addr(bat_priv);
+ 	bat_priv->bat_algo_ops->bat_primary_iface_set(new_hard_iface);
+ 	primary_if_update_addr(bat_priv, curr_hard_iface);
+ 
+ out:
+ 	if (curr_hard_iface)
+ 		hardif_free_ref(curr_hard_iface);
  }
static bool hardif_is_iface_up(const struct hard_iface *hard_iface)
@@@ -175,9 -176,9 +176,9 @@@ static void check_known_mac_addr(const 
    			 net_dev->dev_addr))
    		continue;
- 		pr_warning("The newly added mac address (%pM) already exists on: %s\n",
- 			   net_dev->dev_addr, hard_iface->net_dev->name);
- 		pr_warning("It is strongly recommended to keep mac addresses unique to avoid problems!\n");
+ 		pr_warn("The newly added mac address (%pM) already exists on: %s\n",
+ 			net_dev->dev_addr, hard_iface->net_dev->name);
+ 		pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n");
    }
    rcu_read_unlock();
  }
@@@ -230,7 -231,7 +231,7 @@@ static void hardif_activate_interface(s
bat_priv = netdev_priv(hard_iface->soft_iface);
- 	bat_priv->bat_algo_ops->bat_ogm_update_mac(hard_iface);
+ 	bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface);
    hard_iface->if_status = IF_TO_BE_ACTIVATED;
/**
@@@ -300,22 -301,17 +301,17 @@@ int hardif_enable_interface(struct hard
    if (!softif_is_valid(soft_iface)) {
    	pr_err("Can't create batman mesh interface %s: already exists as regular interface\n",
    	       soft_iface->name);
- 		dev_put(soft_iface);
    	ret = -EINVAL;
- 		goto err;
+ 		goto err_dev;
    }
hard_iface->soft_iface = soft_iface;
    bat_priv = netdev_priv(hard_iface->soft_iface);
- 	bat_priv->bat_algo_ops->bat_ogm_init(hard_iface);
- 
- 	if (!hard_iface->packet_buff) {
- 		bat_err(hard_iface->soft_iface,
- 			"Can't add interface packet (%s): out of memory\n",
- 			hard_iface->net_dev->name);
+ 	ret = bat_priv->bat_algo_ops->bat_iface_enable(hard_iface);
+ 	if (ret < 0) {
    	ret = -ENOMEM;
- 		goto err;
+ 		goto err_dev;
    }
hard_iface->if_num = bat_priv->num_ifaces;
@@@ -328,7 -324,6 +324,6 @@@
    hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;
    dev_add_pack(&hard_iface->batman_adv_ptype);
- 	atomic_set(&hard_iface->seqno, 1);
    atomic_set(&hard_iface->frag_seqno, 1);
    bat_info(hard_iface->soft_iface, "Adding interface: %s\n",
    	 hard_iface->net_dev->name);
@@@ -360,6 -355,8 +355,8 @@@
  out:
    return 0;
+ err_dev:
+ 	dev_put(soft_iface);
  err:
    hardif_free_ref(hard_iface);
    return ret;
@@@ -394,8 -391,7 +391,7 @@@ void hardif_disable_interface(struct ha
    		hardif_free_ref(new_if);
    }
- 	kfree(hard_iface->packet_buff);
- 	hard_iface->packet_buff = NULL;
+ 	bat_priv->bat_algo_ops->bat_iface_disable(hard_iface);
    hard_iface->if_status = IF_NOT_IN_USE;
/* delete all references to this hard_iface */
@@@ -447,6 -443,13 +443,13 @@@ static struct hard_iface *hardif_add_in
    check_known_mac_addr(hard_iface->net_dev);
    list_add_tail_rcu(&hard_iface->list, &hardif_list);
+ 	/**
+ 	 * This can't be called via a bat_priv callback because
+ 	 * we have no bat_priv yet.
+ 	 */
+ 	atomic_set(&hard_iface->seqno, 1);
+ 	hard_iface->packet_buff = NULL;
+ 
    return hard_iface;
free_if:
@@@ -524,14 -527,14 +527,14 @@@ static int hard_if_event(struct notifie
    	check_known_mac_addr(hard_iface->net_dev);
bat_priv = netdev_priv(hard_iface->soft_iface);
- 		bat_priv->bat_algo_ops->bat_ogm_update_mac(hard_iface);
+ 		bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface);
primary_if = primary_if_get_selected(bat_priv);
    	if (!primary_if)
    		goto hardif_put;
if (hard_iface == primary_if)
- 			primary_if_update_addr(bat_priv);
+ 			primary_if_update_addr(bat_priv, NULL);
    	break;
    default:
    	break;
@@@ -545,114 -548,6 +548,6 @@@ out
    return NOTIFY_DONE;
  }
- /* incoming packets with the batman ethertype received on any active hard
-  * interface */
- static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
- 			   struct packet_type *ptype,
- 			   struct net_device *orig_dev)
- {
- 	struct bat_priv *bat_priv;
- 	struct batman_ogm_packet *batman_ogm_packet;
- 	struct hard_iface *hard_iface;
- 	int ret;
- 
- 	hard_iface = container_of(ptype, struct 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 != sizeof(struct ethhdr) ||
- 		     !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) != MESH_ACTIVE)
- 		goto err_free;
- 
- 	/* discard frames on not active interfaces */
- 	if (hard_iface->if_status != IF_ACTIVE)
- 		goto err_free;
- 
- 	batman_ogm_packet = (struct batman_ogm_packet *)skb->data;
- 
- 	if (batman_ogm_packet->header.version != COMPAT_VERSION) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: incompatible batman version (%i)\n",
- 			batman_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. */
- 
- 	switch (batman_ogm_packet->header.packet_type) {
- 		/* batman originator packet */
- 	case BAT_OGM:
- 		ret = recv_bat_ogm_packet(skb, hard_iface);
- 		break;
- 
- 		/* batman icmp packet */
- 	case BAT_ICMP:
- 		ret = recv_icmp_packet(skb, hard_iface);
- 		break;
- 
- 		/* unicast packet */
- 	case BAT_UNICAST:
- 		ret = recv_unicast_packet(skb, hard_iface);
- 		break;
- 
- 		/* fragmented unicast packet */
- 	case BAT_UNICAST_FRAG:
- 		ret = recv_ucast_frag_packet(skb, hard_iface);
- 		break;
- 
- 		/* broadcast packet */
- 	case BAT_BCAST:
- 		ret = recv_bcast_packet(skb, hard_iface);
- 		break;
- 
- 		/* vis packet */
- 	case BAT_VIS:
- 		ret = recv_vis_packet(skb, hard_iface);
- 		break;
- 		/* Translation table query (request or response) */
- 	case BAT_TT_QUERY:
- 		ret = recv_tt_query(skb, hard_iface);
- 		break;
- 		/* Roaming advertisement */
- 	case BAT_ROAM_ADV:
- 		ret = recv_roam_adv(skb, hard_iface);
- 		break;
- 	default:
- 		ret = NET_RX_DROP;
- 	}
- 
- 	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;
- }
- 
  /* This function returns true if the interface represented by ifindex is a
   * 802.11 wireless device */
  bool is_wifi_iface(int ifindex)
diff --combined net/batman-adv/icmp_socket.c
index b87518e,2e98a57..2e98a57
--- a/net/batman-adv/icmp_socket.c
+++ b/net/batman-adv/icmp_socket.c
@@@ -175,13 -175,13 +175,13 @@@ static ssize_t bat_socket_write(struct 
    if (len >= sizeof(struct icmp_packet_rr))
    	packet_len = sizeof(struct icmp_packet_rr);
- 	skb = dev_alloc_skb(packet_len + sizeof(struct ethhdr));
+ 	skb = dev_alloc_skb(packet_len + ETH_HLEN);
    if (!skb) {
    	len = -ENOMEM;
    	goto out;
    }
- 	skb_reserve(skb, sizeof(struct ethhdr));
+ 	skb_reserve(skb, ETH_HLEN);
    icmp_packet = (struct icmp_packet_rr *)skb_put(skb, packet_len);
if (copy_from_user(icmp_packet, buff, packet_len)) {
diff --combined net/batman-adv/main.c
index 6d51caa,0757c2d..0757c2d
--- a/net/batman-adv/main.c
+++ b/net/batman-adv/main.c
@@@ -30,6 -30,7 +30,7 @@@
  #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"
@@@ -38,6 -39,7 +39,7 @@@
  /* List manipulations on hardif_list have to be rtnl_lock()'ed,
   * list traversals just rcu-locked */
  struct list_head hardif_list;
+ static int (*recv_packet_handler[256])(struct sk_buff *, struct hard_iface *);
  char bat_routing_algo[20] = "BATMAN IV";
  static struct hlist_head bat_algo_list;
@@@ -45,11 -47,15 +47,15 @@@ unsigned char broadcast_addr[] = {0xff
struct workqueue_struct *bat_event_workqueue;
+ static void recv_handler_init(void);
+ 
  static int __init batman_init(void)
  {
    INIT_LIST_HEAD(&hardif_list);
    INIT_HLIST_HEAD(&bat_algo_list);
+ 	recv_handler_init();
+ 
    bat_iv_init();
/* the name should not be longer than 10 chars - see
@@@ -96,13 -102,10 +102,10 @@@ int mesh_init(struct net_device *soft_i
    spin_lock_init(&bat_priv->gw_list_lock);
    spin_lock_init(&bat_priv->vis_hash_lock);
    spin_lock_init(&bat_priv->vis_list_lock);
- 	spin_lock_init(&bat_priv->softif_neigh_lock);
- 	spin_lock_init(&bat_priv->softif_neigh_vid_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_HLIST_HEAD(&bat_priv->softif_neigh_vids);
    INIT_LIST_HEAD(&bat_priv->tt_changes_list);
    INIT_LIST_HEAD(&bat_priv->tt_req_list);
    INIT_LIST_HEAD(&bat_priv->tt_roam_list);
@@@ -118,6 -121,9 +121,9 @@@
    if (vis_init(bat_priv) < 1)
    	goto err;
+ 	if (bla_init(bat_priv) < 1)
+ 		goto err;
+ 
    atomic_set(&bat_priv->gw_reselect, 0);
    atomic_set(&bat_priv->mesh_state, MESH_ACTIVE);
    goto end;
@@@ -145,7 -151,7 +151,7 @@@ void mesh_free(struct net_device *soft_
tt_free(bat_priv);
- 	softif_neigh_purge(bat_priv);
+ 	bla_free(bat_priv);
atomic_set(&bat_priv->mesh_state, MESH_INACTIVE);
  }
@@@ -178,6 -184,119 +184,119 @@@ int is_my_mac(const uint8_t *addr
    return 0;
  }
+ static int recv_unhandled_packet(struct sk_buff *skb,
+ 				 struct hard_iface *recv_if)
+ {
+ 	return NET_RX_DROP;
+ }
+ 
+ /* incoming packets with the batman ethertype received on any active hard
+  * interface */
+ int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
+ 		    struct packet_type *ptype, struct net_device *orig_dev)
+ {
+ 	struct bat_priv *bat_priv;
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	struct hard_iface *hard_iface;
+ 	uint8_t idx;
+ 	int ret;
+ 
+ 	hard_iface = container_of(ptype, struct 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) != MESH_ACTIVE)
+ 		goto err_free;
+ 
+ 	/* discard frames on not active interfaces */
+ 	if (hard_iface->if_status != IF_ACTIVE)
+ 		goto err_free;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)skb->data;
+ 
+ 	if (batman_ogm_packet->header.version != COMPAT_VERSION) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: incompatible batman version (%i)\n",
+ 			batman_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 = batman_ogm_packet->header.packet_type;
+ 	ret = (*recv_packet_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 recv_handler_init(void)
+ {
+ 	int i;
+ 
+ 	for (i = 0; i < ARRAY_SIZE(recv_packet_handler); i++)
+ 		recv_packet_handler[i] = recv_unhandled_packet;
+ 
+ 	/* batman icmp packet */
+ 	recv_packet_handler[BAT_ICMP] = recv_icmp_packet;
+ 	/* unicast with 4 addresses packet */
+ 	recv_packet_handler[BAT_UNICAST_4ADDR] = recv_unicast_packet;
+ 	/* unicast packet */
+ 	recv_packet_handler[BAT_UNICAST] = recv_unicast_packet;
+ 	/* fragmented unicast packet */
+ 	recv_packet_handler[BAT_UNICAST_FRAG] = recv_ucast_frag_packet;
+ 	/* broadcast packet */
+ 	recv_packet_handler[BAT_BCAST] = recv_bcast_packet;
+ 	/* vis packet */
+ 	recv_packet_handler[BAT_VIS] = recv_vis_packet;
+ 	/* Translation table query (request or response) */
+ 	recv_packet_handler[BAT_TT_QUERY] = recv_tt_query;
+ 	/* Roaming advertisement */
+ 	recv_packet_handler[BAT_ROAM_ADV] = recv_roam_adv;
+ }
+ 
+ int recv_handler_register(uint8_t packet_type,
+ 			  int (*recv_handler)(struct sk_buff *,
+ 					      struct hard_iface *))
+ {
+ 	if (recv_packet_handler[packet_type] != &recv_unhandled_packet)
+ 		return -EBUSY;
+ 
+ 	recv_packet_handler[packet_type] = recv_handler;
+ 	return 0;
+ }
+ 
+ void recv_handler_unregister(uint8_t packet_type)
+ {
+ 	recv_packet_handler[packet_type] = recv_unhandled_packet;
+ }
+ 
  static struct bat_algo_ops *bat_algo_get(char *name)
  {
    struct bat_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
@@@ -207,12 -326,12 +326,12 @@@ int bat_algo_register(struct bat_algo_o
    }
/* all algorithms must implement all ops (for now) */
- 	if (!bat_algo_ops->bat_ogm_init ||
- 	    !bat_algo_ops->bat_ogm_init_primary ||
- 	    !bat_algo_ops->bat_ogm_update_mac ||
+ 	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 ||
- 	    !bat_algo_ops->bat_ogm_receive) {
+ 	    !bat_algo_ops->bat_ogm_emit) {
    	pr_info("Routing algo '%s' does not implement required ops\n",
    		bat_algo_ops->name);
    	goto out;
diff --combined net/batman-adv/main.h
index 94fa1c2,0000000..14ff75a
mode 100644,000000..100644
--- a/net/batman-adv/main.h
+++ b/net/batman-adv/main.h
@@@ -1,234 -1,0 +1,260 @@@
 +/*
 + * 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 DRIVER_AUTHOR "Marek Lindner lindner_marek@yahoo.de, " \
 +		      "Simon Wunderlich siwu@hrz.tu-chemnitz.de"
 +#define DRIVER_DESC   "B.A.T.M.A.N. advanced"
 +#define DRIVER_DEVICE "batman-adv"
 +
 +#ifndef SOURCE_VERSION
- #define SOURCE_VERSION "2012.1.0"
++#define SOURCE_VERSION "2012.2.0"
 +#endif
 +
 +/* B.A.T.M.A.N. parameters */
 +
 +#define TQ_MAX_VALUE 255
 +#define JITTER 20
 +
 + /* Time To Live of broadcast messages */
 +#define TTL 50
 +
 +/* purge originators after time in seconds if no valid packet comes in
 + * -> TODO: check influence on TQ_LOCAL_WINDOW_SIZE */
 +#define PURGE_TIMEOUT 200000 /* 200 seconds */
 +#define TT_LOCAL_TIMEOUT 3600000 /* in miliseconds */
 +#define TT_CLIENT_ROAM_TIMEOUT 600000 /* in miliseconds */
 +/* sliding packet range of received originator messages in sequence numbers
 + * (should be a multiple of our word size) */
 +#define TQ_LOCAL_WINDOW_SIZE 64
 +#define TT_REQUEST_TIMEOUT 3000 /* miliseconds we have to keep
 +				 * pending tt_req */
 +
 +#define TQ_GLOBAL_WINDOW_SIZE 5
 +#define TQ_LOCAL_BIDRECT_SEND_MINIMUM 1
 +#define TQ_LOCAL_BIDRECT_RECV_MINIMUM 1
 +#define TQ_TOTAL_BIDRECT_LIMIT 1
 +
 +#define TT_OGM_APPEND_MAX 3 /* number of OGMs sent with the last tt diff */
 +
 +#define ROAMING_MAX_TIME 20000 /* Time in which a client can roam at most
 +				* ROAMING_MAX_COUNT times in miliseconds*/
 +#define ROAMING_MAX_COUNT 5
 +
 +#define NO_FLAGS 0
 +
 +#define NULL_IFINDEX 0 /* dummy ifindex used to avoid iface checks */
 +
- #define NUM_WORDS (TQ_LOCAL_WINDOW_SIZE / WORD_BIT_SIZE)
++#define NUM_WORDS BITS_TO_LONGS(TQ_LOCAL_WINDOW_SIZE)
++
++/* msecs after which an ARP_REQUEST is sent in broadcast as fallback */
++#define ARP_REQ_DELAY 250
++/* numbers of originator to contact for any PUT/GET DHT operation */
++#define DHT_CANDIDATES_NUM 3
++/* Factor which default ARP timeout values of the soft_iface table are
++ * multiplied by */
++#define ARP_TIMEOUT_FACTOR 4
 +
 +#define LOG_BUF_LEN 8192	  /* has to be a power of 2 */
 +
 +#define VIS_INTERVAL 5000	/* 5 seconds */
 +
 +/* how much worse secondary interfaces may be to be considered as bonding
 + * candidates */
 +#define BONDING_TQ_THRESHOLD	50
 +
 +/* should not be bigger than 512 bytes or change the size of
 + * forw_packet->direct_link_flags */
 +#define MAX_AGGREGATION_BYTES 512
 +#define MAX_AGGREGATION_MS 100
 +
- #define SOFTIF_NEIGH_TIMEOUT 180000 /* 3 minutes */
++#define BLA_PERIOD_LENGTH	10000	/* 10 seconds */
++#define BLA_BACKBONE_TIMEOUT	(BLA_PERIOD_LENGTH * 3)
++#define BLA_CLAIM_TIMEOUT	(BLA_PERIOD_LENGTH * 10)
 +
++#define DUPLIST_SIZE		16
++#define DUPLIST_TIMEOUT		500	/* 500 ms */
 +/* don't reset again within 30 seconds */
 +#define RESET_PROTECTION_MS 30000
 +#define EXPECTED_SEQNO_RANGE	65536
 +
 +enum mesh_state {
 +	MESH_INACTIVE,
 +	MESH_ACTIVE,
 +	MESH_DEACTIVATING
 +};
 +
 +#define BCAST_QUEUE_LEN		256
 +#define BATMAN_QUEUE_LEN	256
 +
 +enum uev_action {
 +	UEV_ADD = 0,
 +	UEV_DEL,
 +	UEV_CHANGE
 +};
 +
 +enum uev_type {
 +	UEV_GW = 0
 +};
 +
 +#define GW_THRESHOLD	50
 +
++#define DHT_CANDIDATE_NOT_FOUND	0
++#define DHT_CANDIDATE_ORIG	1
++
 +/* Debug Messages */
 +#ifdef pr_fmt
 +#undef pr_fmt
 +#endif
 +/* Append 'batman-adv: ' before kernel messages */
 +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 +
 +/* all messages related to routing / flooding / broadcasting / etc */
 +enum dbg_level {
 +	DBG_BATMAN = 1 << 0,
 +	DBG_ROUTES = 1 << 1, /* route added / changed / deleted */
 +	DBG_TT	   = 1 << 2, /* translation table operations */
- 	DBG_ALL    = 7
++	DBG_BLA    = 1 << 3, /* bridge loop avoidance */
++	DBG_DAT    = 1 << 4, /* snooped arp messages / dat operations */
++	DBG_ALL    = 31
 +};
 +
 +/* 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/slab.h>
 +#include <net/sock.h>		/* struct sock */
 +#include <linux/jiffies.h>
 +#include <linux/seq_file.h>
 +#include "types.h"
 +
 +extern char bat_routing_algo[];
 +extern struct list_head hardif_list;
 +
 +extern unsigned char broadcast_addr[];
 +extern struct workqueue_struct *bat_event_workqueue;
 +
 +int mesh_init(struct net_device *soft_iface);
 +void mesh_free(struct net_device *soft_iface);
 +void inc_module_count(void);
 +void dec_module_count(void);
 +int is_my_mac(const uint8_t *addr);
++int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
++		    struct packet_type *ptype, struct net_device *orig_dev);
++int recv_handler_register(uint8_t packet_type,
++			  int (*recv_handler)(struct sk_buff *,
++					      struct hard_iface *));
++void recv_handler_unregister(uint8_t packet_type);
 +int bat_algo_register(struct bat_algo_ops *bat_algo_ops);
 +int bat_algo_select(struct bat_priv *bat_priv, char *name);
 +int bat_algo_seq_print_text(struct seq_file *seq, void *offset);
 +
 +#ifdef CONFIG_BATMAN_ADV_DEBUG
 +int debug_log(struct bat_priv *bat_priv, const char *fmt, ...) __printf(2, 3);
 +
 +#define bat_dbg(type, bat_priv, fmt, arg...)			\
 +	do {							\
 +		if (atomic_read(&bat_priv->log_level) & type)	\
 +			debug_log(bat_priv, fmt, ## arg);	\
 +	}							\
 +	while (0)
 +#else /* !CONFIG_BATMAN_ADV_DEBUG */
 +__printf(3, 4)
 +static inline void bat_dbg(int type __always_unused,
 +			   struct bat_priv *bat_priv __always_unused,
 +			   const char *fmt __always_unused, ...)
 +{
 +}
 +#endif
 +
 +#define bat_info(net_dev, fmt, arg...)					\
 +	do {								\
 +		struct net_device *_netdev = (net_dev);                 \
 +		struct bat_priv *_batpriv = netdev_priv(_netdev);       \
 +		bat_dbg(DBG_ALL, _batpriv, fmt, ## arg);		\
 +		pr_info("%s: " fmt, _netdev->name, ## arg);		\
 +	} while (0)
 +#define bat_err(net_dev, fmt, arg...)					\
 +	do {								\
 +		struct net_device *_netdev = (net_dev);                 \
 +		struct bat_priv *_batpriv = netdev_priv(_netdev);       \
 +		bat_dbg(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 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 has_timed_out(unsigned long timestamp, unsigned int timeout)
 +{
 +	return time_is_before_jiffies(timestamp + msecs_to_jiffies(timeout));
 +}
 +
 +#define 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 smallest_signed_int(x) (1u << (7u + 8u * (sizeof(x) - 1u)))
 +
++/* Returns the biggest unsigned integer with the sizeof x */
++#define biggest_unsigned_int(x) (~(x)0)
++
 +/* 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 seq_before(x, y) ({typeof(x) _d1 = (x); \
 +			  typeof(y) _d2 = (y); \
 +			  typeof(x) _dummy = (_d1 - _d2); \
 +			  (void) (&_d1 == &_d2); \
 +			  _dummy > smallest_signed_int(_dummy); })
 +#define seq_after(x, y) seq_before(y, x)
 +
 +#endif /* _NET_BATMAN_ADV_MAIN_H_ */
diff --combined net/batman-adv/originator.c
index 43c0a4f,30889c9..30889c9
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@@ -20,6 -20,7 +20,7 @@@
   */
#include "main.h"
+ #include "distributed-arp-table.h"
  #include "originator.h"
  #include "hash.h"
  #include "translation-table.h"
@@@ -28,13 -29,15 +29,15 @@@
  #include "hard-interface.h"
  #include "unicast.h"
  #include "soft-interface.h"
+ #include "bridge_loop_avoidance.h"
static void purge_orig(struct work_struct *work);
static void start_purge_timer(struct bat_priv *bat_priv)
  {
    INIT_DELAYED_WORK(&bat_priv->orig_work, purge_orig);
- 	queue_delayed_work(bat_event_workqueue, &bat_priv->orig_work, 1 * HZ);
+ 	queue_delayed_work(bat_event_workqueue,
+ 			   &bat_priv->orig_work, msecs_to_jiffies(1000));
  }
/* returns 1 if they are the same originator */
@@@ -83,35 -86,29 +86,29 @@@ struct neigh_node *orig_node_get_router
    return router;
  }
- struct neigh_node *create_neighbor(struct orig_node *orig_node,
- 				   struct orig_node *orig_neigh_node,
- 				   const uint8_t *neigh,
- 				   struct hard_iface *if_incoming)
+ struct neigh_node *neigh_node_new(struct hard_iface *hard_iface,
+ 				  const uint8_t *neigh_addr, uint32_t seqno)
  {
- 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
+ 	struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
    struct neigh_node *neigh_node;
- 	bat_dbg(DBG_BATMAN, bat_priv,
- 		"Creating new last-hop neighbor of originator\n");
- 
    neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
    if (!neigh_node)
- 		return NULL;
+ 		goto out;
INIT_HLIST_NODE(&neigh_node->list);
- 	INIT_LIST_HEAD(&neigh_node->bonding_list);
- 	spin_lock_init(&neigh_node->tq_lock);
- 	memcpy(neigh_node->addr, neigh, ETH_ALEN);
- 	neigh_node->orig_node = orig_neigh_node;
- 	neigh_node->if_incoming = if_incoming;
+ 	memcpy(neigh_node->addr, neigh_addr, ETH_ALEN);
+ 	spin_lock_init(&neigh_node->lq_update_lock);
/* extra reference for return */
    atomic_set(&neigh_node->refcount, 2);
- 	spin_lock_bh(&orig_node->neigh_list_lock);
- 	hlist_add_head_rcu(&neigh_node->list, &orig_node->neigh_list);
- 	spin_unlock_bh(&orig_node->neigh_list_lock);
+ 	bat_dbg(DBG_BATMAN, bat_priv,
+ 		"Creating new neighbor %pM, initial seqno %d\n",
+ 		neigh_addr, seqno);
+ 
+ out:
    return neigh_node;
  }
@@@ -223,6 -220,7 +220,7 @@@ struct orig_node *get_orig_node(struct 
    orig_node->tt_poss_change = false;
    orig_node->bat_priv = bat_priv;
    memcpy(orig_node->orig, addr, ETH_ALEN);
+ 	dat_init_orig_node_dht_addr(orig_node);
    orig_node->router = NULL;
    orig_node->tt_crc = 0;
    atomic_set(&orig_node->last_ttvn, 0);
@@@ -273,6 -271,7 +271,7 @@@ static bool purge_orig_neighbors(struc
    struct hlist_node *node, *node_tmp;
    struct neigh_node *neigh_node;
    bool neigh_purged = false;
+ 	unsigned long last_seen;
*best_neigh_node = NULL;
@@@ -282,11 -281,13 +281,13 @@@
    hlist_for_each_entry_safe(neigh_node, node, node_tmp,
    			  &orig_node->neigh_list, list) {
- 		if ((has_timed_out(neigh_node->last_valid, PURGE_TIMEOUT)) ||
+ 		if ((has_timed_out(neigh_node->last_seen, PURGE_TIMEOUT)) ||
    	    (neigh_node->if_incoming->if_status == IF_INACTIVE) ||
    	    (neigh_node->if_incoming->if_status == IF_NOT_IN_USE) ||
    	    (neigh_node->if_incoming->if_status == IF_TO_BE_REMOVED)) {
+ 			last_seen = neigh_node->last_seen;
+ 
    		if ((neigh_node->if_incoming->if_status ==
    							IF_INACTIVE) ||
    		    (neigh_node->if_incoming->if_status ==
@@@ -299,9 -300,9 +300,9 @@@
    				neigh_node->if_incoming->net_dev->name);
    		else
    			bat_dbg(DBG_BATMAN, bat_priv,
- 					"neighbor timeout: originator %pM, neighbor: %pM, last_valid: %lu\n",
+ 					"neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n",
    				orig_node->orig, neigh_node->addr,
- 					(neigh_node->last_valid / HZ));
+ 					jiffies_to_msecs(last_seen));
neigh_purged = true;
@@@ -324,10 -325,11 +325,11 @@@ static bool purge_orig_node(struct bat_
  {
    struct neigh_node *best_neigh_node;
- 	if (has_timed_out(orig_node->last_valid, 2 * PURGE_TIMEOUT)) {
+ 	if (has_timed_out(orig_node->last_seen, 2 * PURGE_TIMEOUT)) {
    	bat_dbg(DBG_BATMAN, bat_priv,
- 			"Originator timeout: originator %pM, last_valid %lu\n",
- 			orig_node->orig, (orig_node->last_valid / HZ));
+ 			"Originator timeout: originator %pM, last_seen %u\n",
+ 			orig_node->orig,
+ 			jiffies_to_msecs(orig_node->last_seen));
    	return true;
    } else {
    	if (purge_orig_neighbors(bat_priv, orig_node,
@@@ -375,8 -377,6 +377,6 @@@ static void _purge_orig(struct bat_pri
gw_node_purge(bat_priv);
    gw_election(bat_priv);
- 
- 	softif_neigh_purge(bat_priv);
  }
static void purge_orig(struct work_struct *work)
@@@ -447,9 -447,9 +447,9 @@@ int orig_seq_print_text(struct seq_fil
    			goto next;
last_seen_secs = jiffies_to_msecs(jiffies -
- 						orig_node->last_valid) / 1000;
+ 						orig_node->last_seen) / 1000;
    		last_seen_msecs = jiffies_to_msecs(jiffies -
- 						orig_node->last_valid) % 1000;
+ 						orig_node->last_seen) % 1000;
seq_printf(seq, "%pM %4i.%03is   (%3i) %pM [%10s]:",
    			   orig_node->orig, last_seen_secs,
diff --combined net/batman-adv/originator.h
index 3fe2eda,64c5d94..64c5d94
--- a/net/batman-adv/originator.h
+++ b/net/batman-adv/originator.h
@@@ -29,10 -29,8 +29,8 @@@ void originator_free(struct bat_priv *b
  void purge_orig_ref(struct bat_priv *bat_priv);
  void orig_node_free_ref(struct orig_node *orig_node);
  struct orig_node *get_orig_node(struct bat_priv *bat_priv, const uint8_t *addr);
- struct neigh_node *create_neighbor(struct orig_node *orig_node,
- 				   struct orig_node *orig_neigh_node,
- 				   const uint8_t *neigh,
- 				   struct hard_iface *if_incoming);
+ struct neigh_node *neigh_node_new(struct hard_iface *hard_iface,
+ 				  const uint8_t *neigh_addr, uint32_t seqno);
  void neigh_node_free_ref(struct neigh_node *neigh_node);
  struct neigh_node *orig_node_get_router(struct orig_node *orig_node);
  int orig_seq_print_text(struct seq_file *seq, void *offset);
diff --combined net/batman-adv/packet.h
index 441f3db,3c4c533..3c4c533
--- a/net/batman-adv/packet.h
+++ b/net/batman-adv/packet.h
@@@ -25,20 -25,29 +25,29 @@@
  #define ETH_P_BATMAN  0x4305	/* unofficial/not registered Ethertype */
enum bat_packettype {
- 	BAT_OGM		 = 0x01,
- 	BAT_ICMP	 = 0x02,
- 	BAT_UNICAST	 = 0x03,
- 	BAT_BCAST	 = 0x04,
- 	BAT_VIS		 = 0x05,
- 	BAT_UNICAST_FRAG = 0x06,
- 	BAT_TT_QUERY	 = 0x07,
- 	BAT_ROAM_ADV	 = 0x08
+ 	BAT_IV_OGM		= 0x01,
+ 	BAT_ICMP		= 0x02,
+ 	BAT_UNICAST		= 0x03,
+ 	BAT_BCAST		= 0x04,
+ 	BAT_VIS			= 0x05,
+ 	BAT_UNICAST_FRAG	= 0x06,
+ 	BAT_TT_QUERY		= 0x07,
+ 	BAT_ROAM_ADV		= 0x08,
+ 	BAT_UNICAST_4ADDR	= 0x09
+ };
+ 
+ enum bat_subtype {
+ 	BAT_P_DATA		= 0x01,
+ 	BAT_P_DAT_DHT_GET	= 0x02,
+ 	BAT_P_DAT_DHT_PUT	= 0x03,
+ 	BAT_P_DAT_CACHE_REPLY	= 0x04
  };
/* this file is included by batctl which needs these defines */
  #define COMPAT_VERSION 14
- enum batman_flags {
+ enum batman_iv_flags {
+ 	NOT_BEST_NEXT_HOP   = 1 << 3,
    PRIMARIES_FIRST_HOP = 1 << 4,
    VIS_SERVER	    = 1 << 5,
    DIRECTLINK	    = 1 << 6
@@@ -90,6 -99,22 +99,22 @@@ enum tt_client_flags 
    TT_CLIENT_PENDING = 1 << 10
  };
+ /* claim frame types for the bridge loop avoidance */
+ enum bla_claimframe {
+ 	CLAIM_TYPE_ADD		= 0x00,
+ 	CLAIM_TYPE_DEL		= 0x01,
+ 	CLAIM_TYPE_ANNOUNCE	= 0x02,
+ 	CLAIM_TYPE_REQUEST	= 0x03
+ };
+ 
+ /* the destination hardware field in the ARP frame is used to
+  * transport the claim type and the group id */
+ struct bla_claim_dst {
+ 	uint8_t magic[3];	/* FF:43:05 */
+ 	uint8_t type;		/* bla_claimframe */
+ 	uint16_t group;		/* group id */
+ } __packed;
+ 
  struct batman_header {
    uint8_t  packet_type;
    uint8_t  version;  /* batman version field */
@@@ -100,8 -125,8 +125,8 @@@ struct batman_ogm_packet 
    struct batman_header header;
    uint8_t  flags;    /* 0x40: DIRECTLINK flag, 0x20 VIS_SERVER flag... */
    uint32_t seqno;
- 	uint8_t  orig[6];
- 	uint8_t  prev_sender[6];
+ 	uint8_t  orig[ETH_ALEN];
+ 	uint8_t  prev_sender[ETH_ALEN];
    uint8_t  gw_flags;  /* flags related to gateway class */
    uint8_t  tq;
    uint8_t  tt_num_changes;
@@@ -109,13 -134,13 +134,13 @@@
    uint16_t tt_crc;
  } __packed;
- #define BATMAN_OGM_LEN sizeof(struct batman_ogm_packet)
+ #define BATMAN_OGM_HLEN sizeof(struct batman_ogm_packet)
struct icmp_packet {
    struct batman_header header;
    uint8_t  msg_type; /* see ICMP message types above */
- 	uint8_t  dst[6];
- 	uint8_t  orig[6];
+ 	uint8_t  dst[ETH_ALEN];
+ 	uint8_t  orig[ETH_ALEN];
    uint16_t seqno;
    uint8_t  uid;
    uint8_t  reserved;
@@@ -128,8 -153,8 +153,8 @@@
  struct icmp_packet_rr {
    struct batman_header header;
    uint8_t  msg_type; /* see ICMP message types above */
- 	uint8_t  dst[6];
- 	uint8_t  orig[6];
+ 	uint8_t  dst[ETH_ALEN];
+ 	uint8_t  orig[ETH_ALEN];
    uint16_t seqno;
    uint8_t  uid;
    uint8_t  rr_cur;
@@@ -139,16 -164,22 +164,22 @@@
  struct unicast_packet {
    struct batman_header header;
    uint8_t  ttvn; /* destination translation table version number */
- 	uint8_t  dest[6];
+ 	uint8_t  dest[ETH_ALEN];
+ } __packed;
+ 
+ struct unicast_4addr_packet {
+ 	struct unicast_packet u;
+ 	uint8_t src[ETH_ALEN];
+ 	uint8_t subtype;
  } __packed;
struct unicast_frag_packet {
    struct batman_header header;
    uint8_t  ttvn; /* destination translation table version number */
- 	uint8_t  dest[6];
+ 	uint8_t  dest[ETH_ALEN];
    uint8_t  flags;
    uint8_t  align;
- 	uint8_t  orig[6];
+ 	uint8_t  orig[ETH_ALEN];
    uint16_t seqno;
  } __packed;
@@@ -156,7 -187,7 +187,7 @@@ struct bcast_packet 
    struct batman_header header;
    uint8_t  reserved;
    uint32_t seqno;
- 	uint8_t  orig[6];
+ 	uint8_t  orig[ETH_ALEN];
  } __packed;
struct vis_packet {
@@@ -165,9 -196,9 +196,9 @@@
    uint32_t seqno;		 /* sequence number */
    uint8_t  entries;	 /* number of entries behind this struct */
    uint8_t  reserved;
- 	uint8_t  vis_orig[6];	 /* originator that announces its neighbors */
- 	uint8_t  target_orig[6]; /* who should receive this packet */
- 	uint8_t  sender_orig[6]; /* who sent or rebroadcasted this packet */
+ 	uint8_t  vis_orig[ETH_ALEN];	/* originator reporting its neighbors */
+ 	uint8_t  target_orig[ETH_ALEN]; /* who should receive this packet */
+ 	uint8_t  sender_orig[ETH_ALEN]; /* who sent or forwarded this packet */
  } __packed;
struct tt_query_packet {
diff --combined net/batman-adv/routing.c
index 7f8e158,795d3af..795d3af
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@@ -29,6 -29,10 +29,10 @@@
  #include "originator.h"
  #include "vis.h"
  #include "unicast.h"
+ #include "bridge_loop_avoidance.h"
+ 
+ static int route_unicast_packet(struct sk_buff *skb,
+ 				struct hard_iface *recv_if);
void slide_own_bcast_window(struct hard_iface *hard_iface)
  {
@@@ -52,7 -56,7 +56,7 @@@
bit_get_packet(bat_priv, word, 1, 0);
    		orig_node->bcast_own_sum[hard_iface->if_num] =
- 				bit_packet_count(word);
+ 				bitmap_weight(word, TQ_LOCAL_WINDOW_SIZE);
    		spin_unlock_bh(&orig_node->ogm_cnt_lock);
    	}
    	rcu_read_unlock();
@@@ -230,51 -234,46 +234,46 @@@ int window_protected(struct bat_priv *b
  {
    if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE) ||
        (seq_num_diff >= EXPECTED_SEQNO_RANGE)) {
- 		if (has_timed_out(*last_reset, RESET_PROTECTION_MS)) {
- 
- 			*last_reset = jiffies;
- 			bat_dbg(DBG_BATMAN, bat_priv,
- 				"old packet received, start protection\n");
- 
- 			return 0;
- 		} else {
+ 		if (!has_timed_out(*last_reset, RESET_PROTECTION_MS))
    		return 1;
- 		}
+ 
+ 		*last_reset = jiffies;
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"old packet received, start protection\n");
    }
+ 
    return 0;
  }
- int recv_bat_ogm_packet(struct sk_buff *skb, struct hard_iface *hard_iface)
+ bool check_management_packet(struct sk_buff *skb,
+ 			     struct hard_iface *hard_iface,
+ 			     int header_len)
  {
    struct ethhdr *ethhdr;
/* drop packet if it has not necessary minimum size */
- 	if (unlikely(!pskb_may_pull(skb, BATMAN_OGM_LEN)))
- 		return NET_RX_DROP;
+ 	if (unlikely(!pskb_may_pull(skb, header_len)))
+ 		return false;
ethhdr = (struct ethhdr *)skb_mac_header(skb);
/* packet with broadcast indication but unicast recipient */
    if (!is_broadcast_ether_addr(ethhdr->h_dest))
- 		return NET_RX_DROP;
+ 		return false;
/* packet with broadcast sender address */
    if (is_broadcast_ether_addr(ethhdr->h_source))
- 		return NET_RX_DROP;
+ 		return false;
/* create a copy of the skb, if needed, to modify it. */
    if (skb_cow(skb, 0) < 0)
- 		return NET_RX_DROP;
+ 		return false;
/* keep skb linear */
    if (skb_linearize(skb) < 0)
- 		return NET_RX_DROP;
- 
- 	bat_priv->bat_algo_ops->bat_ogm_receive(hard_iface, skb);
+ 		return false;
- 	kfree_skb(skb);
- 	return NET_RX_SUCCESS;
+ 	return true;
  }
static int recv_my_icmp_packet(struct bat_priv *bat_priv,
@@@ -309,7 -308,7 +308,7 @@@
    	goto out;
/* create a copy of the skb, if needed, to modify it. */
- 	if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
+ 	if (skb_cow(skb, ETH_HLEN) < 0)
    	goto out;
icmp_packet = (struct icmp_packet_rr *)skb->data;
@@@ -364,7 -363,7 +363,7 @@@ static int recv_icmp_ttl_exceeded(struc
    	goto out;
/* create a copy of the skb, if needed, to modify it. */
- 	if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
+ 	if (skb_cow(skb, ETH_HLEN) < 0)
    	goto out;
icmp_packet = (struct icmp_packet *)skb->data;
@@@ -450,7 -449,7 +449,7 @@@ int recv_icmp_packet(struct sk_buff *sk
    	goto out;
/* create a copy of the skb, if needed, to modify it. */
- 	if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
+ 	if (skb_cow(skb, ETH_HLEN) < 0)
    	goto out;
icmp_packet = (struct icmp_packet_rr *)skb->data;
@@@ -669,6 -668,12 +668,12 @@@ int recv_roam_adv(struct sk_buff *skb, 
    if (!is_my_mac(roam_adv_packet->dst))
    	return route_unicast_packet(skb, recv_if);
+ 	/* check if it is a backbone gateway. we don't accept
+ 	 * roaming advertisement from it, as it has the same
+ 	 * entries as we have. */
+ 	if (bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src))
+ 		goto out;
+ 
    orig_node = orig_hash_find(bat_priv, roam_adv_packet->src);
    if (!orig_node)
    	goto out;
@@@ -798,7 -803,7 +803,7 @@@ static int check_unicast_packet(struct 
    return 0;
  }
- int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
+ static int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
  {
    struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
    struct orig_node *orig_node = NULL;
@@@ -830,7 -835,7 +835,7 @@@
    	goto out;
/* create a copy of the skb, if needed, to modify it. */
- 	if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
+ 	if (skb_cow(skb, ETH_HLEN) < 0)
    	goto out;
unicast_packet = (struct unicast_packet *)skb->data;
@@@ -907,12 -912,19 +912,19 @@@ static int check_unicast_ttvn(struct ba
/* Check whether I have to reroute the packet */
    if (seq_before(unicast_packet->ttvn, curr_ttvn) || tt_poss_change) {
- 		/* Linearize the skb before accessing it */
- 		if (skb_linearize(skb) < 0)
+ 		/* check if there is enough data before accessing it */
+ 		if (pskb_may_pull(skb, sizeof(struct unicast_packet) +
+ 				  ETH_HLEN) < 0)
    		return 0;
ethhdr = (struct ethhdr *)(skb->data +
    		sizeof(struct unicast_packet));
+ 
+ 		/* we don't have an updated route for this client, so we should
+ 		 * not try to reroute the packet!! */
+ 		if (tt_global_client_is_roaming(bat_priv, ethhdr->h_dest))
+ 			return 1;
+ 
    	orig_node = transtable_search(bat_priv, NULL, ethhdr->h_dest);
if (!orig_node) {
@@@ -948,14 -960,18 +960,18 @@@ int recv_unicast_packet(struct sk_buff 
    struct unicast_packet *unicast_packet;
    int hdr_size = sizeof(*unicast_packet);
+ 	unicast_packet = (struct unicast_packet *)skb->data;
+ 
+ 	/* the caller function should have already pulled 2 bytes */
+ 	if (unicast_packet->header.packet_type == BAT_UNICAST_4ADDR)
+ 		hdr_size = sizeof(struct unicast_4addr_packet);
+ 
    if (check_unicast_packet(skb, hdr_size) < 0)
    	return NET_RX_DROP;
if (!check_unicast_ttvn(bat_priv, skb))
    	return NET_RX_DROP;
- 	unicast_packet = (struct unicast_packet *)skb->data;
- 
    /* packet for me */
    if (is_my_mac(unicast_packet->dest)) {
    	interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size);
@@@ -1047,8 -1063,8 +1063,8 @@@ int recv_bcast_packet(struct sk_buff *s
    spin_lock_bh(&orig_node->bcast_seqno_lock);
/* check whether the packet is a duplicate */
- 	if (get_bit_status(orig_node->bcast_bits, orig_node->last_bcast_seqno,
- 			   ntohl(bcast_packet->seqno)))
+ 	if (bat_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
+ 			 ntohl(bcast_packet->seqno)))
    	goto spin_unlock;
seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
@@@ -1065,9 -1081,18 +1081,18 @@@
spin_unlock_bh(&orig_node->bcast_seqno_lock);
+ 	/* check whether this has been sent by another originator before */
+ 	if (bla_check_bcast_duplist(bat_priv, bcast_packet, hdr_size))
+ 		goto out;
+ 
    /* rebroadcast packet */
    add_bcast_packet_to_list(bat_priv, skb, 1);
+ 	/* don't hand the broadcast up if it is from an originator
+ 	 * from the same backbone. */
+ 	if (bla_is_backbone_gw(skb, orig_node, hdr_size))
+ 		goto out;
+ 
    /* broadcast for me */
    interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size);
    ret = NET_RX_SUCCESS;
diff --combined net/batman-adv/routing.h
index 92ac100,d6bbbeb..d6bbbeb
--- a/net/batman-adv/routing.h
+++ b/net/batman-adv/routing.h
@@@ -23,15 -23,16 +23,16 @@@
  #define _NET_BATMAN_ADV_ROUTING_H_
void slide_own_bcast_window(struct hard_iface *hard_iface);
+ bool check_management_packet(struct sk_buff *skb,
+ 			     struct hard_iface *hard_iface,
+ 			     int header_len);
  void update_route(struct bat_priv *bat_priv, struct orig_node *orig_node,
    	  struct neigh_node *neigh_node);
- int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if);
- int recv_bat_ogm_packet(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if);
  int recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if);
  struct neigh_node *find_router(struct bat_priv *bat_priv,
diff --combined net/batman-adv/send.c
index af7a674,815cc9c..815cc9c
--- a/net/batman-adv/send.c
+++ b/net/batman-adv/send.c
@@@ -20,6 -20,7 +20,7 @@@
   */
#include "main.h"
+ #include "distributed-arp-table.h"
  #include "send.h"
  #include "routing.h"
  #include "translation-table.h"
@@@ -45,13 -46,13 +46,13 @@@ int send_skb_packet(struct sk_buff *skb
    	goto send_skb_err;
if (!(hard_iface->net_dev->flags & IFF_UP)) {
- 		pr_warning("Interface %s is not up - can't send packet via that interface!\n",
- 			   hard_iface->net_dev->name);
+ 		pr_warn("Interface %s is not up - can't send packet via that interface!\n",
+ 			hard_iface->net_dev->name);
    	goto send_skb_err;
    }
/* push to the ethernet header. */
- 	if (my_skb_head_push(skb, sizeof(*ethhdr)) < 0)
+ 	if (my_skb_head_push(skb, ETH_HLEN) < 0)
    	goto send_skb_err;
skb_reset_mac_header(skb);
@@@ -87,7 -88,7 +88,7 @@@ static void realloc_packet_buffer(struc
    /* keep old buffer if kmalloc should fail */
    if (new_buff) {
    	memcpy(new_buff, hard_iface->packet_buff,
- 		       BATMAN_OGM_LEN);
+ 		       BATMAN_OGM_HLEN);
kfree(hard_iface->packet_buff);
    	hard_iface->packet_buff = new_buff;
@@@ -101,13 -102,13 +102,13 @@@ static int prepare_packet_buffer(struc
  {
    int new_len;
- 	new_len = BATMAN_OGM_LEN +
+ 	new_len = BATMAN_OGM_HLEN +
    	  tt_len((uint8_t)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 (new_len > hard_iface->soft_iface->mtu)
- 		new_len = BATMAN_OGM_LEN;
+ 		new_len = BATMAN_OGM_HLEN;
realloc_packet_buffer(hard_iface, new_len);
@@@ -117,14 -118,14 +118,14 @@@
    atomic_set(&bat_priv->tt_ogm_append_cnt, TT_OGM_APPEND_MAX);
return tt_changes_fill_buffer(bat_priv,
- 				      hard_iface->packet_buff + BATMAN_OGM_LEN,
- 				      hard_iface->packet_len - BATMAN_OGM_LEN);
+ 				      hard_iface->packet_buff + BATMAN_OGM_HLEN,
+ 				      hard_iface->packet_len - BATMAN_OGM_HLEN);
  }
static int reset_packet_buffer(struct bat_priv *bat_priv,
    			struct hard_iface *hard_iface)
  {
- 	realloc_packet_buffer(hard_iface, BATMAN_OGM_LEN);
+ 	realloc_packet_buffer(hard_iface, BATMAN_OGM_HLEN);
    return 0;
  }
@@@ -274,6 -275,9 +275,9 @@@ static void send_outstanding_bcast_pack
    if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING)
    	goto out;
+ 	if (dat_drop_broadcast_packet(bat_priv, forw_packet))
+ 		goto out;
+ 
    /* rebroadcast packet */
    rcu_read_lock();
    list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
@@@ -292,7 -296,7 +296,7 @@@
    /* if we still have some more bcasts to send */
    if (forw_packet->num_packets < 3) {
    	_add_bcast_packet_to_list(bat_priv, forw_packet,
- 					  ((5 * HZ) / 1000));
+ 					  msecs_to_jiffies(5));
    	return;
    }
diff --combined net/batman-adv/soft-interface.c
index a5590f4,92137af..92137af
--- a/net/batman-adv/soft-interface.c
+++ b/net/batman-adv/soft-interface.c
@@@ -22,6 -22,7 +22,7 @@@
  #include "main.h"
  #include "soft-interface.h"
  #include "hard-interface.h"
+ #include "distributed-arp-table.h"
  #include "routing.h"
  #include "send.h"
  #include "bat_debugfs.h"
@@@ -36,6 -37,7 +37,7 @@@
  #include <linux/etherdevice.h>
  #include <linux/if_vlan.h>
  #include "unicast.h"
+ #include "bridge_loop_avoidance.h"
static int bat_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
@@@ -73,439 -75,6 +75,6 @@@ int my_skb_head_push(struct sk_buff *sk
    return 0;
  }
- static void softif_neigh_free_ref(struct softif_neigh *softif_neigh)
- {
- 	if (atomic_dec_and_test(&softif_neigh->refcount))
- 		kfree_rcu(softif_neigh, rcu);
- }
- 
- static void softif_neigh_vid_free_rcu(struct rcu_head *rcu)
- {
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct softif_neigh *softif_neigh;
- 	struct hlist_node *node, *node_tmp;
- 	struct bat_priv *bat_priv;
- 
- 	softif_neigh_vid = container_of(rcu, struct softif_neigh_vid, rcu);
- 	bat_priv = softif_neigh_vid->bat_priv;
- 
- 	spin_lock_bh(&bat_priv->softif_neigh_lock);
- 	hlist_for_each_entry_safe(softif_neigh, node, node_tmp,
- 				  &softif_neigh_vid->softif_neigh_list, list) {
- 		hlist_del_rcu(&softif_neigh->list);
- 		softif_neigh_free_ref(softif_neigh);
- 	}
- 	spin_unlock_bh(&bat_priv->softif_neigh_lock);
- 
- 	kfree(softif_neigh_vid);
- }
- 
- static void softif_neigh_vid_free_ref(struct softif_neigh_vid *softif_neigh_vid)
- {
- 	if (atomic_dec_and_test(&softif_neigh_vid->refcount))
- 		call_rcu(&softif_neigh_vid->rcu, softif_neigh_vid_free_rcu);
- }
- 
- static struct softif_neigh_vid *softif_neigh_vid_get(struct bat_priv *bat_priv,
- 						     short vid)
- {
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct hlist_node *node;
- 
- 	rcu_read_lock();
- 	hlist_for_each_entry_rcu(softif_neigh_vid, node,
- 				 &bat_priv->softif_neigh_vids, list) {
- 		if (softif_neigh_vid->vid != vid)
- 			continue;
- 
- 		if (!atomic_inc_not_zero(&softif_neigh_vid->refcount))
- 			continue;
- 
- 		goto out;
- 	}
- 
- 	softif_neigh_vid = kzalloc(sizeof(*softif_neigh_vid), GFP_ATOMIC);
- 	if (!softif_neigh_vid)
- 		goto out;
- 
- 	softif_neigh_vid->vid = vid;
- 	softif_neigh_vid->bat_priv = bat_priv;
- 
- 	/* initialize with 2 - caller decrements counter by one */
- 	atomic_set(&softif_neigh_vid->refcount, 2);
- 	INIT_HLIST_HEAD(&softif_neigh_vid->softif_neigh_list);
- 	INIT_HLIST_NODE(&softif_neigh_vid->list);
- 	spin_lock_bh(&bat_priv->softif_neigh_vid_lock);
- 	hlist_add_head_rcu(&softif_neigh_vid->list,
- 			   &bat_priv->softif_neigh_vids);
- 	spin_unlock_bh(&bat_priv->softif_neigh_vid_lock);
- 
- out:
- 	rcu_read_unlock();
- 	return softif_neigh_vid;
- }
- 
- static struct softif_neigh *softif_neigh_get(struct bat_priv *bat_priv,
- 					     const uint8_t *addr, short vid)
- {
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct softif_neigh *softif_neigh = NULL;
- 	struct hlist_node *node;
- 
- 	softif_neigh_vid = softif_neigh_vid_get(bat_priv, vid);
- 	if (!softif_neigh_vid)
- 		goto out;
- 
- 	rcu_read_lock();
- 	hlist_for_each_entry_rcu(softif_neigh, node,
- 				 &softif_neigh_vid->softif_neigh_list,
- 				 list) {
- 		if (!compare_eth(softif_neigh->addr, addr))
- 			continue;
- 
- 		if (!atomic_inc_not_zero(&softif_neigh->refcount))
- 			continue;
- 
- 		softif_neigh->last_seen = jiffies;
- 		goto unlock;
- 	}
- 
- 	softif_neigh = kzalloc(sizeof(*softif_neigh), GFP_ATOMIC);
- 	if (!softif_neigh)
- 		goto unlock;
- 
- 	memcpy(softif_neigh->addr, addr, ETH_ALEN);
- 	softif_neigh->last_seen = jiffies;
- 	/* initialize with 2 - caller decrements counter by one */
- 	atomic_set(&softif_neigh->refcount, 2);
- 
- 	INIT_HLIST_NODE(&softif_neigh->list);
- 	spin_lock_bh(&bat_priv->softif_neigh_lock);
- 	hlist_add_head_rcu(&softif_neigh->list,
- 			   &softif_neigh_vid->softif_neigh_list);
- 	spin_unlock_bh(&bat_priv->softif_neigh_lock);
- 
- unlock:
- 	rcu_read_unlock();
- out:
- 	if (softif_neigh_vid)
- 		softif_neigh_vid_free_ref(softif_neigh_vid);
- 	return softif_neigh;
- }
- 
- static struct softif_neigh *softif_neigh_get_selected(
- 				struct softif_neigh_vid *softif_neigh_vid)
- {
- 	struct softif_neigh *softif_neigh;
- 
- 	rcu_read_lock();
- 	softif_neigh = rcu_dereference(softif_neigh_vid->softif_neigh);
- 
- 	if (softif_neigh && !atomic_inc_not_zero(&softif_neigh->refcount))
- 		softif_neigh = NULL;
- 
- 	rcu_read_unlock();
- 	return softif_neigh;
- }
- 
- static struct softif_neigh *softif_neigh_vid_get_selected(
- 						struct bat_priv *bat_priv,
- 						short vid)
- {
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct softif_neigh *softif_neigh = NULL;
- 
- 	softif_neigh_vid = softif_neigh_vid_get(bat_priv, vid);
- 	if (!softif_neigh_vid)
- 		goto out;
- 
- 	softif_neigh = softif_neigh_get_selected(softif_neigh_vid);
- out:
- 	if (softif_neigh_vid)
- 		softif_neigh_vid_free_ref(softif_neigh_vid);
- 	return softif_neigh;
- }
- 
- static void softif_neigh_vid_select(struct bat_priv *bat_priv,
- 				    struct softif_neigh *new_neigh,
- 				    short vid)
- {
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct softif_neigh *curr_neigh;
- 
- 	softif_neigh_vid = softif_neigh_vid_get(bat_priv, vid);
- 	if (!softif_neigh_vid)
- 		goto out;
- 
- 	spin_lock_bh(&bat_priv->softif_neigh_lock);
- 
- 	if (new_neigh && !atomic_inc_not_zero(&new_neigh->refcount))
- 		new_neigh = NULL;
- 
- 	curr_neigh = rcu_dereference_protected(softif_neigh_vid->softif_neigh,
- 					       1);
- 	rcu_assign_pointer(softif_neigh_vid->softif_neigh, new_neigh);
- 
- 	if ((curr_neigh) && (!new_neigh))
- 		bat_dbg(DBG_ROUTES, bat_priv,
- 			"Removing mesh exit point on vid: %d (prev: %pM).\n",
- 			vid, curr_neigh->addr);
- 	else if ((curr_neigh) && (new_neigh))
- 		bat_dbg(DBG_ROUTES, bat_priv,
- 			"Changing mesh exit point on vid: %d from %pM to %pM.\n",
- 			vid, curr_neigh->addr, new_neigh->addr);
- 	else if ((!curr_neigh) && (new_neigh))
- 		bat_dbg(DBG_ROUTES, bat_priv,
- 			"Setting mesh exit point on vid: %d to %pM.\n",
- 			vid, new_neigh->addr);
- 
- 	if (curr_neigh)
- 		softif_neigh_free_ref(curr_neigh);
- 
- 	spin_unlock_bh(&bat_priv->softif_neigh_lock);
- 
- out:
- 	if (softif_neigh_vid)
- 		softif_neigh_vid_free_ref(softif_neigh_vid);
- }
- 
- static void softif_neigh_vid_deselect(struct bat_priv *bat_priv,
- 				      struct softif_neigh_vid *softif_neigh_vid)
- {
- 	struct softif_neigh *curr_neigh;
- 	struct softif_neigh *softif_neigh = NULL, *softif_neigh_tmp;
- 	struct hard_iface *primary_if = NULL;
- 	struct hlist_node *node;
- 
- 	primary_if = primary_if_get_selected(bat_priv);
- 	if (!primary_if)
- 		goto out;
- 
- 	/* find new softif_neigh immediately to avoid temporary loops */
- 	rcu_read_lock();
- 	curr_neigh = rcu_dereference(softif_neigh_vid->softif_neigh);
- 
- 	hlist_for_each_entry_rcu(softif_neigh_tmp, node,
- 				 &softif_neigh_vid->softif_neigh_list,
- 				 list) {
- 		if (softif_neigh_tmp == curr_neigh)
- 			continue;
- 
- 		/* we got a neighbor but its mac is 'bigger' than ours  */
- 		if (memcmp(primary_if->net_dev->dev_addr,
- 			   softif_neigh_tmp->addr, ETH_ALEN) < 0)
- 			continue;
- 
- 		if (!atomic_inc_not_zero(&softif_neigh_tmp->refcount))
- 			continue;
- 
- 		softif_neigh = softif_neigh_tmp;
- 		goto unlock;
- 	}
- 
- unlock:
- 	rcu_read_unlock();
- out:
- 	softif_neigh_vid_select(bat_priv, softif_neigh, softif_neigh_vid->vid);
- 
- 	if (primary_if)
- 		hardif_free_ref(primary_if);
- 	if (softif_neigh)
- 		softif_neigh_free_ref(softif_neigh);
- }
- 
- int softif_neigh_seq_print_text(struct seq_file *seq, void *offset)
- {
- 	struct net_device *net_dev = (struct net_device *)seq->private;
- 	struct bat_priv *bat_priv = netdev_priv(net_dev);
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct softif_neigh *softif_neigh;
- 	struct hard_iface *primary_if;
- 	struct hlist_node *node, *node_tmp;
- 	struct softif_neigh *curr_softif_neigh;
- 	int ret = 0, last_seen_secs, last_seen_msecs;
- 
- 	primary_if = primary_if_get_selected(bat_priv);
- 	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 != IF_ACTIVE) {
- 		ret = seq_printf(seq,
- 				 "BATMAN mesh %s disabled - primary interface not active\n",
- 				 net_dev->name);
- 		goto out;
- 	}
- 
- 	seq_printf(seq, "Softif neighbor list (%s)\n", net_dev->name);
- 
- 	rcu_read_lock();
- 	hlist_for_each_entry_rcu(softif_neigh_vid, node,
- 				 &bat_priv->softif_neigh_vids, list) {
- 		seq_printf(seq, "     %-15s %s on vid: %d\n",
- 			   "Originator", "last-seen", softif_neigh_vid->vid);
- 
- 		curr_softif_neigh = softif_neigh_get_selected(softif_neigh_vid);
- 
- 		hlist_for_each_entry_rcu(softif_neigh, node_tmp,
- 					 &softif_neigh_vid->softif_neigh_list,
- 					 list) {
- 			last_seen_secs = jiffies_to_msecs(jiffies -
- 						softif_neigh->last_seen) / 1000;
- 			last_seen_msecs = jiffies_to_msecs(jiffies -
- 						softif_neigh->last_seen) % 1000;
- 			seq_printf(seq, "%s %pM  %3i.%03is\n",
- 				   curr_softif_neigh == softif_neigh
- 				   ? "=>" : "  ", softif_neigh->addr,
- 				   last_seen_secs, last_seen_msecs);
- 		}
- 
- 		if (curr_softif_neigh)
- 			softif_neigh_free_ref(curr_softif_neigh);
- 
- 		seq_printf(seq, "\n");
- 	}
- 	rcu_read_unlock();
- 
- out:
- 	if (primary_if)
- 		hardif_free_ref(primary_if);
- 	return ret;
- }
- 
- void softif_neigh_purge(struct bat_priv *bat_priv)
- {
- 	struct softif_neigh *softif_neigh, *curr_softif_neigh;
- 	struct softif_neigh_vid *softif_neigh_vid;
- 	struct hlist_node *node, *node_tmp, *node_tmp2;
- 	int do_deselect;
- 
- 	rcu_read_lock();
- 	hlist_for_each_entry_rcu(softif_neigh_vid, node,
- 				 &bat_priv->softif_neigh_vids, list) {
- 		if (!atomic_inc_not_zero(&softif_neigh_vid->refcount))
- 			continue;
- 
- 		curr_softif_neigh = softif_neigh_get_selected(softif_neigh_vid);
- 		do_deselect = 0;
- 
- 		spin_lock_bh(&bat_priv->softif_neigh_lock);
- 		hlist_for_each_entry_safe(softif_neigh, node_tmp, node_tmp2,
- 					  &softif_neigh_vid->softif_neigh_list,
- 					  list) {
- 			if ((!has_timed_out(softif_neigh->last_seen,
- 					    SOFTIF_NEIGH_TIMEOUT)) &&
- 			    (atomic_read(&bat_priv->mesh_state) == MESH_ACTIVE))
- 				continue;
- 
- 			if (curr_softif_neigh == softif_neigh) {
- 				bat_dbg(DBG_ROUTES, bat_priv,
- 					"Current mesh exit point on vid: %d '%pM' vanished.\n",
- 					softif_neigh_vid->vid,
- 					softif_neigh->addr);
- 				do_deselect = 1;
- 			}
- 
- 			hlist_del_rcu(&softif_neigh->list);
- 			softif_neigh_free_ref(softif_neigh);
- 		}
- 		spin_unlock_bh(&bat_priv->softif_neigh_lock);
- 
- 		/* soft_neigh_vid_deselect() needs to acquire the
- 		 * softif_neigh_lock */
- 		if (do_deselect)
- 			softif_neigh_vid_deselect(bat_priv, softif_neigh_vid);
- 
- 		if (curr_softif_neigh)
- 			softif_neigh_free_ref(curr_softif_neigh);
- 
- 		softif_neigh_vid_free_ref(softif_neigh_vid);
- 	}
- 	rcu_read_unlock();
- 
- 	spin_lock_bh(&bat_priv->softif_neigh_vid_lock);
- 	hlist_for_each_entry_safe(softif_neigh_vid, node, node_tmp,
- 				  &bat_priv->softif_neigh_vids, list) {
- 		if (!hlist_empty(&softif_neigh_vid->softif_neigh_list))
- 			continue;
- 
- 		hlist_del_rcu(&softif_neigh_vid->list);
- 		softif_neigh_vid_free_ref(softif_neigh_vid);
- 	}
- 	spin_unlock_bh(&bat_priv->softif_neigh_vid_lock);
- 
- }
- 
- static void softif_batman_recv(struct sk_buff *skb, struct net_device *dev,
- 			       short vid)
- {
- 	struct bat_priv *bat_priv = netdev_priv(dev);
- 	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
- 	struct batman_ogm_packet *batman_ogm_packet;
- 	struct softif_neigh *softif_neigh = NULL;
- 	struct hard_iface *primary_if = NULL;
- 	struct softif_neigh *curr_softif_neigh = NULL;
- 
- 	if (ntohs(ethhdr->h_proto) == ETH_P_8021Q)
- 		batman_ogm_packet = (struct batman_ogm_packet *)
- 					(skb->data + ETH_HLEN + VLAN_HLEN);
- 	else
- 		batman_ogm_packet = (struct batman_ogm_packet *)
- 							(skb->data + ETH_HLEN);
- 
- 	if (batman_ogm_packet->header.version != COMPAT_VERSION)
- 		goto out;
- 
- 	if (batman_ogm_packet->header.packet_type != BAT_OGM)
- 		goto out;
- 
- 	if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
- 		goto out;
- 
- 	if (is_my_mac(batman_ogm_packet->orig))
- 		goto out;
- 
- 	softif_neigh = softif_neigh_get(bat_priv, batman_ogm_packet->orig, vid);
- 	if (!softif_neigh)
- 		goto out;
- 
- 	curr_softif_neigh = softif_neigh_vid_get_selected(bat_priv, vid);
- 	if (curr_softif_neigh == softif_neigh)
- 		goto out;
- 
- 	primary_if = primary_if_get_selected(bat_priv);
- 	if (!primary_if)
- 		goto out;
- 
- 	/* we got a neighbor but its mac is 'bigger' than ours  */
- 	if (memcmp(primary_if->net_dev->dev_addr,
- 		   softif_neigh->addr, ETH_ALEN) < 0)
- 		goto out;
- 
- 	/* close own batX device and use softif_neigh as exit node */
- 	if (!curr_softif_neigh) {
- 		softif_neigh_vid_select(bat_priv, softif_neigh, vid);
- 		goto out;
- 	}
- 
- 	/* switch to new 'smallest neighbor' */
- 	if (memcmp(softif_neigh->addr, curr_softif_neigh->addr, ETH_ALEN) < 0)
- 		softif_neigh_vid_select(bat_priv, softif_neigh, vid);
- 
- out:
- 	kfree_skb(skb);
- 	if (softif_neigh)
- 		softif_neigh_free_ref(softif_neigh);
- 	if (curr_softif_neigh)
- 		softif_neigh_free_ref(curr_softif_neigh);
- 	if (primary_if)
- 		hardif_free_ref(primary_if);
- 	return;
- }
- 
  static int interface_open(struct net_device *dev)
  {
    netif_start_queue(dev);
@@@ -562,11 -131,12 +131,12 @@@ static int interface_tx(struct sk_buff 
    struct hard_iface *primary_if = NULL;
    struct bcast_packet *bcast_packet;
    struct vlan_ethhdr *vhdr;
- 	struct softif_neigh *curr_softif_neigh = NULL;
+ 	uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x00};
    unsigned int header_len = 0;
    int data_len = skb->len, ret;
- 	short vid = -1;
+ 	short vid __maybe_unused = -1;
    bool do_bcast = false;
+ 	unsigned long brd_delay = 1;
if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
    	goto dropped;
@@@ -583,21 -153,20 +153,20 @@@
/* fall through */
    case ETH_P_BATMAN:
- 		softif_batman_recv(skb, soft_iface, vid);
- 		goto end;
+ 		goto dropped;
    }
- 	/**
- 	 * if we have a another chosen mesh exit node in range
- 	 * it will transport the packets to the mesh
- 	 */
- 	curr_softif_neigh = softif_neigh_vid_get_selected(bat_priv, vid);
- 	if (curr_softif_neigh)
+ 	if (bla_tx(bat_priv, skb, vid))
    	goto dropped;
/* Register the client MAC in the transtable */
    tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
+ 	/* don't accept stp packets. STP does not help in meshes.
+ 	 * better use the bridge loop avoidance ... */
+ 	if (compare_eth(ethhdr->h_dest, stp_addr))
+ 		goto dropped;
+ 
    if (is_multicast_ether_addr(ethhdr->h_dest)) {
    	do_bcast = true;
@@@ -628,6 -197,9 +197,9 @@@
    	if (!primary_if)
    		goto dropped;
+ 		if (dat_snoop_outgoing_arp_request(bat_priv, skb))
+ 			brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);
+ 
    	if (my_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
    		goto dropped;
@@@ -647,7 -219,7 +219,7 @@@
    	bcast_packet->seqno =
    		htonl(atomic_inc_return(&bat_priv->bcast_seqno));
- 		add_bcast_packet_to_list(bat_priv, skb, 1);
+ 		add_bcast_packet_to_list(bat_priv, skb, brd_delay);
/* a copy is stored in the bcast list, therefore removing
    	 * the original skb. */
@@@ -661,6 -233,8 +233,8 @@@
    			goto dropped;
    	}
+ 		dat_snoop_outgoing_arp_reply(bat_priv, skb);
+ 
    	ret = unicast_send_skb(skb, bat_priv);
    	if (ret != 0)
    		goto dropped_freed;
@@@ -675,8 -249,6 +249,6 @@@ dropped
  dropped_freed:
    bat_priv->stats.tx_dropped++;
  end:
- 	if (curr_softif_neigh)
- 		softif_neigh_free_ref(curr_softif_neigh);
    if (primary_if)
    	hardif_free_ref(primary_if);
    return NETDEV_TX_OK;
@@@ -687,17 -259,20 +259,20 @@@ void interface_rx(struct net_device *so
    	  int hdr_size)
  {
    struct bat_priv *bat_priv = netdev_priv(soft_iface);
- 	struct unicast_packet *unicast_packet;
    struct ethhdr *ethhdr;
    struct vlan_ethhdr *vhdr;
- 	struct softif_neigh *curr_softif_neigh = NULL;
- 	short vid = -1;
- 	int ret;
+ 	short vid __maybe_unused = -1;
/* check if enough space is available for pulling, and pull */
    if (!pskb_may_pull(skb, hdr_size))
    	goto dropped;
+ 	if (dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
+ 		goto out;
+ 
+ 	if (dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
+ 		goto out;
+ 
    skb_pull_rcsum(skb, hdr_size);
    skb_reset_mac_header(skb);
@@@ -716,30 -291,6 +291,6 @@@
    	goto dropped;
    }
- 	/**
- 	 * if we have a another chosen mesh exit node in range
- 	 * it will transport the packets to the non-mesh network
- 	 */
- 	curr_softif_neigh = softif_neigh_vid_get_selected(bat_priv, vid);
- 	if (curr_softif_neigh) {
- 		skb_push(skb, hdr_size);
- 		unicast_packet = (struct unicast_packet *)skb->data;
- 
- 		if ((unicast_packet->header.packet_type != BAT_UNICAST) &&
- 		    (unicast_packet->header.packet_type != BAT_UNICAST_FRAG))
- 			goto dropped;
- 
- 		skb_reset_mac_header(skb);
- 
- 		memcpy(unicast_packet->dest,
- 		       curr_softif_neigh->addr, ETH_ALEN);
- 		ret = route_unicast_packet(skb, recv_if);
- 		if (ret == NET_RX_DROP)
- 			goto dropped;
- 
- 		goto out;
- 	}
- 
    /* skb->dev & skb->pkt_type are set here */
    if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
    	goto dropped;
@@@ -752,21 -303,24 +303,24 @@@
  /*	skb->ip_summed = CHECKSUM_UNNECESSARY;*/
bat_priv->stats.rx_packets++;
- 	bat_priv->stats.rx_bytes += skb->len + sizeof(struct ethhdr);
+ 	bat_priv->stats.rx_bytes += skb->len + ETH_HLEN;
soft_iface->last_rx = jiffies;
if (is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest))
    	goto dropped;
+ 	/* Let the bridge loop avoidance check the packet. If will
+ 	 * not handle it, we can safely push it up. */
+ 	if (bla_rx(bat_priv, skb, vid))
+ 		goto out;
+ 
    netif_rx(skb);
    goto out;
dropped:
    kfree_skb(skb);
  out:
- 	if (curr_softif_neigh)
- 		softif_neigh_free_ref(curr_softif_neigh);
    return;
  }
@@@ -824,17 -378,20 +378,20 @@@ struct net_device *softif_create(const 
    	goto free_soft_iface;
    }
+ 	arp_change_timeout(soft_iface, name);
+ 
    bat_priv = netdev_priv(soft_iface);
atomic_set(&bat_priv->aggregated_ogms, 1);
    atomic_set(&bat_priv->bonding, 0);
+ 	atomic_set(&bat_priv->bridge_loop_avoidance, 0);
    atomic_set(&bat_priv->ap_isolation, 0);
    atomic_set(&bat_priv->vis_mode, VIS_TYPE_CLIENT_UPDATE);
    atomic_set(&bat_priv->gw_mode, GW_MODE_OFF);
    atomic_set(&bat_priv->gw_sel_class, 20);
    atomic_set(&bat_priv->gw_bandwidth, 41);
    atomic_set(&bat_priv->orig_interval, 1000);
- 	atomic_set(&bat_priv->hop_penalty, 10);
+ 	atomic_set(&bat_priv->hop_penalty, 30);
    atomic_set(&bat_priv->log_level, 0);
    atomic_set(&bat_priv->fragmentation, 1);
    atomic_set(&bat_priv->bcast_queue_left, BCAST_QUEUE_LEN);
@@@ -845,6 -402,7 +402,7 @@@
    atomic_set(&bat_priv->ttvn, 0);
    atomic_set(&bat_priv->tt_local_changes, 0);
    atomic_set(&bat_priv->tt_ogm_append_cnt, 0);
+ 	atomic_set(&bat_priv->bla_num_requests, 0);
bat_priv->tt_buff = NULL;
    bat_priv->tt_buff_len = 0;
diff --combined net/batman-adv/soft-interface.h
index 756eab5,0203006..0203006
--- a/net/batman-adv/soft-interface.h
+++ b/net/batman-adv/soft-interface.h
@@@ -23,8 -23,6 +23,6 @@@
  #define _NET_BATMAN_ADV_SOFT_INTERFACE_H_
int my_skb_head_push(struct sk_buff *skb, unsigned int len);
- int softif_neigh_seq_print_text(struct seq_file *seq, void *offset);
- void softif_neigh_purge(struct bat_priv *bat_priv);
  void interface_rx(struct net_device *soft_iface,
    	  struct sk_buff *skb, struct hard_iface *recv_if,
    	  int hdr_size);
diff --combined net/batman-adv/translation-table.c
index 1f86921,934900d..934900d
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@@ -1,7 -1,7 +1,7 @@@
  /*
   * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
   *
-  * Marek Lindner, Simon Wunderlich
+  * 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
@@@ -27,13 -27,14 +27,14 @@@
  #include "hash.h"
  #include "originator.h"
  #include "routing.h"
+ #include "bridge_loop_avoidance.h"
#include <linux/crc16.h>
- static void _tt_global_del(struct bat_priv *bat_priv,
- 			   struct tt_global_entry *tt_global_entry,
- 			   const char *message);
+ static void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
+ 			  struct orig_node *orig_node);
  static void tt_purge(struct work_struct *work);
+ static void tt_global_del_orig_list(struct tt_global_entry *tt_global_entry);
/* returns 1 if they are the same mac addr */
  static int compare_tt(const struct hlist_node *node, const void *data2)
@@@ -123,17 -124,31 +124,31 @@@ static void tt_global_entry_free_rcu(st
    tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
    			       common);
- 	if (tt_global_entry->orig_node)
- 		orig_node_free_ref(tt_global_entry->orig_node);
- 
    kfree(tt_global_entry);
  }
static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry)
  {
- 	if (atomic_dec_and_test(&tt_global_entry->common.refcount))
+ 	if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {
+ 		tt_global_del_orig_list(tt_global_entry);
    	call_rcu(&tt_global_entry->common.rcu,
    		 tt_global_entry_free_rcu);
+ 	}
+ }
+ 
+ static void tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
+ {
+ 	struct tt_orig_list_entry *orig_entry;
+ 
+ 	orig_entry = container_of(rcu, struct tt_orig_list_entry, rcu);
+ 	atomic_dec(&orig_entry->orig_node->tt_size);
+ 	orig_node_free_ref(orig_entry->orig_node);
+ 	kfree(orig_entry);
+ }
+ 
+ static void tt_orig_list_entry_free_ref(struct tt_orig_list_entry *orig_entry)
+ {
+ 	call_rcu(&orig_entry->rcu, tt_orig_list_entry_free_rcu);
  }
static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr,
@@@ -182,6 -197,9 +197,9 @@@ void tt_local_add(struct net_device *so
    struct bat_priv *bat_priv = netdev_priv(soft_iface);
    struct tt_local_entry *tt_local_entry = NULL;
    struct tt_global_entry *tt_global_entry = NULL;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct tt_orig_list_entry *orig_entry;
    int hash_added;
tt_local_entry = tt_local_hash_find(bat_priv, addr);
@@@ -232,14 -250,21 +250,21 @@@
/* Check whether it is a roaming! */
    if (tt_global_entry) {
- 		/* This node is probably going to update its tt table */
- 		tt_global_entry->orig_node->tt_poss_change = true;
- 		/* The global entry has to be marked as ROAMING and has to be
- 		 * kept for consistency purpose */
+ 		/* 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;
+ 
+ 			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 |= TT_CLIENT_ROAM;
    	tt_global_entry->roam_at = jiffies;
- 		send_roam_adv(bat_priv, tt_global_entry->common.addr,
- 			      tt_global_entry->orig_node);
    }
  out:
    if (tt_local_entry)
@@@ -490,33 -515,75 +515,75 @@@ static void tt_changes_list_free(struc
    spin_unlock_bh(&bat_priv->tt_changes_list_lock);
  }
+ /* find out if an orig_node is already in the list of a tt_global_entry.
+  * returns 1 if found, 0 otherwise */
+ static bool tt_global_entry_has_orig(const struct tt_global_entry *entry,
+ 				     const struct orig_node *orig_node)
+ {
+ 	struct tt_orig_list_entry *tmp_orig_entry;
+ 	const struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	bool found = false;
+ 
+ 	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) {
+ 			found = true;
+ 			break;
+ 		}
+ 	}
+ 	rcu_read_unlock();
+ 	return found;
+ }
+ 
+ static void tt_global_add_orig_entry(struct tt_global_entry *tt_global_entry,
+ 				     struct orig_node *orig_node,
+ 				     int ttvn)
+ {
+ 	struct tt_orig_list_entry *orig_entry;
+ 
+ 	orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
+ 	if (!orig_entry)
+ 		return;
+ 
+ 	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;
+ 
+ 	spin_lock_bh(&tt_global_entry->list_lock);
+ 	hlist_add_head_rcu(&orig_entry->list,
+ 			   &tt_global_entry->orig_list);
+ 	spin_unlock_bh(&tt_global_entry->list_lock);
+ }
+ 
  /* caller must hold orig_node refcount */
  int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
    	  const unsigned char *tt_addr, uint8_t ttvn, bool roaming,
    	  bool wifi)
  {
- 	struct tt_global_entry *tt_global_entry;
- 	struct orig_node *orig_node_tmp;
+ 	struct tt_global_entry *tt_global_entry = NULL;
    int ret = 0;
    int hash_added;
tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
if (!tt_global_entry) {
- 		tt_global_entry =
- 			kmalloc(sizeof(*tt_global_entry),
- 				GFP_ATOMIC);
+ 		tt_global_entry = kzalloc(sizeof(*tt_global_entry),
+ 					  GFP_ATOMIC);
    	if (!tt_global_entry)
    		goto out;
memcpy(tt_global_entry->common.addr, tt_addr, ETH_ALEN);
+ 
    	tt_global_entry->common.flags = NO_FLAGS;
- 		atomic_set(&tt_global_entry->common.refcount, 2);
- 		/* Assign the new orig_node */
- 		atomic_inc(&orig_node->refcount);
- 		tt_global_entry->orig_node = orig_node;
- 		tt_global_entry->ttvn = ttvn;
    	tt_global_entry->roam_at = 0;
+ 		atomic_set(&tt_global_entry->common.refcount, 2);
+ 
+ 		INIT_HLIST_HEAD(&tt_global_entry->orig_list);
+ 		spin_lock_init(&tt_global_entry->list_lock);
hash_added = hash_add(bat_priv->tt_global_hash, compare_tt,
    			 choose_orig, &tt_global_entry->common,
@@@ -527,19 -594,27 +594,27 @@@
    		tt_global_entry_free_ref(tt_global_entry);
    		goto out_remove;
    	}
- 		atomic_inc(&orig_node->tt_size);
+ 
+ 		tt_global_add_orig_entry(tt_global_entry, orig_node, ttvn);
    } else {
- 		if (tt_global_entry->orig_node != orig_node) {
- 			atomic_dec(&tt_global_entry->orig_node->tt_size);
- 			orig_node_tmp = tt_global_entry->orig_node;
- 			atomic_inc(&orig_node->refcount);
- 			tt_global_entry->orig_node = orig_node;
- 			orig_node_free_ref(orig_node_tmp);
- 			atomic_inc(&orig_node->tt_size);
+ 		/* there is already a global entry, use this one. */
+ 
+ 		/* If there is the 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 & TT_CLIENT_ROAM) {
+ 			tt_global_del_orig_list(tt_global_entry);
+ 			tt_global_entry->common.flags &= ~TT_CLIENT_ROAM;
+ 			tt_global_entry->roam_at = 0;
    	}
- 		tt_global_entry->common.flags = NO_FLAGS;
- 		tt_global_entry->ttvn = ttvn;
- 		tt_global_entry->roam_at = 0;
+ 
+ 		if (!tt_global_entry_has_orig(tt_global_entry, orig_node))
+ 			tt_global_add_orig_entry(tt_global_entry, orig_node,
+ 						 ttvn);
    }
if (wifi)
@@@ -560,6 -635,34 +635,34 @@@ out
    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 tt_global_print_entry(struct tt_global_entry *tt_global_entry,
+ 				  struct seq_file *seq)
+ {
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct tt_orig_list_entry *orig_entry;
+ 	struct 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]\n",
+ 			   tt_global_entry->common.addr, orig_entry->ttvn,
+ 			   orig_entry->orig_node->orig, last_ttvn,
+ 			   (flags & TT_CLIENT_ROAM ? 'R' : '.'),
+ 			   (flags & TT_CLIENT_WIFI ? 'W' : '.'));
+ 	}
+ }
+ 
  int tt_global_seq_print_text(struct seq_file *seq, void *offset)
  {
    struct net_device *net_dev = (struct net_device *)seq->private;
@@@ -603,18 -706,7 +706,7 @@@
    		tt_global_entry = container_of(tt_common_entry,
    					       struct tt_global_entry,
    					       common);
- 			seq_printf(seq,
- 				   " * %pM  (%3u) via %pM     (%3u)   [%c%c]\n",
- 				   tt_global_entry->common.addr,
- 				   tt_global_entry->ttvn,
- 				   tt_global_entry->orig_node->orig,
- 				   (uint8_t) atomic_read(
- 						&tt_global_entry->orig_node->
- 						last_ttvn),
- 				   (tt_global_entry->common.flags &
- 				    TT_CLIENT_ROAM ? 'R' : '.'),
- 				   (tt_global_entry->common.flags &
- 				    TT_CLIENT_WIFI ? 'W' : '.'));
+ 			tt_global_print_entry(tt_global_entry, seq);
    	}
    	rcu_read_unlock();
    }
@@@ -624,59 -716,149 +716,149 @@@ out
    return ret;
  }
- static void _tt_global_del(struct bat_priv *bat_priv,
- 			   struct tt_global_entry *tt_global_entry,
- 			   const char *message)
+ /* deletes the orig list of a tt_global_entry */
+ static void tt_global_del_orig_list(struct tt_global_entry *tt_global_entry)
  {
- 	if (!tt_global_entry)
- 		goto out;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node, *safe;
+ 	struct tt_orig_list_entry *orig_entry;
- 	bat_dbg(DBG_TT, bat_priv,
- 		"Deleting global tt entry %pM (via %pM): %s\n",
- 		tt_global_entry->common.addr, tt_global_entry->orig_node->orig,
- 		message);
+ 	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);
+ 		tt_orig_list_entry_free_ref(orig_entry);
+ 	}
+ 	spin_unlock_bh(&tt_global_entry->list_lock);
- 	atomic_dec(&tt_global_entry->orig_node->tt_size);
+ }
+ 
+ static void tt_global_del_orig_entry(struct bat_priv *bat_priv,
+ 				     struct tt_global_entry *tt_global_entry,
+ 				     struct orig_node *orig_node,
+ 				     const char *message)
+ {
+ 	struct hlist_head *head;
+ 	struct hlist_node *node, *safe;
+ 	struct 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) {
+ 			bat_dbg(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);
+ 			tt_orig_list_entry_free_ref(orig_entry);
+ 		}
+ 	}
+ 	spin_unlock_bh(&tt_global_entry->list_lock);
+ }
+ 
+ static void tt_global_del_struct(struct bat_priv *bat_priv,
+ 				 struct tt_global_entry *tt_global_entry,
+ 				 const char *message)
+ {
+ 	bat_dbg(DBG_TT, bat_priv,
+ 		"Deleting global tt entry %pM: %s\n",
+ 		tt_global_entry->common.addr, message);
hash_remove(bat_priv->tt_global_hash, compare_tt, choose_orig,
    	    tt_global_entry->common.addr);
- out:
- 	if (tt_global_entry)
- 		tt_global_entry_free_ref(tt_global_entry);
+ 	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 TT_CLIENT_ROAM flag and the timer,
+  * otherwise we simply remove the originator scheduled for deletion.
+  */
+ static void tt_global_del_roaming(struct bat_priv *bat_priv,
+ 				  struct tt_global_entry *tt_global_entry,
+ 				  struct orig_node *orig_node,
+ 				  const char *message)
+ {
+ 	bool last_entry = true;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct 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 |= 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. */
+ 		tt_global_del_orig_entry(bat_priv, tt_global_entry,
+ 					 orig_node, message);
  }
- void tt_global_del(struct bat_priv *bat_priv,
- 		   struct orig_node *orig_node, const unsigned char *addr,
- 		   const char *message, bool roaming)
+ 
+ 
+ static void tt_global_del(struct bat_priv *bat_priv,
+ 			  struct orig_node *orig_node,
+ 			  const unsigned char *addr,
+ 			  const char *message, bool roaming)
  {
    struct tt_global_entry *tt_global_entry = NULL;
    struct tt_local_entry *tt_local_entry = NULL;
tt_global_entry = tt_global_hash_find(bat_priv, addr);
- 	if (!tt_global_entry || tt_global_entry->orig_node != orig_node)
+ 	if (!tt_global_entry)
    	goto out;
- 	if (!roaming)
- 		goto out_del;
+ 	if (!roaming) {
+ 		tt_global_del_orig_entry(bat_priv, tt_global_entry, orig_node,
+ 					 message);
+ 
+ 		if (hlist_empty(&tt_global_entry->orig_list))
+ 			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 => we mark
+ 	 * 1) the client roamed from node A to node B => if there
+ 	 *    is only one originator left for this client, we mark
     *    it with 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. */
+ 
    tt_local_entry = tt_local_hash_find(bat_priv,
    				    tt_global_entry->common.addr);
- 	if (!tt_local_entry) {
- 		tt_global_entry->common.flags |= TT_CLIENT_ROAM;
- 		tt_global_entry->roam_at = jiffies;
- 		goto out;
- 	}
+ 	if (tt_local_entry) {
+ 		/* local entry exists, case 2: client roamed to us. */
+ 		tt_global_del_orig_list(tt_global_entry);
+ 		tt_global_del_struct(bat_priv, tt_global_entry, message);
+ 	} else
+ 		/* no local entry exists, case 1: check for roaming */
+ 		tt_global_del_roaming(bat_priv, tt_global_entry, orig_node,
+ 				      message);
- out_del:
- 	_tt_global_del(bat_priv, tt_global_entry, message);
out:
    if (tt_global_entry)
@@@ -709,11 -891,14 +891,14 @@@ void tt_global_del_orig(struct bat_pri
    		tt_global_entry = container_of(tt_common_entry,
    					       struct tt_global_entry,
    					       common);
- 			if (tt_global_entry->orig_node == orig_node) {
+ 
+ 			tt_global_del_orig_entry(bat_priv, tt_global_entry,
+ 						 orig_node, message);
+ 
+ 			if (hlist_empty(&tt_global_entry->orig_list)) {
    			bat_dbg(DBG_TT, bat_priv,
- 					"Deleting global tt entry %pM (via %pM): %s\n",
+ 					"Deleting global tt entry %pM: %s\n",
    				tt_global_entry->common.addr,
- 					tt_global_entry->orig_node->orig,
    				message);
    			hlist_del_rcu(node);
    			tt_global_entry_free_ref(tt_global_entry);
@@@ -754,7 -939,7 +939,7 @@@ static void tt_global_roam_purge(struc
    		bat_dbg(DBG_TT, bat_priv,
    			"Deleting global tt entry (%pM): Roaming timeout\n",
    			tt_global_entry->common.addr);
- 			atomic_dec(&tt_global_entry->orig_node->tt_size);
+ 
    		hlist_del_rcu(node);
    		tt_global_entry_free_ref(tt_global_entry);
    	}
@@@ -817,6 -1002,11 +1002,11 @@@ struct orig_node *transtable_search(str
    struct tt_local_entry *tt_local_entry = NULL;
    struct tt_global_entry *tt_global_entry = NULL;
    struct orig_node *orig_node = NULL;
+ 	struct neigh_node *router = NULL;
+ 	struct hlist_head *head;
+ 	struct hlist_node *node;
+ 	struct tt_orig_list_entry *orig_entry;
+ 	int best_tq;
if (src && atomic_read(&bat_priv->ap_isolation)) {
    	tt_local_entry = tt_local_hash_find(bat_priv, src);
@@@ -833,11 -1023,25 +1023,25 @@@
    if (tt_local_entry && _is_ap_isolated(tt_local_entry, tt_global_entry))
    	goto out;
- 	if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount))
- 		goto out;
+ 	best_tq = 0;
- 	orig_node = tt_global_entry->orig_node;
+ 	rcu_read_lock();
+ 	head = &tt_global_entry->orig_list;
+ 	hlist_for_each_entry_rcu(orig_entry, node, head, list) {
+ 		router = 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;
+ 		}
+ 		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)
    	tt_global_entry_free_ref(tt_global_entry);
@@@ -848,7 -1052,8 +1052,8 @@@
  }
/* Calculates the checksum of the local table of a given orig_node */
- uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node)
+ static uint16_t tt_global_crc(struct bat_priv *bat_priv,
+ 			      struct orig_node *orig_node)
  {
    uint16_t total = 0, total_one;
    struct hashtable_t *hash = bat_priv->tt_global_hash;
@@@ -868,20 -1073,24 +1073,24 @@@
    		tt_global_entry = container_of(tt_common_entry,
    					       struct tt_global_entry,
    					       common);
- 			if (compare_eth(tt_global_entry->orig_node,
- 					orig_node)) {
- 				/* 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_entry->flags & TT_CLIENT_ROAM)
- 					continue;
- 				total_one = 0;
- 				for (j = 0; j < ETH_ALEN; j++)
- 					total_one = crc16_byte(total_one,
- 						tt_common_entry->addr[j]);
- 				total ^= total_one;
- 			}
+ 			/* 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_global_entry->common.flags & TT_CLIENT_ROAM)
+ 				continue;
+ 
+ 			/* find out if this global entry is announced by this
+ 			 * originator */
+ 			if (!tt_global_entry_has_orig(tt_global_entry,
+ 						      orig_node))
+ 				continue;
+ 
+ 			total_one = 0;
+ 			for (j = 0; j < ETH_ALEN; j++)
+ 				total_one = crc16_byte(total_one,
+ 					tt_global_entry->common.addr[j]);
+ 			total ^= total_one;
    	}
    	rcu_read_unlock();
    }
@@@ -936,8 -1145,10 +1145,10 @@@ static void tt_req_list_free(struct bat
    spin_unlock_bh(&bat_priv->tt_req_list_lock);
  }
- void tt_save_orig_buffer(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 			 const unsigned char *tt_buff, uint8_t tt_num_changes)
+ static void tt_save_orig_buffer(struct bat_priv *bat_priv,
+ 				struct orig_node *orig_node,
+ 				const unsigned char *tt_buff,
+ 				uint8_t tt_num_changes)
  {
    uint16_t tt_buff_len = tt_len(tt_num_changes);
@@@ -1020,7 -1231,7 +1231,7 @@@ static int tt_global_valid_entry(const 
    tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
    			       common);
- 	return (tt_global_entry->orig_node == orig_node);
+ 	return tt_global_entry_has_orig(tt_global_entry, orig_node);
  }
static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
@@@ -1401,10 -1612,15 +1612,15 @@@ out
  bool send_tt_response(struct bat_priv *bat_priv,
    	      struct tt_query_packet *tt_request)
  {
- 	if (is_my_mac(tt_request->dst))
+ 	if (is_my_mac(tt_request->dst)) {
+ 		/* don't answer backbone gws! */
+ 		if (bla_is_backbone_gw_orig(bat_priv, tt_request->src))
+ 			return true;
+ 
    	return send_my_tt_response(bat_priv, tt_request);
- 	else
+ 	} else {
    	return send_other_tt_response(bat_priv, tt_request);
+ 	}
  }
static void _tt_update_changes(struct bat_priv *bat_priv,
@@@ -1508,6 -1724,10 +1724,10 @@@ void handle_tt_response(struct bat_pri
    	tt_response->src, tt_response->ttvn, tt_response->tt_data,
    	(tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
+ 	/* we should have never asked a backbone gw */
+ 	if (bla_is_backbone_gw_orig(bat_priv, tt_response->src))
+ 		goto out;
+ 
    orig_node = orig_hash_find(bat_priv, tt_response->src);
    if (!orig_node)
    	goto out;
@@@ -1627,8 -1847,8 +1847,8 @@@ unlock
    return ret;
  }
- void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
- 		   struct orig_node *orig_node)
+ static void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
+ 			  struct orig_node *orig_node)
  {
    struct neigh_node *neigh_node = NULL;
    struct sk_buff *skb = NULL;
@@@ -1796,6 -2016,8 +2016,8 @@@ void tt_commit_changes(struct bat_priv
/* Increment the TTVN only once per OGM interval */
    atomic_inc(&bat_priv->ttvn);
+ 	bat_dbg(DBG_TT, bat_priv, "Local changes committed, updating to ttvn %u\n",
+ 		(uint8_t)atomic_read(&bat_priv->ttvn));
    bat_priv->tt_poss_change = false;
  }
@@@ -1836,6 -2058,10 +2058,10 @@@ void tt_update_orig(struct bat_priv *ba
    uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
    bool full_table = true;
+ 	/* don't care about a backbone gateways updates. */
+ 	if (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) ||
@@@ -1873,6 -2099,7 +2099,7 @@@
    } 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:
@@@ -1886,3 -2113,21 +2113,21 @@@
    	}
    }
  }
+ 
+ /* 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 tt_global_client_is_roaming(struct bat_priv *bat_priv, uint8_t *addr)
+ {
+ 	struct tt_global_entry *tt_global_entry;
+ 	bool ret = false;
+ 
+ 	tt_global_entry = tt_global_hash_find(bat_priv, addr);
+ 	if (!tt_global_entry)
+ 		goto out;
+ 
+ 	ret = tt_global_entry->common.flags & TT_CLIENT_ROAM;
+ 	tt_global_entry_free_ref(tt_global_entry);
+ out:
+ 	return ret;
+ }
diff --combined net/batman-adv/translation-table.h
index c753633,c43374d..c43374d
--- a/net/batman-adv/translation-table.h
+++ b/net/batman-adv/translation-table.h
@@@ -1,7 -1,7 +1,7 @@@
  /*
   * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
   *
-  * Marek Lindner, Simon Wunderlich
+  * 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
@@@ -39,27 -39,21 +39,21 @@@ int tt_global_add(struct bat_priv *bat_
  int tt_global_seq_print_text(struct seq_file *seq, void *offset);
  void tt_global_del_orig(struct bat_priv *bat_priv,
    		struct orig_node *orig_node, const char *message);
- void tt_global_del(struct bat_priv *bat_priv,
- 		   struct orig_node *orig_node, const unsigned char *addr,
- 		   const char *message, bool roaming);
  struct orig_node *transtable_search(struct bat_priv *bat_priv,
    			    const uint8_t *src, const uint8_t *addr);
- void tt_save_orig_buffer(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 			 const unsigned char *tt_buff, uint8_t tt_num_changes);
  uint16_t tt_local_crc(struct bat_priv *bat_priv);
- uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node);
  void tt_free(struct bat_priv *bat_priv);
  bool send_tt_response(struct bat_priv *bat_priv,
    	      struct tt_query_packet *tt_request);
  bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr);
  void handle_tt_response(struct bat_priv *bat_priv,
    		struct tt_query_packet *tt_response);
- void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
- 		   struct orig_node *orig_node);
  void tt_commit_changes(struct bat_priv *bat_priv);
  bool is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, uint8_t *dst);
  void tt_update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
    	    const unsigned char *tt_buff, uint8_t tt_num_changes,
    	    uint8_t ttvn, uint16_t tt_crc);
+ bool tt_global_client_is_roaming(struct bat_priv *bat_priv, uint8_t *addr);
+
#endif /* _NET_BATMAN_ADV_TRANSLATION_TABLE_H_ */
diff --combined net/batman-adv/types.h
index 302efb5,15f538a..15f538a
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@@ -27,7 -27,18 +27,18 @@@
  #include "packet.h"
  #include "bitarray.h"
- #define BAT_HEADER_LEN (sizeof(struct ethhdr) + \
+ #ifdef CONFIG_BATMAN_ADV_DAT
+ 
+ /* dat_addr_t is the type used for all DHT addresses. If it is changed,
+  * DAT_ADDR_MAX is changed as well.
+  *
+  * *Please be careful: dat_addr_t must be UNSIGNED*
+  */
+ #define dat_addr_t uint16_t
+ 
+ #endif /* CONFIG_BATMAN_ADV_DAT */
+ 
+ #define BAT_HEADER_LEN (ETH_HLEN + \
    ((sizeof(struct unicast_packet) > sizeof(struct bcast_packet) ? \
     sizeof(struct unicast_packet) : \
     sizeof(struct bcast_packet))))
@@@ -52,7 -63,7 +63,7 @@@ struct hard_iface 
  /**
   *	orig_node - structure for orig_list maintaining nodes of mesh
   *	@primary_addr: hosts primary interface address
-  *	@last_valid: when last packet from this node was received
+  *	@last_seen: when last packet from this node was received
   *	@bcast_seqno_reset: time when the broadcast seqno window was reset
   *	@batman_seqno_reset: time when the batman seqno window was reset
   *	@gw_flags: flags related to gateway class
@@@ -67,10 -78,13 +78,13 @@@
  struct orig_node {
    uint8_t orig[ETH_ALEN];
    uint8_t primary_addr[ETH_ALEN];
+ #ifdef CONFIG_BATMAN_ADV_DAT
+ 	dat_addr_t dht_addr;
+ #endif
    struct neigh_node __rcu *router; /* rcu protected pointer */
    unsigned long *bcast_own;
    uint8_t *bcast_own_sum;
- 	unsigned long last_valid;
+ 	unsigned long last_seen;
    unsigned long bcast_seqno_reset;
    unsigned long batman_seqno_reset;
    uint8_t gw_flags;
@@@ -90,7 -104,7 +104,7 @@@
    bool tt_poss_change;
    uint32_t last_real_seqno;
    uint8_t last_ttl;
- 	unsigned long bcast_bits[NUM_WORDS];
+ 	DECLARE_BITMAP(bcast_bits, TQ_LOCAL_WINDOW_SIZE);
    uint32_t last_bcast_seqno;
    struct hlist_head neigh_list;
    struct list_head frag_list;
@@@ -120,7 -134,7 +134,7 @@@ struct gw_node
/**
   *	neigh_node
-  *	@last_valid: when last packet via this neighbor was received
+  *	@last_seen: when last packet via this neighbor was received
   */
  struct neigh_node {
    struct hlist_node list;
@@@ -131,15 -145,22 +145,22 @@@
    uint8_t tq_avg;
    uint8_t last_ttl;
    struct list_head bonding_list;
- 	unsigned long last_valid;
- 	unsigned long real_bits[NUM_WORDS];
+ 	unsigned long last_seen;
+ 	DECLARE_BITMAP(real_bits, TQ_LOCAL_WINDOW_SIZE);
    atomic_t refcount;
    struct rcu_head rcu;
    struct orig_node *orig_node;
    struct hard_iface *if_incoming;
- 	spinlock_t tq_lock;	/* protects: tq_recv, tq_index */
+ 	spinlock_t lq_update_lock;	/* protects: tq_recv, tq_index */
  };
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ struct bcast_duplist_entry {
+ 	uint8_t orig[ETH_ALEN];
+ 	uint16_t crc;
+ 	unsigned long entrytime;
+ };
+ #endif
struct bat_priv {
    atomic_t mesh_state;
@@@ -148,6 -169,7 +169,7 @@@
    atomic_t bonding;		/* boolean */
    atomic_t fragmentation;		/* boolean */
    atomic_t ap_isolation;		/* boolean */
+ 	atomic_t bridge_loop_avoidance;	/* boolean */
    atomic_t vis_mode;		/* VIS_TYPE_* */
    atomic_t gw_mode;		/* GW_MODE_* */
    atomic_t gw_sel_class;		/* uint */
@@@ -161,6 -183,7 +183,7 @@@
    atomic_t ttvn; /* translation table version number */
    atomic_t tt_ogm_append_cnt;
    atomic_t tt_local_changes; /* changes registered in a OGM interval */
+ 	atomic_t bla_num_requests; /* number of bla requests in flight */
    /* The tt_poss_change flag is used to detect an ongoing roaming phase.
     * If true, then I received a Roaming_adv and I have to inspect every
     * packet directed to me to check whether I am still the true
@@@ -174,15 -197,23 +197,23 @@@
    struct hlist_head forw_bat_list;
    struct hlist_head forw_bcast_list;
    struct hlist_head gw_list;
- 	struct hlist_head softif_neigh_vids;
    struct list_head tt_changes_list; /* tracks changes in a OGM int */
    struct list_head vis_send_list;
    struct hashtable_t *orig_hash;
    struct hashtable_t *tt_local_hash;
    struct hashtable_t *tt_global_hash;
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ 	struct hashtable_t *claim_hash;
+ 	struct hashtable_t *backbone_hash;
+ #endif
    struct list_head tt_req_list; /* list of pending tt_requests */
    struct list_head tt_roam_list;
    struct hashtable_t *vis_hash;
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ 	struct bcast_duplist_entry bcast_duplist[DUPLIST_SIZE];
+ 	int bcast_duplist_curr;
+ 	struct bla_claim_dst claim_dest;
+ #endif
    spinlock_t forw_bat_list_lock; /* protects forw_bat_list */
    spinlock_t forw_bcast_list_lock; /* protects  */
    spinlock_t tt_changes_list_lock; /* protects tt_changes */
@@@ -191,8 -222,6 +222,6 @@@
    spinlock_t gw_list_lock; /* protects gw_list and curr_gw */
    spinlock_t vis_hash_lock; /* protects vis_hash */
    spinlock_t vis_list_lock; /* protects vis_info::recv_list */
- 	spinlock_t softif_neigh_lock; /* protects soft-interface neigh list */
- 	spinlock_t softif_neigh_vid_lock; /* protects soft-interface vid list */
    atomic_t num_local_tt;
    /* Checksum of the local table, recomputed before sending a new OGM */
    atomic_t tt_crc;
@@@ -202,9 -231,13 +231,13 @@@
    struct delayed_work tt_work;
    struct delayed_work orig_work;
    struct delayed_work vis_work;
+ 	struct delayed_work bla_work;
    struct gw_node __rcu *curr_gw;  /* rcu protected pointer */
    atomic_t gw_reselect;
    struct hard_iface __rcu *primary_if;  /* rcu protected pointer */
+ #ifdef CONFIG_BATMAN_ADV_DAT
+ 	dat_addr_t dht_addr;
+ #endif
    struct vis_info *my_vis_info;
    struct bat_algo_ops *bat_algo_ops;
  };
@@@ -239,10 -272,41 +272,41 @@@ struct tt_local_entry
struct tt_global_entry {
    struct tt_common_entry common;
+ 	struct hlist_head orig_list;
+ 	spinlock_t list_lock;	/* protects the list */
+ 	unsigned long roam_at; /* time at which TT_GLOBAL_ROAM was set */
+ };
+ 
+ struct tt_orig_list_entry {
    struct orig_node *orig_node;
    uint8_t ttvn;
- 	unsigned long roam_at; /* time at which TT_GLOBAL_ROAM was set */
+ 	struct rcu_head rcu;
+ 	struct hlist_node list;
+ };
+ 
+ #ifdef CONFIG_BATMAN_ADV_BLA
+ struct backbone_gw {
+ 	uint8_t orig[ETH_ALEN];
+ 	short vid;		/* used VLAN ID */
+ 	struct hlist_node hash_entry;
+ 	struct bat_priv *bat_priv;
+ 	unsigned long lasttime;	/* last time we heard of this backbone gw */
+ 	atomic_t request_sent;
+ 	atomic_t refcount;
+ 	struct rcu_head rcu;
+ 	uint16_t crc;		/* crc checksum over all claims */
+ };
+ 
+ struct claim {
+ 	uint8_t addr[ETH_ALEN];
+ 	short vid;
+ 	struct backbone_gw *backbone_gw;
+ 	unsigned long lasttime;	/* last time we heard of claim (locals only) */
+ 	struct rcu_head rcu;
+ 	atomic_t refcount;
+ 	struct hlist_node hash_entry;
  };
+ #endif
struct tt_change_node {
    struct list_head list;
@@@ -327,41 -391,28 +391,28 @@@ struct recvlist_node 
    uint8_t mac[ETH_ALEN];
  };
struct bat_algo_ops {
    struct hlist_node list;
    char *name;
- 	/* init OGM when hard-interface is enabled */
- 	void (*bat_ogm_init)(struct hard_iface *hard_iface);
- 	/* init primary OGM when primary interface is selected */
- 	void (*bat_ogm_init_primary)(struct hard_iface *hard_iface);
- 	/* init mac addresses of the OGM belonging to this hard-interface */
- 	void (*bat_ogm_update_mac)(struct hard_iface *hard_iface);
+ 	/* init routing info when hard-interface is enabled */
+ 	int (*bat_iface_enable)(struct hard_iface *hard_iface);
+ 	/* de-init routing info when hard-interface is disabled */
+ 	void (*bat_iface_disable)(struct hard_iface *hard_iface);
+ 	/* (re-)init mac addresses of the protocol information
+ 	 * belonging to this hard-interface */
+ 	void (*bat_iface_update_mac)(struct hard_iface *hard_iface);
+ 	/* called when primary interface is selected / changed */
+ 	void (*bat_primary_iface_set)(struct hard_iface *hard_iface);
    /* prepare a new outgoing OGM for the send queue */
    void (*bat_ogm_schedule)(struct hard_iface *hard_iface,
    			 int tt_num_changes);
    /* send scheduled OGM */
    void (*bat_ogm_emit)(struct forw_packet *forw_packet);
- 	/* receive incoming OGM */
- 	void (*bat_ogm_receive)(struct hard_iface *if_incoming,
- 				struct sk_buff *skb);
+ };
+ 
+ struct dht_candidate {
+ 	int type;
+ 	struct orig_node *orig_node;
  };
#endif /* _NET_BATMAN_ADV_TYPES_H_ */
diff --combined net/batman-adv/unicast.c
index 676f6a6,63ab35b..63ab35b
--- a/net/batman-adv/unicast.c
+++ b/net/batman-adv/unicast.c
@@@ -283,13 -283,77 +283,77 @@@ out
    return ret;
  }
- int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv)
+ static bool pull_and_fill_unicast(struct sk_buff *skb, int hdr_size,
+ 				  struct orig_node *orig_node)
  {
- 	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
    struct unicast_packet *unicast_packet;
+ 
+ 	if (my_skb_head_push(skb, hdr_size) < 0)
+ 		return false;
+ 
+ 	unicast_packet = (struct unicast_packet *)skb->data;
+ 	unicast_packet->header.version = COMPAT_VERSION;
+ 	/* batman packet type: unicast */
+ 	unicast_packet->header.packet_type = BAT_UNICAST;
+ 	/* set unicast ttl */
+ 	unicast_packet->header.ttl = TTL;
+ 	/* copy the destination for faster routing */
+ 	memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);
+ 	/* set the destination tt version number */
+ 	unicast_packet->ttvn =
+ 		(uint8_t)atomic_read(&orig_node->last_ttvn);
+ 
+ 	return true;
+ }
+ 
+ static bool prepare_unicast_packet(struct sk_buff *skb,
+ 				   struct orig_node *orig_node)
+ {
+ 	return pull_and_fill_unicast(skb, sizeof(struct unicast_packet),
+ 				     orig_node);
+ }
+ 
+ bool prepare_unicast_4addr_packet(struct bat_priv *bat_priv,
+ 				  struct sk_buff *skb,
+ 				  struct orig_node *orig_node,
+ 				  int packet_subtype)
+ {
+ 	struct hard_iface *primary_if;
+ 	struct unicast_4addr_packet *unicast_4addr_packet;
+ 	bool ret = false;
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		goto out;
+ 
+ 	/* pull the header space and fill the unicast_packet substructure.
+ 	 * We can do that because the first member of the unicast_4addr_packet
+ 	 * is of type struct unicast_packet */
+ 	if (!pull_and_fill_unicast(skb, sizeof(*unicast_4addr_packet),
+ 				   orig_node))
+ 		goto out;
+ 
+ 	unicast_4addr_packet = (struct unicast_4addr_packet *)skb->data;
+ 	unicast_4addr_packet->u.header.packet_type = BAT_UNICAST_4ADDR;
+ 	memcpy(unicast_4addr_packet->src, primary_if->net_dev->dev_addr,
+ 	       ETH_ALEN);
+ 	unicast_4addr_packet->subtype = packet_subtype;
+ 
+ 	ret = true;
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 	return ret;
+ }
+ 
+ int unicast_generic_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
+ 			     int packet_type, int packet_subtype)
+ {
+ 	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
    struct orig_node *orig_node;
    struct neigh_node *neigh_node;
    int data_len = skb->len;
+ 	struct unicast_packet *unicast_packet;
    int ret = 1;
/* get routing information */
@@@ -303,7 -367,6 +367,6 @@@
     * returns NULL in case of AP isolation */
    orig_node = transtable_search(bat_priv, ethhdr->h_source,
    			      ethhdr->h_dest);
- 
  find_router:
    /**
     * find_router():
@@@ -311,27 -374,35 +374,35 @@@
     *  - increases neigh_nodes refcount if found.
     */
    neigh_node = find_router(bat_priv, orig_node, NULL);
    if (!neigh_node)
    	goto out;
- 	if (my_skb_head_push(skb, sizeof(*unicast_packet)) < 0)
+ 	switch (packet_type) {
+ 	case BAT_UNICAST:
+ 		prepare_unicast_packet(skb, orig_node);
+ 		break;
+ 	case BAT_UNICAST_4ADDR:
+ 		prepare_unicast_4addr_packet(bat_priv, skb, orig_node,
+ 					     packet_subtype);
+ 		break;
+ 	default:
+ 		/* this function supports UNICAST and UNICAST_4ADDR only. It
+ 		 * should never be invoked with any other packet type */
    	goto out;
+ 	}
unicast_packet = (struct unicast_packet *)skb->data;
- 	unicast_packet->header.version = COMPAT_VERSION;
- 	/* batman packet type: unicast */
- 	unicast_packet->header.packet_type = BAT_UNICAST;
- 	/* set unicast ttl */
- 	unicast_packet->header.ttl = TTL;
- 	/* copy the destination for faster routing */
- 	memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);
- 	/* set the destination tt version number */
- 	unicast_packet->ttvn =
- 		(uint8_t)atomic_read(&orig_node->last_ttvn);
+ 	/* inform the destination ode that we are still missing a correct route
+ 	 * for this client. The destination will receive this packet and will
+ 	 * try to reroute it because the ttvn contained in the header is less
+ 	 * than the current one */
+ 	if (tt_global_client_is_roaming(bat_priv, ethhdr->h_dest))
+ 		unicast_packet->ttvn = unicast_packet->ttvn - 1;
- 	if (atomic_read(&bat_priv->fragmentation) &&
+ 	/* fragmentation mechanism only works for UNICAST (now) */
+ 	if (packet_type == BAT_UNICAST &&
+ 	    atomic_read(&bat_priv->fragmentation) &&
        data_len + sizeof(*unicast_packet) >
    			neigh_node->if_incoming->net_dev->mtu) {
    	/* send frag skb decreases ttl */
@@@ -343,7 -414,6 +414,6 @@@
send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
    ret = 0;
- 	goto out;
out:
    if (neigh_node)
diff --combined net/batman-adv/unicast.h
index a9faf6b,e15aa62..e15aa62
--- a/net/batman-adv/unicast.h
+++ b/net/batman-adv/unicast.h
@@@ -30,9 -30,28 +30,28 @@@
  int frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
    		struct sk_buff **new_skb);
  void frag_list_free(struct list_head *head);
- int unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv);
  int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
    	  struct hard_iface *hard_iface, const uint8_t dstaddr[]);
+ bool prepare_unicast_4addr_packet(struct bat_priv *bat_priv,
+ 				  struct sk_buff *skb,
+ 				  struct orig_node *orig_node,
+ 				  int packet_subtype);
+ int unicast_generic_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
+ 			     int packet_type, int packet_subtype);
+ 
+ static inline int unicast_send_skb(struct sk_buff *skb,
+ 				   struct bat_priv *bat_priv)
+ {
+ 	return unicast_generic_send_skb(skb, bat_priv, BAT_UNICAST, 0);
+ }
+ 
+ static inline int unicast_4addr_send_skb(struct sk_buff *skb,
+ 					 struct bat_priv *bat_priv,
+ 					 int packet_subtype)
+ {
+ 	return unicast_generic_send_skb(skb, bat_priv, BAT_UNICAST_4ADDR,
+ 					packet_subtype);
+ }
static inline int frag_can_reassemble(const struct sk_buff *skb, int mtu)
  {
diff --combined net/batman-adv/vis.c
index c4a5b8c,cec216f..cec216f
--- a/net/batman-adv/vis.c
+++ b/net/batman-adv/vis.c
@@@ -434,12 -434,12 +434,12 @@@ static struct vis_info *add_packet(stru
    	return NULL;
info->skb_packet = dev_alloc_skb(sizeof(*packet) + vis_info_len +
- 					 sizeof(struct ethhdr));
+ 					 ETH_HLEN);
    if (!info->skb_packet) {
    	kfree(info);
    	return NULL;
    }
- 	skb_reserve(info->skb_packet, sizeof(struct ethhdr));
+ 	skb_reserve(info->skb_packet, ETH_HLEN);
    packet = (struct vis_packet *)skb_put(info->skb_packet, sizeof(*packet)
    				      + vis_info_len);
@@@ -894,11 -894,11 +894,11 @@@ int vis_init(struct bat_priv *bat_priv
bat_priv->my_vis_info->skb_packet = dev_alloc_skb(sizeof(*packet) +
    						  MAX_VIS_PACKET_SIZE +
- 							 sizeof(struct ethhdr));
+ 							  ETH_HLEN);
    if (!bat_priv->my_vis_info->skb_packet)
    	goto free_info;
- 	skb_reserve(bat_priv->my_vis_info->skb_packet, sizeof(struct ethhdr));
+ 	skb_reserve(bat_priv->my_vis_info->skb_packet, ETH_HLEN);
    packet = (struct vis_packet *)skb_put(bat_priv->my_vis_info->skb_packet,
    				      sizeof(*packet));
-- 
linux integration

    