[commits] linux integration; branch, merge/master, updated. v3.1-rc1-1105-g7ff4216

8 Sep 2011

The following commit has been merged in the merge/master branch:
commit 7ff421630feba9d4bcf18cbb8e08ad2f31dd91aa
Merge: 12416fb4ec358e36c4e47456e98ca72a5fb90f10 89526f54915deb7158520907d2d70fac9b2cd694
Author: Marek Lindner lindner_marek@yahoo.de
Date:   Wed Aug 31 17:47:22 2011 +0200
Merge remote-tracking branch 'origin/standalone/next' into merge/master
Conflicts:
    	net/batman-adv/CHANGELOG
    	net/batman-adv/Makefile.kbuild
    	net/batman-adv/README
    	net/batman-adv/compat.c
    	net/batman-adv/compat.h
    	net/batman-adv/sysfs-class-net-mesh
diff --combined Documentation/ABI/testing/sysfs-class-net-mesh
index 748fe17,b020014..b020014

--- a/Documentation/ABI/testing/sysfs-class-net-mesh
+++ b/Documentation/ABI/testing/sysfs-class-net-mesh
@@@ -22,6 -22,14 +22,14 @@@ Description
                  mesh will be fragmented or silently discarded if the
                  packet size exceeds the outgoing interface MTU.
+ What:		/sys/class/net/<mesh_iface>/mesh/ap_isolation
+ Date:		May 2011
+ Contact:	Antonio Quartulli ordex@autistici.org
+ Description:
+ 		Indicates whether the data traffic going from a
+ 		wireless client to another wireless client will be
+ 		silently dropped.
+ 
  What:           /sys/class/net/<mesh_iface>/mesh/gw_bandwidth
  Date:           October 2010
  Contact:        Marek Lindner lindner_marek@yahoo.de
diff --combined Documentation/networking/batman-adv.txt
index 88d4afb,0000000..9b13424
mode 100644,000000..100644
--- a/Documentation/networking/batman-adv.txt
+++ b/Documentation/networking/batman-adv.txt
@@@ -1,241 -1,0 +1,241 @@@
 +[state: 17-04-2011]
 +
 +BATMAN-ADV
 +----------
 +
 +Batman  advanced  is  a new approach to wireless networking which
 +does no longer operate on the IP basis. Unlike the batman daemon,
 +which  exchanges  information  using UDP packets and sets routing
 +tables, batman-advanced operates on ISO/OSI Layer 2 only and uses
 +and  routes  (or  better: bridges) Ethernet Frames. It emulates a
 +virtual network switch of all nodes participating.  Therefore all
 +nodes  appear  to be link local, thus all higher operating proto-
 +cols won't be affected by any changes within the network. You can
 +run almost any protocol above batman advanced, prominent examples
 +are: IPv4, IPv6, DHCP, IPX.
 +
 +Batman advanced was implemented as a Linux kernel driver  to  re-
 +duce the overhead to a minimum. It does not depend on any (other)
 +network driver, and can be used on wifi as well as ethernet  lan,
 +vpn,  etc ... (anything with ethernet-style layer 2).
 +
 +
 +CONFIGURATION
 +-------------
 +
 +Load the batman-adv module into your kernel:
 +
 +# insmod batman-adv.ko
 +
 +The  module  is now waiting for activation. You must add some in-
 +terfaces on which batman can operate. After  loading  the  module
 +batman  advanced  will scan your systems interfaces to search for
 +compatible interfaces. Once found, it will create  subfolders  in
 +the /sys directories of each supported interface, e.g.
 +
 +# ls /sys/class/net/eth0/batman_adv/
 +# iface_status  mesh_iface
 +
 +If an interface does not have the "batman_adv" subfolder it prob-
 +ably is not supported. Not supported  interfaces  are:  loopback,
 +non-ethernet and batman's own interfaces.
 +
 +Note:  After the module was loaded it will continuously watch for
 +new interfaces to verify the compatibility. There is no  need  to
 +reload the module if you plug your USB wifi adapter into your ma-
 +chine after batman advanced was initially loaded.
 +
 +To activate a  given  interface  simply  write  "bat0"  into  its
 +"mesh_iface" file inside the batman_adv subfolder:
 +
 +# echo bat0 > /sys/class/net/eth0/batman_adv/mesh_iface
 +
 +Repeat  this step for all interfaces you wish to add.  Now batman
 +starts using/broadcasting on this/these interface(s).
 +
 +By reading the "iface_status" file you can check its status:
 +
 +# cat /sys/class/net/eth0/batman_adv/iface_status
 +# active
 +
 +To deactivate an interface you have  to  write  "none"  into  its
 +"mesh_iface" file:
 +
 +# echo none > /sys/class/net/eth0/batman_adv/mesh_iface
 +
 +
 +All  mesh  wide  settings  can be found in batman's own interface
 +folder:
 +
 +#  ls  /sys/class/net/bat0/mesh/
- #  aggregated_ogms  gw_bandwidth  hop_penalty
- #  bonding          gw_mode       orig_interval
- #  fragmentation    gw_sel_class  vis_mode
++# aggregated_ogms   fragmentation gw_sel_class   vis_mode
++# ap_isolation      gw_bandwidth  hop_penalty
++# bonding           gw_mode       orig_interval
 +
 +
 +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
 +
 +
 +Some of the files contain all sort of status information  regard-
 +ing  the  mesh  network.  For  example, you can view the table of
 +originators (mesh participants) with:
 +
 +# cat /sys/kernel/debug/batman_adv/bat0/originators
 +
 +Other files allow to change batman's behaviour to better fit your
 +requirements.  For instance, you can check the current originator
 +interval (value in milliseconds which determines how often batman
 +sends its broadcast packets):
 +
 +# cat /sys/class/net/bat0/mesh/orig_interval
 +# 1000
 +
 +and also change its value:
 +
 +# echo 3000 > /sys/class/net/bat0/mesh/orig_interval
 +
 +In very mobile scenarios, you might want to adjust the originator
 +interval to a lower value. This will make the mesh  more  respon-
 +sive to topology changes, but will also increase the overhead.
 +
 +
 +USAGE
 +-----
 +
 +To  make use of your newly created mesh, batman advanced provides
 +a new interface "bat0" which you should use from this  point  on.
 +All  interfaces  added  to  batman  advanced are not relevant any
 +longer because batman handles them for you. Basically, one "hands
 +over" the data by using the batman interface and batman will make
 +sure it reaches its destination.
 +
 +The "bat0" interface can be used like any  other  regular  inter-
 +face.  It needs an IP address which can be either statically con-
 +figured or dynamically (by using DHCP or similar services):
 +
 +# NodeA: ifconfig bat0 192.168.0.1
 +# NodeB: ifconfig bat0 192.168.0.2
 +# NodeB: ping 192.168.0.1
 +
 +Note:  In  order to avoid problems remove all IP addresses previ-
 +ously assigned to interfaces now used by batman advanced, e.g.
 +
 +# ifconfig eth0 0.0.0.0
 +
 +
 +VISUALIZATION
 +-------------
 +
 +If you want topology visualization, at least one mesh  node  must
 +be configured as VIS-server:
 +
 +# echo "server" > /sys/class/net/bat0/mesh/vis_mode
 +
 +Each  node  is  either configured as "server" or as "client" (de-
 +fault: "client").  Clients send their topology data to the server
 +next to them, and server synchronize with other servers. If there
 +is no server configured (default) within the  mesh,  no  topology
 +information   will  be  transmitted.  With  these  "synchronizing
 +servers", there can be 1 or more vis servers sharing the same (or
 +at least very similar) data.
 +
 +When  configured  as  server,  you can get a topology snapshot of
 +your mesh:
 +
 +# cat /sys/kernel/debug/batman_adv/bat0/vis_data
 +
 +This raw output is intended to be easily parsable and convertable
 +with  other tools. Have a look at the batctl README if you want a
 +vis output in dot or json format for instance and how those  out-
 +puts could then be visualised in an image.
 +
 +The raw format consists of comma separated values per entry where
 +each entry is giving information about a  certain  source  inter-
 +face.  Each  entry can/has to have the following values:
 +-> "mac" - mac address of an originator's source interface
 +           (each line begins with it)
 +-> "TQ mac  value"  -  src mac's link quality towards mac address
 +                       of a neighbor originator's interface which
 +                       is being used for routing
 +-> "TT mac" - TT announced by source mac
 +-> "PRIMARY" - this  is a primary interface
 +-> "SEC mac" - secondary mac address of source
 +               (requires preceding PRIMARY)
 +
 +The TQ value has a range from 4 to 255 with 255 being  the  best.
 +The TT entries are showing which hosts are connected to the mesh
 +via bat0 or being bridged into the mesh network.  The PRIMARY/SEC
 +values are only applied on primary interfaces
 +
 +
 +LOGGING/DEBUGGING
 +-----------------
 +
 +All error messages, warnings and information messages are sent to
 +the kernel log. Depending on your operating  system  distribution
 +this  can  be read in one of a number of ways. Try using the com-
 +mands: dmesg, logread, or looking in the files  /var/log/kern.log
 +or  /var/log/syslog.  All  batman-adv  messages are prefixed with
 +"batman-adv:" So to see just these messages try
 +
 +# dmesg | grep batman-adv
 +
 +When investigating problems with your mesh network  it  is  some-
 +times  necessary  to see more detail debug messages. This must be
 +enabled when compiling the batman-adv module. When building  bat-
 +man-adv  as  part of kernel, use "make menuconfig" and enable the
 +option "B.A.T.M.A.N. debugging".
 +
 +Those additional  debug messages can be accessed  using a special
 +file in debugfs
 +
 +# cat /sys/kernel/debug/batman_adv/bat0/log
 +
 +The additional debug output is by default disabled. It can be en-
 +abled  during run time. Following log_levels are defined:
 +
 +0 - All  debug  output  disabled
 +1 - Enable messages related to routing / flooding / broadcasting
 +2 - Enable route or tt entry added / changed / deleted
 +3 - 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
 +
 +will enable debug messages for when routes or TTs change.
 +
 +
 +BATCTL
 +------
 +
 +As batman advanced operates on layer 2 all hosts participating in
 +the  virtual switch are completely transparent for all  protocols
 +above layer 2. Therefore the common diagnosis tools do  not  work
 +as  expected.  To  overcome these problems batctl was created. At
 +the  moment the  batctl contains ping,  traceroute,  tcpdump  and
 +interfaces to the kernel module settings.
 +
 +For more information, please see the manpage (man batctl).
 +
 +batctl is available on http://www.open-mesh.org/
 +
 +
 +CONTACT
 +-------
 +
 +Please send us comments, experiences, questions, anything :)
 +
 +IRC:            #batman   on   irc.freenode.org
 +Mailing-list:   b.a.t.m.a.n@open-mesh.org (optional  subscription
 +          at https://lists.open-mesh.org/mm/listinfo/b.a.t.m.a.n)
 +
 +You can also contact the Authors:
 +
 +Marek  Lindner  lindner_marek@yahoo.de
 +Simon  Wunderlich  siwu@hrz.tu-chemnitz.de
diff --combined net/batman-adv/Makefile
index 2de93d0,0000000..ce68611
mode 100644,000000..100644
--- a/net/batman-adv/Makefile
+++ b/net/batman-adv/Makefile
@@@ -1,39 -1,0 +1,39 @@@
 +#
 +# Copyright (C) 2007-2011 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
 +#
 +
 +obj-$(CONFIG_BATMAN_ADV) += batman-adv.o
- batman-adv-y += aggregation.o
 +batman-adv-y += bat_debugfs.o
++batman-adv-y += bat_iv_ogm.o
 +batman-adv-y += bat_sysfs.o
 +batman-adv-y += bitarray.o
 +batman-adv-y += gateway_client.o
 +batman-adv-y += gateway_common.o
 +batman-adv-y += hard-interface.o
 +batman-adv-y += hash.o
 +batman-adv-y += icmp_socket.o
 +batman-adv-y += main.o
 +batman-adv-y += originator.o
 +batman-adv-y += ring_buffer.o
 +batman-adv-y += routing.o
 +batman-adv-y += send.o
 +batman-adv-y += soft-interface.o
 +batman-adv-y += translation-table.o
 +batman-adv-y += unicast.o
 +batman-adv-y += vis.o
diff --combined net/batman-adv/bat_iv_ogm.c
index 0000000,3512e25..3512e25
mode 000000,100644..100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@@ -1,0 -1,1170 +1,1170 @@@
+ /*
+  * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
+  *
+  * Marek Lindner, Simon Wunderlich
+  *
+  * This program is free software; you can redistribute it and/or
+  * modify it under the terms of version 2 of the GNU General Public
+  * License as published by the Free Software Foundation.
+  *
+  * This program is distributed in the hope that it will be useful, but
+  * WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  * General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License
+  * along with this program; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+  * 02110-1301, USA
+  *
+  */
+ 
+ #include "main.h"
+ #include "bat_ogm.h"
+ #include "translation-table.h"
+ #include "ring_buffer.h"
+ #include "originator.h"
+ #include "routing.h"
+ #include "gateway_common.h"
+ #include "gateway_client.h"
+ #include "hard-interface.h"
+ #include "send.h"
+ 
+ void bat_ogm_init(struct hard_iface *hard_iface)
+ {
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 
+ 	hard_iface->packet_len = BATMAN_OGM_LEN;
+ 	hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC);
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
+ 	batman_ogm_packet->packet_type = BAT_OGM;
+ 	batman_ogm_packet->version = COMPAT_VERSION;
+ 	batman_ogm_packet->flags = NO_FLAGS;
+ 	batman_ogm_packet->ttl = 2;
+ 	batman_ogm_packet->tq = TQ_MAX_VALUE;
+ 	batman_ogm_packet->tt_num_changes = 0;
+ 	batman_ogm_packet->ttvn = 0;
+ }
+ 
+ void bat_ogm_init_primary(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->ttl = TTL;
+ }
+ 
+ void bat_ogm_update_mac(struct hard_iface *hard_iface)
+ {
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
+ 	memcpy(batman_ogm_packet->orig,
+ 	       hard_iface->net_dev->dev_addr, ETH_ALEN);
+ 	memcpy(batman_ogm_packet->prev_sender,
+ 	       hard_iface->net_dev->dev_addr, ETH_ALEN);
+ }
+ 
+ /* when do we schedule our own ogm to be sent */
+ static unsigned long bat_ogm_emit_send_time(const struct bat_priv *bat_priv)
+ {
+ 	return jiffies + msecs_to_jiffies(
+ 		   atomic_read(&bat_priv->orig_interval) -
+ 		   JITTER + (random32() % 2*JITTER));
+ }
+ 
+ /* when do we schedule a ogm packet to be sent */
+ static unsigned long bat_ogm_fwd_send_time(void)
+ {
+ 	return jiffies + msecs_to_jiffies(random32() % (JITTER/2));
+ }
+ 
+ /* apply hop penalty for a normal link */
+ static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
+ {
+ 	int hop_penalty = atomic_read(&bat_priv->hop_penalty);
+ 	return (tq * (TQ_MAX_VALUE - hop_penalty)) / (TQ_MAX_VALUE);
+ }
+ 
+ /* is there another aggregated packet here? */
+ static int bat_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);
+ 
+ 	return (next_buff_pos <= packet_len) &&
+ 		(next_buff_pos <= MAX_AGGREGATION_BYTES);
+ }
+ 
+ /* send a batman ogm to a given interface */
+ static void bat_ogm_send_to_if(struct forw_packet *forw_packet,
+ 			       struct hard_iface *hard_iface)
+ {
+ 	struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
+ 	char *fwd_str;
+ 	uint8_t packet_num;
+ 	int16_t buff_pos;
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	struct sk_buff *skb;
+ 
+ 	if (hard_iface->if_status != IF_ACTIVE)
+ 		return;
+ 
+ 	packet_num = 0;
+ 	buff_pos = 0;
+ 	batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;
+ 
+ 	/* adjust all flags and log packets */
+ 	while (bat_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
+ 				   batman_ogm_packet->tt_num_changes)) {
+ 
+ 		/* we might have aggregated direct link packets with an
+ 		 * ordinary base packet */
+ 		if ((forw_packet->direct_link_flags & (1 << packet_num)) &&
+ 		    (forw_packet->if_incoming == hard_iface))
+ 			batman_ogm_packet->flags |= DIRECTLINK;
+ 		else
+ 			batman_ogm_packet->flags &= ~DIRECTLINK;
+ 
+ 		fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
+ 							    "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",
+ 			fwd_str, (packet_num > 0 ? "aggregated " : ""),
+ 			batman_ogm_packet->orig,
+ 			ntohl(batman_ogm_packet->seqno),
+ 			batman_ogm_packet->tq, batman_ogm_packet->ttl,
+ 			(batman_ogm_packet->flags & DIRECTLINK ?
+ 			 "on" : "off"),
+ 			batman_ogm_packet->ttvn, hard_iface->net_dev->name,
+ 			hard_iface->net_dev->dev_addr);
+ 
+ 		buff_pos += BATMAN_OGM_LEN +
+ 				tt_len(batman_ogm_packet->tt_num_changes);
+ 		packet_num++;
+ 		batman_ogm_packet = (struct batman_ogm_packet *)
+ 					(forw_packet->skb->data + buff_pos);
+ 	}
+ 
+ 	/* create clone because function is called more than once */
+ 	skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
+ 	if (skb)
+ 		send_skb_packet(skb, hard_iface, broadcast_addr);
+ }
+ 
+ /* send a batman ogm packet */
+ void bat_ogm_emit(struct forw_packet *forw_packet)
+ {
+ 	struct hard_iface *hard_iface;
+ 	struct net_device *soft_iface;
+ 	struct bat_priv *bat_priv;
+ 	struct hard_iface *primary_if = NULL;
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	unsigned char directlink;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)
+ 						(forw_packet->skb->data);
+ 	directlink = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);
+ 
+ 	if (!forw_packet->if_incoming) {
+ 		pr_err("Error - can't forward packet: incoming iface not "
+ 		       "specified\n");
+ 		goto out;
+ 	}
+ 
+ 	soft_iface = forw_packet->if_incoming->soft_iface;
+ 	bat_priv = netdev_priv(soft_iface);
+ 
+ 	if (forw_packet->if_incoming->if_status != IF_ACTIVE)
+ 		goto out;
+ 
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 	if (!primary_if)
+ 		goto out;
+ 
+ 	/* multihomed peer assumed */
+ 	/* non-primary OGMs are only broadcasted on their interface */
+ 	if ((directlink && (batman_ogm_packet->ttl == 1)) ||
+ 	    (forw_packet->own && (forw_packet->if_incoming != primary_if))) {
+ 
+ 		/* FIXME: what about aggregated packets ? */
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"%s packet (originator %pM, seqno %d, TTL %d) "
+ 			"on interface %s [%pM]\n",
+ 			(forw_packet->own ? "Sending own" : "Forwarding"),
+ 			batman_ogm_packet->orig,
+ 			ntohl(batman_ogm_packet->seqno),
+ 			batman_ogm_packet->ttl,
+ 			forw_packet->if_incoming->net_dev->name,
+ 			forw_packet->if_incoming->net_dev->dev_addr);
+ 
+ 		/* skb is only used once and than forw_packet is free'd */
+ 		send_skb_packet(forw_packet->skb, forw_packet->if_incoming,
+ 				broadcast_addr);
+ 		forw_packet->skb = NULL;
+ 
+ 		goto out;
+ 	}
+ 
+ 	/* broadcast on every interface */
+ 	rcu_read_lock();
+ 	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
+ 		if (hard_iface->soft_iface != soft_iface)
+ 			continue;
+ 
+ 		bat_ogm_send_to_if(forw_packet, hard_iface);
+ 	}
+ 	rcu_read_unlock();
+ 
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ }
+ 
+ /* return true if new_packet can be aggregated with forw_packet */
+ static bool bat_ogm_can_aggregate(const struct batman_ogm_packet
+ 							*new_batman_ogm_packet,
+ 				  struct bat_priv *bat_priv,
+ 				  int packet_len, unsigned long send_time,
+ 				  bool directlink,
+ 				  const struct hard_iface *if_incoming,
+ 				  const struct forw_packet *forw_packet)
+ {
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	int aggregated_bytes = forw_packet->packet_len + packet_len;
+ 	struct hard_iface *primary_if = NULL;
+ 	bool res = false;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;
+ 
+ 	/**
+ 	 * we can aggregate the current packet to this aggregated packet
+ 	 * if:
+ 	 *
+ 	 * - the send time is within our MAX_AGGREGATION_MS time
+ 	 * - the resulting packet wont be bigger than
+ 	 *   MAX_AGGREGATION_BYTES
+ 	 */
+ 
+ 	if (time_before(send_time, forw_packet->send_time) &&
+ 	    time_after_eq(send_time + msecs_to_jiffies(MAX_AGGREGATION_MS),
+ 					forw_packet->send_time) &&
+ 	    (aggregated_bytes <= MAX_AGGREGATION_BYTES)) {
+ 
+ 		/**
+ 		 * check aggregation compatibility
+ 		 * -> direct link packets are broadcasted on
+ 		 *    their interface only
+ 		 * -> aggregate packet if the current packet is
+ 		 *    a "global" packet as well as the base
+ 		 *    packet
+ 		 */
+ 
+ 		primary_if = primary_if_get_selected(bat_priv);
+ 		if (!primary_if)
+ 			goto out;
+ 
+ 		/* packets without direct link flag and high TTL
+ 		 * are flooded through the net  */
+ 		if ((!directlink) &&
+ 		    (!(batman_ogm_packet->flags & DIRECTLINK)) &&
+ 		    (batman_ogm_packet->ttl != 1) &&
+ 
+ 		    /* own packets originating non-primary
+ 		     * interfaces leave only that interface */
+ 		    ((!forw_packet->own) ||
+ 		     (forw_packet->if_incoming == primary_if))) {
+ 			res = true;
+ 			goto out;
+ 		}
+ 
+ 		/* if the incoming packet is sent via this one
+ 		 * interface only - we still can aggregate */
+ 		if ((directlink) &&
+ 		    (new_batman_ogm_packet->ttl == 1) &&
+ 		    (forw_packet->if_incoming == if_incoming) &&
+ 
+ 		    /* packets from direct neighbors or
+ 		     * own secondary interface packets
+ 		     * (= secondary interface packets in general) */
+ 		    (batman_ogm_packet->flags & DIRECTLINK ||
+ 		     (forw_packet->own &&
+ 		      forw_packet->if_incoming != primary_if))) {
+ 			res = true;
+ 			goto out;
+ 		}
+ 	}
+ 
+ out:
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ 	return res;
+ }
+ 
+ /* create a new aggregated packet and add this packet to it */
+ static void bat_ogm_aggregate_new(const unsigned char *packet_buff,
+ 				  int packet_len, unsigned long send_time,
+ 				  bool direct_link,
+ 				  struct hard_iface *if_incoming,
+ 				  int own_packet)
+ {
+ 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
+ 	struct forw_packet *forw_packet_aggr;
+ 	unsigned char *skb_buff;
+ 
+ 	if (!atomic_inc_not_zero(&if_incoming->refcount))
+ 		return;
+ 
+ 	/* own packet should always be scheduled */
+ 	if (!own_packet) {
+ 		if (!atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
+ 			bat_dbg(DBG_BATMAN, bat_priv,
+ 				"batman packet queue full\n");
+ 			goto out;
+ 		}
+ 	}
+ 
+ 	forw_packet_aggr = kmalloc(sizeof(*forw_packet_aggr), GFP_ATOMIC);
+ 	if (!forw_packet_aggr) {
+ 		if (!own_packet)
+ 			atomic_inc(&bat_priv->batman_queue_left);
+ 		goto out;
+ 	}
+ 
+ 	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));
+ 	else
+ 		forw_packet_aggr->skb = dev_alloc_skb(packet_len +
+ 						      sizeof(struct ethhdr));
+ 
+ 	if (!forw_packet_aggr->skb) {
+ 		if (!own_packet)
+ 			atomic_inc(&bat_priv->batman_queue_left);
+ 		kfree(forw_packet_aggr);
+ 		goto out;
+ 	}
+ 	skb_reserve(forw_packet_aggr->skb, sizeof(struct ethhdr));
+ 
+ 	INIT_HLIST_NODE(&forw_packet_aggr->list);
+ 
+ 	skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
+ 	forw_packet_aggr->packet_len = packet_len;
+ 	memcpy(skb_buff, packet_buff, packet_len);
+ 
+ 	forw_packet_aggr->own = own_packet;
+ 	forw_packet_aggr->if_incoming = if_incoming;
+ 	forw_packet_aggr->num_packets = 0;
+ 	forw_packet_aggr->direct_link_flags = NO_FLAGS;
+ 	forw_packet_aggr->send_time = send_time;
+ 
+ 	/* save packet direct link flag status */
+ 	if (direct_link)
+ 		forw_packet_aggr->direct_link_flags |= 1;
+ 
+ 	/* add new packet to packet list */
+ 	spin_lock_bh(&bat_priv->forw_bat_list_lock);
+ 	hlist_add_head(&forw_packet_aggr->list, &bat_priv->forw_bat_list);
+ 	spin_unlock_bh(&bat_priv->forw_bat_list_lock);
+ 
+ 	/* start timer for this packet */
+ 	INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
+ 			  send_outstanding_bat_ogm_packet);
+ 	queue_delayed_work(bat_event_workqueue,
+ 			   &forw_packet_aggr->delayed_work,
+ 			   send_time - jiffies);
+ 
+ 	return;
+ out:
+ 	hardif_free_ref(if_incoming);
+ }
+ 
+ /* aggregate a new packet into the existing ogm packet */
+ static void bat_ogm_aggregate(struct forw_packet *forw_packet_aggr,
+ 			      const unsigned char *packet_buff,
+ 			      int packet_len, bool direct_link)
+ {
+ 	unsigned char *skb_buff;
+ 
+ 	skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
+ 	memcpy(skb_buff, packet_buff, packet_len);
+ 	forw_packet_aggr->packet_len += packet_len;
+ 	forw_packet_aggr->num_packets++;
+ 
+ 	/* save packet direct link flag status */
+ 	if (direct_link)
+ 		forw_packet_aggr->direct_link_flags |=
+ 			(1 << forw_packet_aggr->num_packets);
+ }
+ 
+ static void bat_ogm_queue_add(struct bat_priv *bat_priv,
+ 			      unsigned char *packet_buff,
+ 			      int packet_len, struct hard_iface *if_incoming,
+ 			      int own_packet, unsigned long send_time)
+ {
+ 	/**
+ 	 * _aggr -> pointer to the packet we want to aggregate with
+ 	 * _pos -> pointer to the position in the queue
+ 	 */
+ 	struct forw_packet *forw_packet_aggr = NULL, *forw_packet_pos = NULL;
+ 	struct hlist_node *tmp_node;
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	bool direct_link;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)packet_buff;
+ 	direct_link = batman_ogm_packet->flags & DIRECTLINK ? 1 : 0;
+ 
+ 	/* find position for the packet in the forward queue */
+ 	spin_lock_bh(&bat_priv->forw_bat_list_lock);
+ 	/* own packets are not to be aggregated */
+ 	if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) {
+ 		hlist_for_each_entry(forw_packet_pos, tmp_node,
+ 				     &bat_priv->forw_bat_list, list) {
+ 			if (bat_ogm_can_aggregate(batman_ogm_packet,
+ 						  bat_priv, packet_len,
+ 						  send_time, direct_link,
+ 						  if_incoming,
+ 						  forw_packet_pos)) {
+ 				forw_packet_aggr = forw_packet_pos;
+ 				break;
+ 			}
+ 		}
+ 	}
+ 
+ 	/* nothing to aggregate with - either aggregation disabled or no
+ 	 * suitable aggregation packet found */
+ 	if (!forw_packet_aggr) {
+ 		/* the following section can run without the lock */
+ 		spin_unlock_bh(&bat_priv->forw_bat_list_lock);
+ 
+ 		/**
+ 		 * if we could not aggregate this packet with one of the others
+ 		 * we hold it back for a while, so that it might be aggregated
+ 		 * later on
+ 		 */
+ 		if ((!own_packet) &&
+ 		    (atomic_read(&bat_priv->aggregated_ogms)))
+ 			send_time += msecs_to_jiffies(MAX_AGGREGATION_MS);
+ 
+ 		bat_ogm_aggregate_new(packet_buff, packet_len,
+ 				      send_time, direct_link,
+ 				      if_incoming, own_packet);
+ 	} else {
+ 		bat_ogm_aggregate(forw_packet_aggr, packet_buff, packet_len,
+ 				  direct_link);
+ 		spin_unlock_bh(&bat_priv->forw_bat_list_lock);
+ 	}
+ }
+ 
+ static void bat_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)
+ {
+ 	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->ttl <= 1) {
+ 		bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
+ 		return;
+ 	}
+ 
+ 	router = orig_node_get_router(orig_node);
+ 
+ 	in_tq = batman_ogm_packet->tq;
+ 	in_ttl = batman_ogm_packet->ttl;
+ 	tt_num_changes = batman_ogm_packet->tt_num_changes;
+ 
+ 	batman_ogm_packet->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->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->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)
+ 		batman_ogm_packet->flags |= DIRECTLINK;
+ 	else
+ 		batman_ogm_packet->flags &= ~DIRECTLINK;
+ 
+ 	bat_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
+ 			  BATMAN_OGM_LEN + tt_len(tt_num_changes),
+ 			  if_incoming, 0, bat_ogm_fwd_send_time());
+ }
+ 
+ void bat_ogm_schedule(struct hard_iface *hard_iface, int tt_num_changes)
+ {
+ 	struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	struct hard_iface *primary_if;
+ 	int vis_server;
+ 
+ 	vis_server = atomic_read(&bat_priv->vis_mode);
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
+ 
+ 	/* change sequence number to network order */
+ 	batman_ogm_packet->seqno =
+ 			htonl((uint32_t)atomic_read(&hard_iface->seqno));
+ 
+ 	batman_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn);
+ 	batman_ogm_packet->tt_crc = htons((uint16_t)
+ 						atomic_read(&bat_priv->tt_crc));
+ 	if (tt_num_changes >= 0)
+ 		batman_ogm_packet->tt_num_changes = tt_num_changes;
+ 
+ 	if (vis_server == VIS_TYPE_SERVER_SYNC)
+ 		batman_ogm_packet->flags |= VIS_SERVER;
+ 	else
+ 		batman_ogm_packet->flags &= ~VIS_SERVER;
+ 
+ 	if ((hard_iface == primary_if) &&
+ 	    (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER))
+ 		batman_ogm_packet->gw_flags =
+ 				(uint8_t)atomic_read(&bat_priv->gw_bandwidth);
+ 	else
+ 		batman_ogm_packet->gw_flags = NO_FLAGS;
+ 
+ 	atomic_inc(&hard_iface->seqno);
+ 
+ 	slide_own_bcast_window(hard_iface);
+ 	bat_ogm_queue_add(bat_priv, hard_iface->packet_buff,
+ 			  hard_iface->packet_len, hard_iface, 1,
+ 			  bat_ogm_emit_send_time(bat_priv));
+ 
+ 	if (primary_if)
+ 		hardif_free_ref(primary_if);
+ }
+ 
+ static void bat_ogm_orig_update(struct bat_priv *bat_priv,
+ 				struct orig_node *orig_node,
+ 				const struct ethhdr *ethhdr,
+ 				const struct batman_ogm_packet
+ 							*batman_ogm_packet,
+ 				struct hard_iface *if_incoming,
+ 				const unsigned char *tt_buff, int is_duplicate)
+ {
+ 	struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
+ 	struct neigh_node *router = NULL;
+ 	struct orig_node *orig_node_tmp;
+ 	struct hlist_node *node;
+ 	uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
+ 
+ 	bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): "
+ 		"Searching and updating originator entry of received packet\n");
+ 
+ 	rcu_read_lock();
+ 	hlist_for_each_entry_rcu(tmp_neigh_node, node,
+ 				 &orig_node->neigh_list, list) {
+ 		if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
+ 		    (tmp_neigh_node->if_incoming == if_incoming) &&
+ 		     atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
+ 			if (neigh_node)
+ 				neigh_node_free_ref(neigh_node);
+ 			neigh_node = tmp_neigh_node;
+ 			continue;
+ 		}
+ 
+ 		if (is_duplicate)
+ 			continue;
+ 
+ 		spin_lock_bh(&tmp_neigh_node->tq_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);
+ 	}
+ 
+ 	if (!neigh_node) {
+ 		struct orig_node *orig_tmp;
+ 
+ 		orig_tmp = get_orig_node(bat_priv, ethhdr->h_source);
+ 		if (!orig_tmp)
+ 			goto unlock;
+ 
+ 		neigh_node = create_neighbor(orig_node, orig_tmp,
+ 					     ethhdr->h_source, if_incoming);
+ 
+ 		orig_node_free_ref(orig_tmp);
+ 		if (!neigh_node)
+ 			goto unlock;
+ 	} else
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Updating existing last-hop neighbor of originator\n");
+ 
+ 	rcu_read_unlock();
+ 
+ 	orig_node->flags = batman_ogm_packet->flags;
+ 	neigh_node->last_valid = jiffies;
+ 
+ 	spin_lock_bh(&neigh_node->tq_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);
+ 
+ 	if (!is_duplicate) {
+ 		orig_node->last_ttl = batman_ogm_packet->ttl;
+ 		neigh_node->last_ttl = batman_ogm_packet->ttl;
+ 	}
+ 
+ 	bonding_candidate_add(orig_node, neigh_node);
+ 
+ 	/* if this neighbor already is our next hop there is nothing
+ 	 * to change */
+ 	router = orig_node_get_router(orig_node);
+ 	if (router == neigh_node)
+ 		goto update_tt;
+ 
+ 	/* if this neighbor does not offer a better TQ we won't consider it */
+ 	if (router && (router->tq_avg > neigh_node->tq_avg))
+ 		goto update_tt;
+ 
+ 	/* if the TQ is the same and the link not more symmetric we
+ 	 * won't consider it either */
+ 	if (router && (neigh_node->tq_avg == router->tq_avg)) {
+ 		orig_node_tmp = router->orig_node;
+ 		spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
+ 		bcast_own_sum_orig =
+ 			orig_node_tmp->bcast_own_sum[if_incoming->if_num];
+ 		spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
+ 
+ 		orig_node_tmp = neigh_node->orig_node;
+ 		spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
+ 		bcast_own_sum_neigh =
+ 			orig_node_tmp->bcast_own_sum[if_incoming->if_num];
+ 		spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
+ 
+ 		if (bcast_own_sum_orig >= bcast_own_sum_neigh)
+ 			goto update_tt;
+ 	}
+ 
+ 	update_route(bat_priv, orig_node, neigh_node);
+ 
+ update_tt:
+ 	/* I have to check for transtable changes only if the OGM has been
+ 	 * sent through a primary interface */
+ 	if (((batman_ogm_packet->orig != ethhdr->h_source) &&
+ 	     (batman_ogm_packet->ttl > 2)) ||
+ 	    (batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
+ 		tt_update_orig(bat_priv, orig_node, tt_buff,
+ 			       batman_ogm_packet->tt_num_changes,
+ 			       batman_ogm_packet->ttvn,
+ 			       batman_ogm_packet->tt_crc);
+ 
+ 	if (orig_node->gw_flags != batman_ogm_packet->gw_flags)
+ 		gw_node_update(bat_priv, orig_node,
+ 			       batman_ogm_packet->gw_flags);
+ 
+ 	orig_node->gw_flags = batman_ogm_packet->gw_flags;
+ 
+ 	/* restart gateway selection if fast or late switching was enabled */
+ 	if ((orig_node->gw_flags) &&
+ 	    (atomic_read(&bat_priv->gw_mode) == GW_MODE_CLIENT) &&
+ 	    (atomic_read(&bat_priv->gw_sel_class) > 2))
+ 		gw_check_election(bat_priv, orig_node);
+ 
+ 	goto out;
+ 
+ unlock:
+ 	rcu_read_unlock();
+ out:
+ 	if (neigh_node)
+ 		neigh_node_free_ref(neigh_node);
+ 	if (router)
+ 		neigh_node_free_ref(router);
+ }
+ 
+ static int bat_ogm_calc_tq(struct orig_node *orig_node,
+ 			   struct orig_node *orig_neigh_node,
+ 			   struct batman_ogm_packet *batman_ogm_packet,
+ 			   struct hard_iface *if_incoming)
+ {
+ 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
+ 	struct neigh_node *neigh_node = NULL, *tmp_neigh_node;
+ 	struct hlist_node *node;
+ 	uint8_t total_count;
+ 	uint8_t orig_eq_count, neigh_rq_count, tq_own;
+ 	int tq_asym_penalty, ret = 0;
+ 
+ 	/* find corresponding one hop neighbor */
+ 	rcu_read_lock();
+ 	hlist_for_each_entry_rcu(tmp_neigh_node, node,
+ 				 &orig_neigh_node->neigh_list, list) {
+ 
+ 		if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig))
+ 			continue;
+ 
+ 		if (tmp_neigh_node->if_incoming != if_incoming)
+ 			continue;
+ 
+ 		if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
+ 			continue;
+ 
+ 		neigh_node = tmp_neigh_node;
+ 		break;
+ 	}
+ 	rcu_read_unlock();
+ 
+ 	if (!neigh_node)
+ 		neigh_node = create_neighbor(orig_neigh_node,
+ 					     orig_neigh_node,
+ 					     orig_neigh_node->orig,
+ 					     if_incoming);
+ 
+ 	if (!neigh_node)
+ 		goto out;
+ 
+ 	/* if orig_node is direct neighbor update neigh_node last_valid */
+ 	if (orig_node == orig_neigh_node)
+ 		neigh_node->last_valid = jiffies;
+ 
+ 	orig_node->last_valid = jiffies;
+ 
+ 	/* find packet count of corresponding one hop neighbor */
+ 	spin_lock_bh(&orig_node->ogm_cnt_lock);
+ 	orig_eq_count = orig_neigh_node->bcast_own_sum[if_incoming->if_num];
+ 	neigh_rq_count = neigh_node->real_packet_count;
+ 	spin_unlock_bh(&orig_node->ogm_cnt_lock);
+ 
+ 	/* pay attention to not get a value bigger than 100 % */
+ 	total_count = (orig_eq_count > neigh_rq_count ?
+ 		       neigh_rq_count : orig_eq_count);
+ 
+ 	/* if we have too few packets (too less data) we set tq_own to zero */
+ 	/* if we receive too few packets it is not considered bidirectional */
+ 	if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) ||
+ 	    (neigh_rq_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM))
+ 		tq_own = 0;
+ 	else
+ 		/* neigh_node->real_packet_count is never zero as we
+ 		 * only purge old information when getting new
+ 		 * information */
+ 		tq_own = (TQ_MAX_VALUE * total_count) /	neigh_rq_count;
+ 
+ 	/*
+ 	 * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
+ 	 * affect the nearly-symmetric links only a little, but
+ 	 * punishes asymmetric links more.  This will give a value
+ 	 * between 0 and TQ_MAX_VALUE
+ 	 */
+ 	tq_asym_penalty = TQ_MAX_VALUE - (TQ_MAX_VALUE *
+ 				(TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) *
+ 				(TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) *
+ 				(TQ_LOCAL_WINDOW_SIZE - neigh_rq_count)) /
+ 					(TQ_LOCAL_WINDOW_SIZE *
+ 					 TQ_LOCAL_WINDOW_SIZE *
+ 					 TQ_LOCAL_WINDOW_SIZE);
+ 
+ 	batman_ogm_packet->tq = ((batman_ogm_packet->tq * tq_own
+ 							* tq_asym_penalty) /
+ 						(TQ_MAX_VALUE * TQ_MAX_VALUE));
+ 
+ 	bat_dbg(DBG_BATMAN, bat_priv,
+ 		"bidirectional: "
+ 		"orig = %-15pM neigh = %-15pM => own_bcast = %2i, "
+ 		"real recv = %2i, local tq: %3i, asym_penalty: %3i, "
+ 		"total tq: %3i\n",
+ 		orig_node->orig, orig_neigh_node->orig, total_count,
+ 		neigh_rq_count, tq_own,	tq_asym_penalty, batman_ogm_packet->tq);
+ 
+ 	/* if link has the minimum required transmission quality
+ 	 * consider it bidirectional */
+ 	if (batman_ogm_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
+ 		ret = 1;
+ 
+ out:
+ 	if (neigh_node)
+ 		neigh_node_free_ref(neigh_node);
+ 	return ret;
+ }
+ 
+ /* processes a batman packet for all interfaces, adjusts the sequence number and
+  * finds out whether it is a duplicate.
+  * returns:
+  *   1 the packet is a duplicate
+  *   0 the packet has not yet been received
+  *  -1 the packet is old and has been received while the seqno window
+  *     was protected. Caller should drop it.
+  */
+ static int bat_ogm_update_seqnos(const struct ethhdr *ethhdr,
+ 				 const struct batman_ogm_packet
+ 							*batman_ogm_packet,
+ 				 const struct hard_iface *if_incoming)
+ {
+ 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
+ 	struct orig_node *orig_node;
+ 	struct neigh_node *tmp_neigh_node;
+ 	struct hlist_node *node;
+ 	int is_duplicate = 0;
+ 	int32_t seq_diff;
+ 	int need_update = 0;
+ 	int set_mark, ret = -1;
+ 
+ 	orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig);
+ 	if (!orig_node)
+ 		return 0;
+ 
+ 	spin_lock_bh(&orig_node->ogm_cnt_lock);
+ 	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,
+ 			     &orig_node->batman_seqno_reset))
+ 		goto out;
+ 
+ 	rcu_read_lock();
+ 	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);
+ 
+ 		if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
+ 		    (tmp_neigh_node->if_incoming == if_incoming))
+ 			set_mark = 1;
+ 		else
+ 			set_mark = 0;
+ 
+ 		/* if the window moved, set the update flag. */
+ 		need_update |= bit_get_packet(bat_priv,
+ 					      tmp_neigh_node->real_bits,
+ 					      seq_diff, set_mark);
+ 
+ 		tmp_neigh_node->real_packet_count =
+ 			bit_packet_count(tmp_neigh_node->real_bits);
+ 	}
+ 	rcu_read_unlock();
+ 
+ 	if (need_update) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"updating last_seqno: old %d, new %d\n",
+ 			orig_node->last_real_seqno, batman_ogm_packet->seqno);
+ 		orig_node->last_real_seqno = batman_ogm_packet->seqno;
+ 	}
+ 
+ 	ret = is_duplicate;
+ 
+ out:
+ 	spin_unlock_bh(&orig_node->ogm_cnt_lock);
+ 	orig_node_free_ref(orig_node);
+ 	return ret;
+ }
+ 
+ static void bat_ogm_process(const struct ethhdr *ethhdr,
+ 			    struct batman_ogm_packet *batman_ogm_packet,
+ 			    const unsigned char *tt_buff,
+ 			    struct hard_iface *if_incoming)
+ {
+ 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
+ 	struct hard_iface *hard_iface;
+ 	struct orig_node *orig_neigh_node, *orig_node;
+ 	struct neigh_node *router = NULL, *router_router = NULL;
+ 	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_duplicate;
+ 	uint32_t if_incoming_seqno;
+ 
+ 	/* Silently drop when the batman packet is actually not a
+ 	 * correct packet.
+ 	 *
+ 	 * This might happen if a packet is padded (e.g. Ethernet has a
+ 	 * minimum frame length of 64 byte) and the aggregation interprets
+ 	 * it as an additional length.
+ 	 *
+ 	 * TODO: A more sane solution would be to have a bit in the
+ 	 * batman_ogm_packet to detect whether the packet is the last
+ 	 * packet in an aggregation.  Here we expect that the padding
+ 	 * is always zero (or not 0x01)
+ 	 */
+ 	if (batman_ogm_packet->packet_type != BAT_OGM)
+ 		return;
+ 
+ 	/* could be changed by schedule_own_packet() */
+ 	if_incoming_seqno = atomic_read(&if_incoming->seqno);
+ 
+ 	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);
+ 
+ 	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",
+ 		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,
+ 		batman_ogm_packet->ttvn, batman_ogm_packet->tt_crc,
+ 		batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
+ 		batman_ogm_packet->ttl, batman_ogm_packet->version,
+ 		has_directlink_flag);
+ 
+ 	rcu_read_lock();
+ 	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
+ 		if (hard_iface->if_status != IF_ACTIVE)
+ 			continue;
+ 
+ 		if (hard_iface->soft_iface != if_incoming->soft_iface)
+ 			continue;
+ 
+ 		if (compare_eth(ethhdr->h_source,
+ 				hard_iface->net_dev->dev_addr))
+ 			is_my_addr = 1;
+ 
+ 		if (compare_eth(batman_ogm_packet->orig,
+ 				hard_iface->net_dev->dev_addr))
+ 			is_my_orig = 1;
+ 
+ 		if (compare_eth(batman_ogm_packet->prev_sender,
+ 				hard_iface->net_dev->dev_addr))
+ 			is_my_oldorig = 1;
+ 
+ 		if (is_broadcast_ether_addr(ethhdr->h_source))
+ 			is_broadcast = 1;
+ 	}
+ 	rcu_read_unlock();
+ 
+ 	if (batman_ogm_packet->version != COMPAT_VERSION) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: incompatible batman version (%i)\n",
+ 			batman_ogm_packet->version);
+ 		return;
+ 	}
+ 
+ 	if (is_my_addr) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: received my own broadcast (sender: %pM"
+ 			")\n",
+ 			ethhdr->h_source);
+ 		return;
+ 	}
+ 
+ 	if (is_broadcast) {
+ 		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
+ 		"ignoring all packets with broadcast source addr (sender: %pM"
+ 		")\n", ethhdr->h_source);
+ 		return;
+ 	}
+ 
+ 	if (is_my_orig) {
+ 		unsigned long *word;
+ 		int offset;
+ 
+ 		orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source);
+ 		if (!orig_neigh_node)
+ 			return;
+ 
+ 		/* neighbor has to indicate direct link and it has to
+ 		 * come via the corresponding interface */
+ 		/* save packet seqno for bidirectional check */
+ 		if (has_directlink_flag &&
+ 		    compare_eth(if_incoming->net_dev->dev_addr,
+ 				batman_ogm_packet->orig)) {
+ 			offset = if_incoming->if_num * NUM_WORDS;
+ 
+ 			spin_lock_bh(&orig_neigh_node->ogm_cnt_lock);
+ 			word = &(orig_neigh_node->bcast_own[offset]);
+ 			bit_mark(word,
+ 				 if_incoming_seqno -
+ 						batman_ogm_packet->seqno - 2);
+ 			orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
+ 				bit_packet_count(word);
+ 			spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
+ 		}
+ 
+ 		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
+ 			"originator packet from myself (via neighbor)\n");
+ 		orig_node_free_ref(orig_neigh_node);
+ 		return;
+ 	}
+ 
+ 	if (is_my_oldorig) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: ignoring all rebroadcast echos (sender: "
+ 			"%pM)\n", ethhdr->h_source);
+ 		return;
+ 	}
+ 
+ 	orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig);
+ 	if (!orig_node)
+ 		return;
+ 
+ 	is_duplicate = bat_ogm_update_seqnos(ethhdr, batman_ogm_packet,
+ 					     if_incoming);
+ 
+ 	if (is_duplicate == -1) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: packet within seqno protection time "
+ 			"(sender: %pM)\n", ethhdr->h_source);
+ 		goto out;
+ 	}
+ 
+ 	if (batman_ogm_packet->tq == 0) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: originator packet with tq equal 0\n");
+ 		goto out;
+ 	}
+ 
+ 	router = orig_node_get_router(orig_node);
+ 	if (router)
+ 		router_router = orig_node_get_router(router->orig_node);
+ 
+ 	/* avoid temporary routing loops */
+ 	if (router && router_router &&
+ 	    (compare_eth(router->addr, batman_ogm_packet->prev_sender)) &&
+ 	    !(compare_eth(batman_ogm_packet->orig,
+ 			  batman_ogm_packet->prev_sender)) &&
+ 	    (compare_eth(router->addr, router_router->addr))) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: ignoring all rebroadcast packets that "
+ 			"may make me loop (sender: %pM)\n", ethhdr->h_source);
+ 		goto out;
+ 	}
+ 
+ 	/* if sender is a direct neighbor the sender mac equals
+ 	 * originator mac */
+ 	orig_neigh_node = (is_single_hop_neigh ?
+ 			   orig_node :
+ 			   get_orig_node(bat_priv, ethhdr->h_source));
+ 	if (!orig_neigh_node)
+ 		goto out;
+ 
+ 	orig_neigh_router = orig_node_get_router(orig_neigh_node);
+ 
+ 	/* drop packet if sender is not a direct neighbor and if we
+ 	 * don't route towards it */
+ 	if (!is_single_hop_neigh && (!orig_neigh_router)) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: OGM via unknown neighbor!\n");
+ 		goto out_neigh;
+ 	}
+ 
+ 	is_bidirectional = bat_ogm_calc_tq(orig_node, orig_neigh_node,
+ 					   batman_ogm_packet, if_incoming);
+ 
+ 	bonding_save_primary(orig_node, orig_neigh_node, batman_ogm_packet);
+ 
+ 	/* update ranking if it is not a duplicate or has the same
+ 	 * seqno and similar ttl as the non-duplicate */
+ 	if (is_bidirectional &&
+ 	    (!is_duplicate ||
+ 	     ((orig_node->last_real_seqno == batman_ogm_packet->seqno) &&
+ 	      (orig_node->last_ttl - 3 <= batman_ogm_packet->ttl))))
+ 		bat_ogm_orig_update(bat_priv, orig_node, ethhdr,
+ 				    batman_ogm_packet, if_incoming,
+ 				    tt_buff, is_duplicate);
+ 
+ 	/* is single hop (direct) neighbor */
+ 	if (is_single_hop_neigh) {
+ 
+ 		/* mark direct link on incoming interface */
+ 		bat_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
+ 				1, if_incoming);
+ 
+ 		bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
+ 			"rebroadcast neighbor packet with direct link flag\n");
+ 		goto out_neigh;
+ 	}
+ 
+ 	/* multihop originator */
+ 	if (!is_bidirectional) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: not received via bidirectional link\n");
+ 		goto out_neigh;
+ 	}
+ 
+ 	if (is_duplicate) {
+ 		bat_dbg(DBG_BATMAN, bat_priv,
+ 			"Drop packet: duplicate packet received\n");
+ 		goto out_neigh;
+ 	}
+ 
+ 	bat_dbg(DBG_BATMAN, bat_priv,
+ 		"Forwarding packet: rebroadcast originator packet\n");
+ 	bat_ogm_forward(orig_node, ethhdr, batman_ogm_packet, 0, if_incoming);
+ 
+ out_neigh:
+ 	if ((orig_neigh_node) && (!is_single_hop_neigh))
+ 		orig_node_free_ref(orig_neigh_node);
+ out:
+ 	if (router)
+ 		neigh_node_free_ref(router);
+ 	if (router_router)
+ 		neigh_node_free_ref(router_router);
+ 	if (orig_neigh_router)
+ 		neigh_node_free_ref(orig_neigh_router);
+ 
+ 	orig_node_free_ref(orig_node);
+ }
+ 
+ void bat_ogm_receive(const struct ethhdr *ethhdr, unsigned char *packet_buff,
+ 		     int packet_len, struct hard_iface *if_incoming)
+ {
+ 	struct batman_ogm_packet *batman_ogm_packet;
+ 	int buff_pos = 0;
+ 	unsigned char *tt_buff;
+ 
+ 	batman_ogm_packet = (struct batman_ogm_packet *)packet_buff;
+ 
+ 	/* unpack the aggregated packets and process them one by one */
+ 	do {
+ 		/* network to host order for our 32bit seqno and the
+ 		   orig_interval */
+ 		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;
+ 
+ 		bat_ogm_process(ethhdr, batman_ogm_packet,
+ 				tt_buff, if_incoming);
+ 
+ 		buff_pos += BATMAN_OGM_LEN +
+ 				tt_len(batman_ogm_packet->tt_num_changes);
+ 
+ 		batman_ogm_packet = (struct batman_ogm_packet *)
+ 						(packet_buff + buff_pos);
+ 	} while (bat_ogm_aggr_packet(buff_pos, packet_len,
+ 				     batman_ogm_packet->tt_num_changes));
+ }
diff --combined net/batman-adv/bat_ogm.h
index 0000000,69329c1..69329c1
mode 000000,100644..100644
--- a/net/batman-adv/bat_ogm.h
+++ b/net/batman-adv/bat_ogm.h
@@@ -1,0 -1,35 +1,35 @@@
+ /*
+  * Copyright (C) 2007-2011 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_OGM_H_
+ #define _NET_BATMAN_ADV_OGM_H_
+ 
+ #include "main.h"
+ 
+ void bat_ogm_init(struct hard_iface *hard_iface);
+ void bat_ogm_init_primary(struct hard_iface *hard_iface);
+ void bat_ogm_update_mac(struct hard_iface *hard_iface);
+ void bat_ogm_schedule(struct hard_iface *hard_iface, int tt_num_changes);
+ void bat_ogm_emit(struct forw_packet *forw_packet);
+ void bat_ogm_receive(const struct ethhdr *ethhdr, unsigned char *packet_buff,
+ 		     int packet_len, struct hard_iface *if_incoming);
+ 
+ #endif /* _NET_BATMAN_ADV_OGM_H_ */
diff --combined net/batman-adv/bat_sysfs.c
index cd15deb,b8a7414..b8a7414
--- a/net/batman-adv/bat_sysfs.c
+++ b/net/batman-adv/bat_sysfs.c
@@@ -380,6 -380,7 +380,7 @@@ static ssize_t store_gw_bwidth(struct k
  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);
  static BAT_ATTR(vis_mode, S_IRUGO | S_IWUSR, show_vis_mode, store_vis_mode);
  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);
@@@ -396,6 -397,7 +397,7 @@@ static struct bat_attribute *mesh_attrs
    &bat_attr_aggregated_ogms,
    &bat_attr_bonding,
    &bat_attr_fragmentation,
+ 	&bat_attr_ap_isolation,
    &bat_attr_vis_mode,
    &bat_attr_gw_mode,
    &bat_attr_orig_interval,
diff --combined net/batman-adv/bitarray.c
index c1f4bfc,0be9ff3..0be9ff3
--- a/net/batman-adv/bitarray.c
+++ b/net/batman-adv/bitarray.c
@@@ -97,12 -97,12 +97,12 @@@ static void bit_shift(unsigned long *se
    		(seq_bits[i - word_num - 1] >>
    		 (WORD_BIT_SIZE-word_offset));
    	/* and the upper part of the right half and shift it left to
- 		 * it's position */
+ 		 * its position */
    	/* for our example that would be: word[0] = 9800 + 0076 =
    	 * 9876 */
    }
- 	/* now for our last word, i==word_num, we only have the it's "left"
- 	 * half. that's the 1000 word in our example.*/
+ 	/* 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);
diff --combined net/batman-adv/gateway_client.c
index 056180e,619fb73..619fb73
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@@ -532,14 -532,14 +532,14 @@@ static bool is_type_dhcprequest(struct 
    pkt_len -= header_len + DHCP_OPTIONS_OFFSET + 1;
/* Access the dhcp option lists. Each entry is made up by:
- 	 * - octect 1: option type
- 	 * - octect 2: option data len (only if type != 255 and 0)
- 	 * - octect 3: option data */
+ 	 * - octet 1: option type
+ 	 * - octet 2: option data len (only if type != 255 and 0)
+ 	 * - octet 3: option data */
    while (*p != 255 && !ret) {
- 		/* p now points to the first octect: option type */
+ 		/* p now points to the first octet: option type */
    	if (*p == 53) {
    		/* type 53 is the message type option.
- 			 * Jump the len octect and go to the data octect */
+ 			 * Jump the len octet and go to the data octet */
    		if (pkt_len < 2)
    			goto out;
    		p += 2;
diff --combined net/batman-adv/hard-interface.c
index db7aacf,7704df4..7704df4
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@@ -28,6 -28,7 +28,7 @@@
  #include "bat_sysfs.h"
  #include "originator.h"
  #include "hash.h"
+ #include "bat_ogm.h"
#include <linux/if_arp.h>
@@@ -131,7 -132,6 +132,6 @@@ static void primary_if_select(struct ba
    		      struct hard_iface *new_hard_iface)
  {
    struct hard_iface *curr_hard_iface;
- 	struct batman_packet *batman_packet;
ASSERT_RTNL();
@@@ -147,10 -147,7 +147,7 @@@
    if (!new_hard_iface)
    	return;
- 	batman_packet = (struct batman_packet *)(new_hard_iface->packet_buff);
- 	batman_packet->flags = PRIMARIES_FIRST_HOP;
- 	batman_packet->ttl = TTL;
- 
+ 	bat_ogm_init_primary(new_hard_iface);
    primary_if_update_addr(bat_priv);
  }
@@@ -162,14 -159,6 +159,6 @@@ static bool hardif_is_iface_up(const st
    return false;
  }
- static void update_mac_addresses(struct hard_iface *hard_iface)
- {
- 	memcpy(((struct batman_packet *)(hard_iface->packet_buff))->orig,
- 	       hard_iface->net_dev->dev_addr, ETH_ALEN);
- 	memcpy(((struct batman_packet *)(hard_iface->packet_buff))->prev_sender,
- 	       hard_iface->net_dev->dev_addr, ETH_ALEN);
- }
- 
  static void check_known_mac_addr(const struct net_device *net_dev)
  {
    const struct hard_iface *hard_iface;
@@@ -244,12 -233,12 +233,12 @@@ static void hardif_activate_interface(s
bat_priv = netdev_priv(hard_iface->soft_iface);
- 	update_mac_addresses(hard_iface);
+ 	bat_ogm_update_mac(hard_iface);
    hard_iface->if_status = IF_TO_BE_ACTIVATED;
/**
     * the first active interface becomes our primary interface or
- 	 * the next active interface after the old primay interface was removed
+ 	 * the next active interface after the old primary interface was removed
     */
    primary_if = primary_if_get_selected(bat_priv);
    if (!primary_if)
@@@ -283,7 -272,6 +272,6 @@@ int hardif_enable_interface(struct hard
    		    const char *iface_name)
  {
    struct bat_priv *bat_priv;
- 	struct batman_packet *batman_packet;
    struct net_device *soft_iface;
    int ret;
@@@ -318,8 -306,8 +306,8 @@@
hard_iface->soft_iface = soft_iface;
    bat_priv = netdev_priv(hard_iface->soft_iface);
- 	hard_iface->packet_len = BAT_PACKET_LEN;
- 	hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC);
+ 
+ 	bat_ogm_init(hard_iface);
if (!hard_iface->packet_buff) {
    	bat_err(hard_iface->soft_iface, "Can't add interface packet "
@@@ -328,15 -316,6 +316,6 @@@
    	goto err;
    }
- 	batman_packet = (struct batman_packet *)(hard_iface->packet_buff);
- 	batman_packet->packet_type = BAT_PACKET;
- 	batman_packet->version = COMPAT_VERSION;
- 	batman_packet->flags = NO_FLAGS;
- 	batman_packet->ttl = 2;
- 	batman_packet->tq = TQ_MAX_VALUE;
- 	batman_packet->tt_num_changes = 0;
- 	batman_packet->ttvn = 0;
- 
    hard_iface->if_num = bat_priv->num_ifaces;
    bat_priv->num_ifaces++;
    hard_iface->if_status = IF_INACTIVE;
@@@ -381,7 -360,7 +360,7 @@@
    		hard_iface->net_dev->name);
/* begin scheduling originator messages on that interface */
- 	schedule_own_packet(hard_iface);
+ 	schedule_bat_ogm(hard_iface);
out:
    return 0;
@@@ -455,11 -434,8 +434,8 @@@ static struct hard_iface *hardif_add_in
    dev_hold(net_dev);
hard_iface = kmalloc(sizeof(*hard_iface), GFP_ATOMIC);
- 	if (!hard_iface) {
- 		pr_err("Can't add interface (%s): out of memory\n",
- 		       net_dev->name);
+ 	if (!hard_iface)
    	goto release_dev;
- 	}
ret = sysfs_add_hardif(&hard_iface->hardif_obj, net_dev);
    if (ret)
@@@ -551,7 -527,7 +527,7 @@@ static int hard_if_event(struct notifie
    		goto hardif_put;
check_known_mac_addr(hard_iface->net_dev);
- 		update_mac_addresses(hard_iface);
+ 		bat_ogm_update_mac(hard_iface);
bat_priv = netdev_priv(hard_iface->soft_iface);
    	primary_if = primary_if_get_selected(bat_priv);
@@@ -573,14 -549,14 +549,14 @@@ out
    return NOTIFY_DONE;
  }
- /* receive a packet with the batman ethertype coming on a hard
+ /* 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_packet *batman_packet;
+ 	struct batman_ogm_packet *batman_ogm_packet;
    struct hard_iface *hard_iface;
    int ret;
@@@ -612,22 -588,22 +588,22 @@@
    if (hard_iface->if_status != IF_ACTIVE)
    	goto err_free;
- 	batman_packet = (struct batman_packet *)skb->data;
+ 	batman_ogm_packet = (struct batman_ogm_packet *)skb->data;
- 	if (batman_packet->version != COMPAT_VERSION) {
+ 	if (batman_ogm_packet->version != COMPAT_VERSION) {
    	bat_dbg(DBG_BATMAN, bat_priv,
    		"Drop packet: incompatible batman version (%i)\n",
- 			batman_packet->version);
+ 			batman_ogm_packet->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_packet->packet_type) {
+ 	switch (batman_ogm_packet->packet_type) {
    	/* batman originator packet */
- 	case BAT_PACKET:
- 		ret = recv_bat_packet(skb, hard_iface);
+ 	case BAT_OGM:
+ 		ret = recv_bat_ogm_packet(skb, hard_iface);
    	break;
/* batman icmp packet */
@@@ -681,6 -657,36 +657,36 @@@ 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)
+ {
+ 	struct net_device *net_device = NULL;
+ 	bool ret = false;
+ 
+ 	if (ifindex == NULL_IFINDEX)
+ 		goto out;
+ 
+ 	net_device = dev_get_by_index(&init_net, ifindex);
+ 	if (!net_device)
+ 		goto out;
+ 
+ #ifdef CONFIG_WIRELESS_EXT
+ 	/* pre-cfg80211 drivers have to implement WEXT, so it is possible to
+ 	 * check for wireless_handlers != NULL */
+ 	if (net_device->wireless_handlers)
+ 		ret = true;
+ 	else
+ #endif
+ 		/* cfg80211 drivers have to set ieee80211_ptr */
+ 		if (net_device->ieee80211_ptr)
+ 			ret = true;
+ out:
+ 	if (net_device)
+ 		dev_put(net_device);
+ 	return ret;
+ }
+ 
  struct notifier_block hard_if_notifier = {
    .notifier_call = hard_if_event,
  };
diff --combined net/batman-adv/hard-interface.h
index 442eacb,67f78d1..67f78d1
--- a/net/batman-adv/hard-interface.h
+++ b/net/batman-adv/hard-interface.h
@@@ -42,6 -42,7 +42,7 @@@ void hardif_remove_interfaces(void)
  int hardif_min_mtu(struct net_device *soft_iface);
  void update_min_mtu(struct net_device *soft_iface);
  void hardif_free_rcu(struct rcu_head *rcu);
+ bool is_wifi_iface(int ifindex);
static inline void hardif_free_ref(struct hard_iface *hard_iface)
  {
diff --combined net/batman-adv/hash.h
index dd5c9fd,d20aa71..d20aa71
--- a/net/batman-adv/hash.h
+++ b/net/batman-adv/hash.h
@@@ -76,19 -76,30 +76,30 @@@ static inline void hash_delete(struct h
    hash_destroy(hash);
  }
- /* adds data to the hashtable. returns 0 on success, -1 on error */
+ /**
+  *	hash_add - adds data to the hashtable
+  *	@hash: storage hash table
+  *	@compare: callback to determine if 2 hash elements are identical
+  *	@choose: callback calculating the hash index
+  *	@data: data passed to the aforementioned callbacks as argument
+  *	@data_node: to be added element
+  *
+  *	Returns 0 on success, 1 if the element already is in the hash
+  *	and -1 on error.
+  */
+ 
  static inline int hash_add(struct hashtable_t *hash,
    		   hashdata_compare_cb compare,
    		   hashdata_choose_cb choose,
    		   const void *data, struct hlist_node *data_node)
  {
- 	int index;
+ 	int index, ret = -1;
    struct hlist_head *head;
    struct hlist_node *node;
    spinlock_t *list_lock; /* spinlock to protect write access */
if (!hash)
- 		goto err;
+ 		goto out;
index = choose(data, hash->size);
    head = &hash->table[index];
@@@ -99,6 -110,7 +110,7 @@@
    	if (!compare(node, data))
    		continue;
+ 		ret = 1;
    	goto err_unlock;
    }
    rcu_read_unlock();
@@@ -108,12 -120,13 +120,13 @@@
    hlist_add_head_rcu(data_node, head);
    spin_unlock_bh(list_lock);
- 	return 0;
+ 	ret = 0;
+ 	goto out;
err_unlock:
    rcu_read_unlock();
- err:
- 	return -1;
+ out:
+ 	return ret;
  }
/* removes data from hash, if found. returns pointer do data on success, so you
diff --combined net/batman-adv/main.c
index b0f9068,fb87bdc..fb87bdc
--- a/net/batman-adv/main.c
+++ b/net/batman-adv/main.c
@@@ -107,7 -107,7 +107,7 @@@ int mesh_init(struct net_device *soft_i
    if (tt_init(bat_priv) < 1)
    	goto err;
- 	tt_local_add(soft_iface, soft_iface->dev_addr);
+ 	tt_local_add(soft_iface, soft_iface->dev_addr, NULL_IFINDEX);
if (vis_init(bat_priv) < 1)
    	goto err;
@@@ -117,8 -117,6 +117,6 @@@
    goto end;
err:
- 	pr_err("Unable to allocate memory for mesh information structures: "
- 	       "out of mem ?\n");
    mesh_free(soft_iface);
    return -1;
diff --combined net/batman-adv/main.h
index a6df61a,0000000..964ad4d
mode 100644,000000..100644
--- a/net/batman-adv/main.h
+++ b/net/batman-adv/main.h
@@@ -1,225 -1,0 +1,227 @@@
 +/*
 + * Copyright (C) 2007-2011 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 "2011.3.0"
++#define SOURCE_VERSION "2011.4.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 200
 +#define TT_LOCAL_TIMEOUT 3600 /* in seconds */
 +#define TT_CLIENT_ROAM_TIMEOUT 600
- /* sliding packet range of received originator messages in squence numbers
++/* 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 3 /* seconds 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 20 /* Time in which a client can roam at most
 +			     * ROAMING_MAX_COUNT times */
 +#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 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 */
 +
 +/* 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
 +
 +/*
 + * 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
 +};
 +
 +
 +/*
 + *  Vis
 + */
 +
 +/*
 + * 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 classifaction */
++#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 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);
 +
 +#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);
 +}
 +
 +
 +#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)))
 +
 +/* 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 f3c3f62,0e5b772..0e5b772
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@@ -252,7 -252,7 +252,7 @@@ struct orig_node *get_orig_node(struct
hash_added = hash_add(bat_priv->orig_hash, compare_orig,
    		      choose_orig, orig_node, &orig_node->hash_entry);
- 	if (hash_added < 0)
+ 	if (hash_added != 0)
    	goto free_bcast_own_sum;
return orig_node;
@@@ -336,8 -336,7 +336,7 @@@ static bool purge_orig_node(struct bat_
    } else {
    	if (purge_orig_neighbors(bat_priv, orig_node,
    						&best_neigh_node)) {
- 			update_routes(bat_priv, orig_node,
- 				      best_neigh_node);
+ 			update_route(bat_priv, orig_node, best_neigh_node);
    	}
    }
@@@ -493,10 -492,8 +492,8 @@@ static int orig_node_add_if(struct orig
data_ptr = kmalloc(max_if_num * sizeof(unsigned long) * NUM_WORDS,
    		   GFP_ATOMIC);
- 	if (!data_ptr) {
- 		pr_err("Can't resize orig: out of memory\n");
+ 	if (!data_ptr)
    	return -1;
- 	}
memcpy(data_ptr, orig_node->bcast_own,
           (max_if_num - 1) * sizeof(unsigned long) * NUM_WORDS);
@@@ -504,10 -501,8 +501,8 @@@
    orig_node->bcast_own = data_ptr;
data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
- 	if (!data_ptr) {
- 		pr_err("Can't resize orig: out of memory\n");
+ 	if (!data_ptr)
    	return -1;
- 	}
memcpy(data_ptr, orig_node->bcast_own_sum,
           (max_if_num - 1) * sizeof(uint8_t));
@@@ -562,10 -557,8 +557,8 @@@ static int orig_node_del_if(struct orig
chunk_size = sizeof(unsigned long) * NUM_WORDS;
    data_ptr = kmalloc(max_if_num * chunk_size, GFP_ATOMIC);
- 	if (!data_ptr) {
- 		pr_err("Can't resize orig: out of memory\n");
+ 	if (!data_ptr)
    	return -1;
- 	}
/* copy first part */
    memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
@@@ -583,10 -576,8 +576,8 @@@ free_bcast_own
    	goto free_own_sum;
data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
- 	if (!data_ptr) {
- 		pr_err("Can't resize orig: out of memory\n");
+ 	if (!data_ptr)
    	return -1;
- 	}
memcpy(data_ptr, orig_node->bcast_own_sum,
           del_if_num * sizeof(uint8_t));
diff --combined net/batman-adv/packet.h
index b76b4be,4d9e54c..4d9e54c
--- a/net/batman-adv/packet.h
+++ b/net/batman-adv/packet.h
@@@ -25,14 -25,14 +25,14 @@@
  #define ETH_P_BATMAN  0x4305	/* unofficial/not registered Ethertype */
enum bat_packettype {
- 	BAT_PACKET       = 0x01,
- 	BAT_ICMP         = 0x02,
- 	BAT_UNICAST      = 0x03,
- 	BAT_BCAST        = 0x04,
- 	BAT_VIS          = 0x05,
+ 	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_TT_QUERY	 = 0x07,
+ 	BAT_ROAM_ADV	 = 0x08
  };
/* this file is included by batctl which needs these defines */
@@@ -84,12 -84,13 +84,13 @@@ enum tt_query_flags 
  enum tt_client_flags {
    TT_CLIENT_DEL     = 1 << 0,
    TT_CLIENT_ROAM    = 1 << 1,
+ 	TT_CLIENT_WIFI    = 1 << 2,
    TT_CLIENT_NOPURGE = 1 << 8,
    TT_CLIENT_NEW     = 1 << 9,
    TT_CLIENT_PENDING = 1 << 10
  };
- struct batman_packet {
+ struct batman_ogm_packet {
    uint8_t  packet_type;
    uint8_t  version;  /* batman version field */
    uint8_t  ttl;
@@@ -104,7 -105,7 +105,7 @@@
    uint16_t tt_crc;
  } __packed;
- #define BAT_PACKET_LEN sizeof(struct batman_packet)
+ #define BATMAN_OGM_LEN sizeof(struct batman_ogm_packet)
struct icmp_packet {
    uint8_t  packet_type;
diff --combined net/batman-adv/routing.c
index 0f32c81,f961cc5..f961cc5
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@@ -22,18 -22,14 +22,14 @@@
  #include "main.h"
  #include "routing.h"
  #include "send.h"
- #include "hash.h"
  #include "soft-interface.h"
  #include "hard-interface.h"
  #include "icmp_socket.h"
  #include "translation-table.h"
  #include "originator.h"
- #include "ring_buffer.h"
  #include "vis.h"
- #include "aggregation.h"
- #include "gateway_common.h"
- #include "gateway_client.h"
  #include "unicast.h"
+ #include "bat_ogm.h"
void slide_own_bcast_window(struct hard_iface *hard_iface)
  {
@@@ -64,69 -60,9 +60,9 @@@
    }
  }
- static void update_transtable(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)
- {
- 	uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
- 	bool full_table = true;
- 
- 	/* the ttvn increased by one -> we can apply the attached changes */
- 	if (ttvn - orig_ttvn == 1) {
- 		/* the OGM could not contain the changes because they were too
- 		 * many to fit in one frame or because they have already been
- 		 * sent TT_OGM_APPEND_MAX times. In this case send a tt
- 		 * request */
- 		if (!tt_num_changes) {
- 			full_table = false;
- 			goto request_table;
- 		}
- 
- 		tt_update_changes(bat_priv, orig_node, tt_num_changes, ttvn,
- 				  (struct tt_change *)tt_buff);
- 
- 		/* Even if we received the crc into the OGM, we prefer
- 		 * to recompute it to spot any possible inconsistency
- 		 * in the global table */
- 		orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
- 
- 		/* The ttvn alone is not enough to guarantee consistency
- 		 * because a single value could repesent different states
- 		 * (due to the wrap around). Thus a node has to check whether
- 		 * the resulting table (after applying the changes) is still
- 		 * consistent or not. E.g. a node could disconnect while its
- 		 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
- 		 * checking the CRC value is mandatory to detect the
- 		 * inconsistency */
- 		if (orig_node->tt_crc != tt_crc)
- 			goto request_table;
- 
- 		/* Roaming phase is over: tables are in sync again. I can
- 		 * unset the flag */
- 		orig_node->tt_poss_change = false;
- 	} else {
- 		/* if we missed more than one change or our tables are not
- 		 * in sync anymore -> request fresh tt data */
- 		if (ttvn != orig_ttvn || orig_node->tt_crc != tt_crc) {
- request_table:
- 			bat_dbg(DBG_TT, bat_priv, "TT inconsistency for %pM. "
- 				"Need to retrieve the correct information "
- 				"(ttvn: %u last_ttvn: %u crc: %u last_crc: "
- 				"%u num_changes: %u)\n", orig_node->orig, ttvn,
- 				orig_ttvn, tt_crc, orig_node->tt_crc,
- 				tt_num_changes);
- 			send_tt_request(bat_priv, orig_node, ttvn, tt_crc,
- 					full_table);
- 			return;
- 		}
- 	}
- }
- 
- static void update_route(struct bat_priv *bat_priv,
- 			 struct orig_node *orig_node,
- 			 struct neigh_node *neigh_node)
+ static void _update_route(struct bat_priv *bat_priv,
+ 			  struct orig_node *orig_node,
+ 			  struct neigh_node *neigh_node)
  {
    struct neigh_node *curr_router;
@@@ -170,8 -106,8 +106,8 @@@
    	neigh_node_free_ref(curr_router);
  }
- void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 		   struct neigh_node *neigh_node)
+ void update_route(struct bat_priv *bat_priv, struct orig_node *orig_node,
+ 		  struct neigh_node *neigh_node)
  {
    struct neigh_node *router = NULL;
@@@ -181,116 -117,13 +117,13 @@@
    router = orig_node_get_router(orig_node);
if (router != neigh_node)
- 		update_route(bat_priv, orig_node, neigh_node);
+ 		_update_route(bat_priv, orig_node, neigh_node);
out:
    if (router)
    	neigh_node_free_ref(router);
  }
- static int is_bidirectional_neigh(struct orig_node *orig_node,
- 				struct orig_node *orig_neigh_node,
- 				struct batman_packet *batman_packet,
- 				struct hard_iface *if_incoming)
- {
- 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
- 	struct neigh_node *neigh_node = NULL, *tmp_neigh_node;
- 	struct hlist_node *node;
- 	uint8_t total_count;
- 	uint8_t orig_eq_count, neigh_rq_count, tq_own;
- 	int tq_asym_penalty, ret = 0;
- 
- 	/* find corresponding one hop neighbor */
- 	rcu_read_lock();
- 	hlist_for_each_entry_rcu(tmp_neigh_node, node,
- 				 &orig_neigh_node->neigh_list, list) {
- 
- 		if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig))
- 			continue;
- 
- 		if (tmp_neigh_node->if_incoming != if_incoming)
- 			continue;
- 
- 		if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
- 			continue;
- 
- 		neigh_node = tmp_neigh_node;
- 		break;
- 	}
- 	rcu_read_unlock();
- 
- 	if (!neigh_node)
- 		neigh_node = create_neighbor(orig_neigh_node,
- 					     orig_neigh_node,
- 					     orig_neigh_node->orig,
- 					     if_incoming);
- 
- 	if (!neigh_node)
- 		goto out;
- 
- 	/* if orig_node is direct neighbour update neigh_node last_valid */
- 	if (orig_node == orig_neigh_node)
- 		neigh_node->last_valid = jiffies;
- 
- 	orig_node->last_valid = jiffies;
- 
- 	/* find packet count of corresponding one hop neighbor */
- 	spin_lock_bh(&orig_node->ogm_cnt_lock);
- 	orig_eq_count = orig_neigh_node->bcast_own_sum[if_incoming->if_num];
- 	neigh_rq_count = neigh_node->real_packet_count;
- 	spin_unlock_bh(&orig_node->ogm_cnt_lock);
- 
- 	/* pay attention to not get a value bigger than 100 % */
- 	total_count = (orig_eq_count > neigh_rq_count ?
- 		       neigh_rq_count : orig_eq_count);
- 
- 	/* if we have too few packets (too less data) we set tq_own to zero */
- 	/* if we receive too few packets it is not considered bidirectional */
- 	if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) ||
- 	    (neigh_rq_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM))
- 		tq_own = 0;
- 	else
- 		/* neigh_node->real_packet_count is never zero as we
- 		 * only purge old information when getting new
- 		 * information */
- 		tq_own = (TQ_MAX_VALUE * total_count) /	neigh_rq_count;
- 
- 	/*
- 	 * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
- 	 * affect the nearly-symmetric links only a little, but
- 	 * punishes asymmetric links more.  This will give a value
- 	 * between 0 and TQ_MAX_VALUE
- 	 */
- 	tq_asym_penalty = TQ_MAX_VALUE - (TQ_MAX_VALUE *
- 				(TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) *
- 				(TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) *
- 				(TQ_LOCAL_WINDOW_SIZE - neigh_rq_count)) /
- 					(TQ_LOCAL_WINDOW_SIZE *
- 					 TQ_LOCAL_WINDOW_SIZE *
- 					 TQ_LOCAL_WINDOW_SIZE);
- 
- 	batman_packet->tq = ((batman_packet->tq * tq_own * tq_asym_penalty) /
- 						(TQ_MAX_VALUE * TQ_MAX_VALUE));
- 
- 	bat_dbg(DBG_BATMAN, bat_priv,
- 		"bidirectional: "
- 		"orig = %-15pM neigh = %-15pM => own_bcast = %2i, "
- 		"real recv = %2i, local tq: %3i, asym_penalty: %3i, "
- 		"total tq: %3i\n",
- 		orig_node->orig, orig_neigh_node->orig, total_count,
- 		neigh_rq_count, tq_own,	tq_asym_penalty, batman_packet->tq);
- 
- 	/* if link has the minimum required transmission quality
- 	 * consider it bidirectional */
- 	if (batman_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
- 		ret = 1;
- 
- out:
- 	if (neigh_node)
- 		neigh_node_free_ref(neigh_node);
- 	return ret;
- }
- 
  /* caller must hold the neigh_list_lock */
  void bonding_candidate_del(struct orig_node *orig_node,
    		   struct neigh_node *neigh_node)
@@@ -308,8 -141,8 +141,8 @@@ out
    return;
  }
- static void bonding_candidate_add(struct orig_node *orig_node,
- 				  struct neigh_node *neigh_node)
+ void bonding_candidate_add(struct orig_node *orig_node,
+ 			   struct neigh_node *neigh_node)
  {
    struct hlist_node *node;
    struct neigh_node *tmp_neigh_node, *router = NULL;
@@@ -379,162 -212,23 +212,23 @@@ out
  }
/* copy primary address for bonding */
- static void bonding_save_primary(const struct orig_node *orig_node,
- 				 struct orig_node *orig_neigh_node,
- 				 const struct batman_packet *batman_packet)
+ void bonding_save_primary(const struct orig_node *orig_node,
+ 			  struct orig_node *orig_neigh_node,
+ 			  const struct batman_ogm_packet *batman_ogm_packet)
  {
- 	if (!(batman_packet->flags & PRIMARIES_FIRST_HOP))
+ 	if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
    	return;
memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
  }
- static void update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 			const struct ethhdr *ethhdr,
- 			const struct batman_packet *batman_packet,
- 			struct hard_iface *if_incoming,
- 			const unsigned char *tt_buff, int is_duplicate)
- {
- 	struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
- 	struct neigh_node *router = NULL;
- 	struct orig_node *orig_node_tmp;
- 	struct hlist_node *node;
- 	uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
- 
- 	bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): "
- 		"Searching and updating originator entry of received packet\n");
- 
- 	rcu_read_lock();
- 	hlist_for_each_entry_rcu(tmp_neigh_node, node,
- 				 &orig_node->neigh_list, list) {
- 		if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
- 		    (tmp_neigh_node->if_incoming == if_incoming) &&
- 		     atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
- 			if (neigh_node)
- 				neigh_node_free_ref(neigh_node);
- 			neigh_node = tmp_neigh_node;
- 			continue;
- 		}
- 
- 		if (is_duplicate)
- 			continue;
- 
- 		spin_lock_bh(&tmp_neigh_node->tq_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);
- 	}
- 
- 	if (!neigh_node) {
- 		struct orig_node *orig_tmp;
- 
- 		orig_tmp = get_orig_node(bat_priv, ethhdr->h_source);
- 		if (!orig_tmp)
- 			goto unlock;
- 
- 		neigh_node = create_neighbor(orig_node, orig_tmp,
- 					     ethhdr->h_source, if_incoming);
- 
- 		orig_node_free_ref(orig_tmp);
- 		if (!neigh_node)
- 			goto unlock;
- 	} else
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Updating existing last-hop neighbor of originator\n");
- 
- 	rcu_read_unlock();
- 
- 	orig_node->flags = batman_packet->flags;
- 	neigh_node->last_valid = jiffies;
- 
- 	spin_lock_bh(&neigh_node->tq_lock);
- 	ring_buffer_set(neigh_node->tq_recv,
- 			&neigh_node->tq_index,
- 			batman_packet->tq);
- 	neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv);
- 	spin_unlock_bh(&neigh_node->tq_lock);
- 
- 	if (!is_duplicate) {
- 		orig_node->last_ttl = batman_packet->ttl;
- 		neigh_node->last_ttl = batman_packet->ttl;
- 	}
- 
- 	bonding_candidate_add(orig_node, neigh_node);
- 
- 	/* if this neighbor already is our next hop there is nothing
- 	 * to change */
- 	router = orig_node_get_router(orig_node);
- 	if (router == neigh_node)
- 		goto update_tt;
- 
- 	/* if this neighbor does not offer a better TQ we won't consider it */
- 	if (router && (router->tq_avg > neigh_node->tq_avg))
- 		goto update_tt;
- 
- 	/* if the TQ is the same and the link not more symetric we
- 	 * won't consider it either */
- 	if (router && (neigh_node->tq_avg == router->tq_avg)) {
- 		orig_node_tmp = router->orig_node;
- 		spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
- 		bcast_own_sum_orig =
- 			orig_node_tmp->bcast_own_sum[if_incoming->if_num];
- 		spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
- 
- 		orig_node_tmp = neigh_node->orig_node;
- 		spin_lock_bh(&orig_node_tmp->ogm_cnt_lock);
- 		bcast_own_sum_neigh =
- 			orig_node_tmp->bcast_own_sum[if_incoming->if_num];
- 		spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock);
- 
- 		if (bcast_own_sum_orig >= bcast_own_sum_neigh)
- 			goto update_tt;
- 	}
- 
- 	update_routes(bat_priv, orig_node, neigh_node);
- 
- update_tt:
- 	/* I have to check for transtable changes only if the OGM has been
- 	 * sent through a primary interface */
- 	if (((batman_packet->orig != ethhdr->h_source) &&
- 				(batman_packet->ttl > 2)) ||
- 				(batman_packet->flags & PRIMARIES_FIRST_HOP))
- 		update_transtable(bat_priv, orig_node, tt_buff,
- 				  batman_packet->tt_num_changes,
- 				  batman_packet->ttvn,
- 				  batman_packet->tt_crc);
- 
- 	if (orig_node->gw_flags != batman_packet->gw_flags)
- 		gw_node_update(bat_priv, orig_node, batman_packet->gw_flags);
- 
- 	orig_node->gw_flags = batman_packet->gw_flags;
- 
- 	/* restart gateway selection if fast or late switching was enabled */
- 	if ((orig_node->gw_flags) &&
- 	    (atomic_read(&bat_priv->gw_mode) == GW_MODE_CLIENT) &&
- 	    (atomic_read(&bat_priv->gw_sel_class) > 2))
- 		gw_check_election(bat_priv, orig_node);
- 
- 	goto out;
- 
- unlock:
- 	rcu_read_unlock();
- out:
- 	if (neigh_node)
- 		neigh_node_free_ref(neigh_node);
- 	if (router)
- 		neigh_node_free_ref(router);
- }
- 
  /* checks whether the host restarted and is in the protection time.
   * returns:
   *  0 if the packet is to be accepted
   *  1 if the packet is to be ignored.
   */
- static int window_protected(struct bat_priv *bat_priv,
- 			    int32_t seq_num_diff,
- 			    unsigned long *last_reset)
+ int window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff,
+ 		     unsigned long *last_reset)
  {
    if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE)
    	|| (seq_num_diff >= EXPECTED_SEQNO_RANGE)) {
@@@ -552,330 -246,12 +246,12 @@@
    return 0;
  }
- /* processes a batman packet for all interfaces, adjusts the sequence number and
-  * finds out whether it is a duplicate.
-  * returns:
-  *   1 the packet is a duplicate
-  *   0 the packet has not yet been received
-  *  -1 the packet is old and has been received while the seqno window
-  *     was protected. Caller should drop it.
-  */
- static int count_real_packets(const struct ethhdr *ethhdr,
- 			       const struct batman_packet *batman_packet,
- 			       const struct hard_iface *if_incoming)
- {
- 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
- 	struct orig_node *orig_node;
- 	struct neigh_node *tmp_neigh_node;
- 	struct hlist_node *node;
- 	int is_duplicate = 0;
- 	int32_t seq_diff;
- 	int need_update = 0;
- 	int set_mark, ret = -1;
- 
- 	orig_node = get_orig_node(bat_priv, batman_packet->orig);
- 	if (!orig_node)
- 		return 0;
- 
- 	spin_lock_bh(&orig_node->ogm_cnt_lock);
- 	seq_diff = batman_packet->seqno - orig_node->last_real_seqno;
- 
- 	/* signalize caller that the packet is to be dropped. */
- 	if (window_protected(bat_priv, seq_diff,
- 			     &orig_node->batman_seqno_reset))
- 		goto out;
- 
- 	rcu_read_lock();
- 	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_packet->seqno);
- 
- 		if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
- 		    (tmp_neigh_node->if_incoming == if_incoming))
- 			set_mark = 1;
- 		else
- 			set_mark = 0;
- 
- 		/* if the window moved, set the update flag. */
- 		need_update |= bit_get_packet(bat_priv,
- 					      tmp_neigh_node->real_bits,
- 					      seq_diff, set_mark);
- 
- 		tmp_neigh_node->real_packet_count =
- 			bit_packet_count(tmp_neigh_node->real_bits);
- 	}
- 	rcu_read_unlock();
- 
- 	if (need_update) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"updating last_seqno: old %d, new %d\n",
- 			orig_node->last_real_seqno, batman_packet->seqno);
- 		orig_node->last_real_seqno = batman_packet->seqno;
- 	}
- 
- 	ret = is_duplicate;
- 
- out:
- 	spin_unlock_bh(&orig_node->ogm_cnt_lock);
- 	orig_node_free_ref(orig_node);
- 	return ret;
- }
- 
- void receive_bat_packet(const struct ethhdr *ethhdr,
- 			struct batman_packet *batman_packet,
- 			const unsigned char *tt_buff,
- 			struct hard_iface *if_incoming)
- {
- 	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
- 	struct hard_iface *hard_iface;
- 	struct orig_node *orig_neigh_node, *orig_node;
- 	struct neigh_node *router = NULL, *router_router = NULL;
- 	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_duplicate;
- 	uint32_t if_incoming_seqno;
- 
- 	/* Silently drop when the batman packet is actually not a
- 	 * correct packet.
- 	 *
- 	 * This might happen if a packet is padded (e.g. Ethernet has a
- 	 * minimum frame length of 64 byte) and the aggregation interprets
- 	 * it as an additional length.
- 	 *
- 	 * TODO: A more sane solution would be to have a bit in the
- 	 * batman_packet to detect whether the packet is the last
- 	 * packet in an aggregation.  Here we expect that the padding
- 	 * is always zero (or not 0x01)
- 	 */
- 	if (batman_packet->packet_type != BAT_PACKET)
- 		return;
- 
- 	/* could be changed by schedule_own_packet() */
- 	if_incoming_seqno = atomic_read(&if_incoming->seqno);
- 
- 	has_directlink_flag = (batman_packet->flags & DIRECTLINK ? 1 : 0);
- 
- 	is_single_hop_neigh = (compare_eth(ethhdr->h_source,
- 					   batman_packet->orig) ? 1 : 0);
- 
- 	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",
- 		ethhdr->h_source, if_incoming->net_dev->name,
- 		if_incoming->net_dev->dev_addr, batman_packet->orig,
- 		batman_packet->prev_sender, batman_packet->seqno,
- 		batman_packet->ttvn, batman_packet->tt_crc,
- 		batman_packet->tt_num_changes, batman_packet->tq,
- 		batman_packet->ttl, batman_packet->version,
- 		has_directlink_flag);
- 
- 	rcu_read_lock();
- 	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
- 		if (hard_iface->if_status != IF_ACTIVE)
- 			continue;
- 
- 		if (hard_iface->soft_iface != if_incoming->soft_iface)
- 			continue;
- 
- 		if (compare_eth(ethhdr->h_source,
- 				hard_iface->net_dev->dev_addr))
- 			is_my_addr = 1;
- 
- 		if (compare_eth(batman_packet->orig,
- 				hard_iface->net_dev->dev_addr))
- 			is_my_orig = 1;
- 
- 		if (compare_eth(batman_packet->prev_sender,
- 				hard_iface->net_dev->dev_addr))
- 			is_my_oldorig = 1;
- 
- 		if (is_broadcast_ether_addr(ethhdr->h_source))
- 			is_broadcast = 1;
- 	}
- 	rcu_read_unlock();
- 
- 	if (batman_packet->version != COMPAT_VERSION) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: incompatible batman version (%i)\n",
- 			batman_packet->version);
- 		return;
- 	}
- 
- 	if (is_my_addr) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: received my own broadcast (sender: %pM"
- 			")\n",
- 			ethhdr->h_source);
- 		return;
- 	}
- 
- 	if (is_broadcast) {
- 		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
- 		"ignoring all packets with broadcast source addr (sender: %pM"
- 		")\n", ethhdr->h_source);
- 		return;
- 	}
- 
- 	if (is_my_orig) {
- 		unsigned long *word;
- 		int offset;
- 
- 		orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source);
- 		if (!orig_neigh_node)
- 			return;
- 
- 		/* neighbor has to indicate direct link and it has to
- 		 * come via the corresponding interface */
- 		/* save packet seqno for bidirectional check */
- 		if (has_directlink_flag &&
- 		    compare_eth(if_incoming->net_dev->dev_addr,
- 				batman_packet->orig)) {
- 			offset = if_incoming->if_num * NUM_WORDS;
- 
- 			spin_lock_bh(&orig_neigh_node->ogm_cnt_lock);
- 			word = &(orig_neigh_node->bcast_own[offset]);
- 			bit_mark(word,
- 				 if_incoming_seqno - batman_packet->seqno - 2);
- 			orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
- 				bit_packet_count(word);
- 			spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
- 		}
- 
- 		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
- 			"originator packet from myself (via neighbor)\n");
- 		orig_node_free_ref(orig_neigh_node);
- 		return;
- 	}
- 
- 	if (is_my_oldorig) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: ignoring all rebroadcast echos (sender: "
- 			"%pM)\n", ethhdr->h_source);
- 		return;
- 	}
- 
- 	orig_node = get_orig_node(bat_priv, batman_packet->orig);
- 	if (!orig_node)
- 		return;
- 
- 	is_duplicate = count_real_packets(ethhdr, batman_packet, if_incoming);
- 
- 	if (is_duplicate == -1) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: packet within seqno protection time "
- 			"(sender: %pM)\n", ethhdr->h_source);
- 		goto out;
- 	}
- 
- 	if (batman_packet->tq == 0) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: originator packet with tq equal 0\n");
- 		goto out;
- 	}
- 
- 	router = orig_node_get_router(orig_node);
- 	if (router)
- 		router_router = orig_node_get_router(router->orig_node);
- 
- 	/* avoid temporary routing loops */
- 	if (router && router_router &&
- 	    (compare_eth(router->addr, batman_packet->prev_sender)) &&
- 	    !(compare_eth(batman_packet->orig, batman_packet->prev_sender)) &&
- 	    (compare_eth(router->addr, router_router->addr))) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: ignoring all rebroadcast packets that "
- 			"may make me loop (sender: %pM)\n", ethhdr->h_source);
- 		goto out;
- 	}
- 
- 	/* if sender is a direct neighbor the sender mac equals
- 	 * originator mac */
- 	orig_neigh_node = (is_single_hop_neigh ?
- 			   orig_node :
- 			   get_orig_node(bat_priv, ethhdr->h_source));
- 	if (!orig_neigh_node)
- 		goto out;
- 
- 	orig_neigh_router = orig_node_get_router(orig_neigh_node);
- 
- 	/* drop packet if sender is not a direct neighbor and if we
- 	 * don't route towards it */
- 	if (!is_single_hop_neigh && (!orig_neigh_router)) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: OGM via unknown neighbor!\n");
- 		goto out_neigh;
- 	}
- 
- 	is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node,
- 						batman_packet, if_incoming);
- 
- 	bonding_save_primary(orig_node, orig_neigh_node, batman_packet);
- 
- 	/* update ranking if it is not a duplicate or has the same
- 	 * seqno and similar ttl as the non-duplicate */
- 	if (is_bidirectional &&
- 	    (!is_duplicate ||
- 	     ((orig_node->last_real_seqno == batman_packet->seqno) &&
- 	      (orig_node->last_ttl - 3 <= batman_packet->ttl))))
- 		update_orig(bat_priv, orig_node, ethhdr, batman_packet,
- 			    if_incoming, tt_buff, is_duplicate);
- 
- 	/* is single hop (direct) neighbor */
- 	if (is_single_hop_neigh) {
- 
- 		/* mark direct link on incoming interface */
- 		schedule_forward_packet(orig_node, ethhdr, batman_packet,
- 					1, if_incoming);
- 
- 		bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
- 			"rebroadcast neighbor packet with direct link flag\n");
- 		goto out_neigh;
- 	}
- 
- 	/* multihop originator */
- 	if (!is_bidirectional) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: not received via bidirectional link\n");
- 		goto out_neigh;
- 	}
- 
- 	if (is_duplicate) {
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"Drop packet: duplicate packet received\n");
- 		goto out_neigh;
- 	}
- 
- 	bat_dbg(DBG_BATMAN, bat_priv,
- 		"Forwarding packet: rebroadcast originator packet\n");
- 	schedule_forward_packet(orig_node, ethhdr, batman_packet,
- 				0, if_incoming);
- 
- out_neigh:
- 	if ((orig_neigh_node) && (!is_single_hop_neigh))
- 		orig_node_free_ref(orig_neigh_node);
- out:
- 	if (router)
- 		neigh_node_free_ref(router);
- 	if (router_router)
- 		neigh_node_free_ref(router_router);
- 	if (orig_neigh_router)
- 		neigh_node_free_ref(orig_neigh_router);
- 
- 	orig_node_free_ref(orig_node);
- }
- 
- int recv_bat_packet(struct sk_buff *skb, struct hard_iface *hard_iface)
+ int recv_bat_ogm_packet(struct sk_buff *skb, struct hard_iface *hard_iface)
  {
    struct ethhdr *ethhdr;
/* drop packet if it has not necessary minimum size */
- 	if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet))))
+ 	if (unlikely(!pskb_may_pull(skb, BATMAN_OGM_LEN)))
    	return NET_RX_DROP;
ethhdr = (struct ethhdr *)skb_mac_header(skb);
@@@ -898,10 -274,7 +274,7 @@@
ethhdr = (struct ethhdr *)skb_mac_header(skb);
- 	receive_aggr_bat_packet(ethhdr,
- 				skb->data,
- 				skb_headlen(skb),
- 				hard_iface);
+ 	bat_ogm_receive(ethhdr, skb->data, skb_headlen(skb), hard_iface);
kfree_skb(skb);
    return NET_RX_SUCCESS;
@@@ -1243,7 -616,7 +616,7 @@@ int recv_tt_query(struct sk_buff *skb, 
    	}
    	break;
    case TT_RESPONSE:
- 		/* packet needs to be linearised to access the TT changes */
+ 		/* packet needs to be linearized to access the TT changes */
    	if (skb_linearize(skb) < 0)
    		goto out;
@@@ -1300,7 -673,7 +673,7 @@@ int recv_roam_adv(struct sk_buff *skb, 
    	roam_adv_packet->client);
tt_global_add(bat_priv, orig_node, roam_adv_packet->client,
- 		      atomic_read(&orig_node->last_ttvn) + 1, true);
+ 		      atomic_read(&orig_node->last_ttvn) + 1, true, false);
/* Roaming phase starts: I have new information but the ttvn has not
     * been incremented yet. This flag will make me check all the incoming
@@@ -1536,7 -909,7 +909,7 @@@ static int check_unicast_ttvn(struct ba
ethhdr = (struct ethhdr *)(skb->data +
    		sizeof(struct unicast_packet));
- 		orig_node = transtable_search(bat_priv, ethhdr->h_dest);
+ 		orig_node = transtable_search(bat_priv, NULL, ethhdr->h_dest);
if (!orig_node) {
    		if (!is_my_client(bat_priv, ethhdr->h_dest))
diff --combined net/batman-adv/routing.h
index fb14e95,7aaee0f..7aaee0f
--- a/net/batman-adv/routing.h
+++ b/net/batman-adv/routing.h
@@@ -23,19 -23,15 +23,15 @@@
  #define _NET_BATMAN_ADV_ROUTING_H_
void slide_own_bcast_window(struct hard_iface *hard_iface);
- void receive_bat_packet(const struct ethhdr *ethhdr,
- 			struct batman_packet *batman_packet,
- 			const unsigned char *tt_buff,
- 			struct hard_iface *if_incoming);
- void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 		   struct neigh_node *neigh_node);
+ 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_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,
@@@ -43,5 -39,12 +39,12 @@@
    		       const struct hard_iface *recv_if);
  void bonding_candidate_del(struct orig_node *orig_node,
    		   struct neigh_node *neigh_node);
+ void bonding_candidate_add(struct orig_node *orig_node,
+ 			   struct neigh_node *neigh_node);
+ void bonding_save_primary(const struct orig_node *orig_node,
+ 			  struct orig_node *orig_neigh_node,
+ 			  const struct batman_ogm_packet *batman_ogm_packet);
+ int window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff,
+ 		     unsigned long *last_reset);
#endif /* _NET_BATMAN_ADV_ROUTING_H_ */
diff --combined net/batman-adv/send.c
index 58d1447,8a684eb..8a684eb
--- a/net/batman-adv/send.c
+++ b/net/batman-adv/send.c
@@@ -26,33 -26,12 +26,12 @@@
  #include "soft-interface.h"
  #include "hard-interface.h"
  #include "vis.h"
- #include "aggregation.h"
  #include "gateway_common.h"
  #include "originator.h"
+ #include "bat_ogm.h"
static void send_outstanding_bcast_packet(struct work_struct *work);
- /* apply hop penalty for a normal link */
- static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
- {
- 	int hop_penalty = atomic_read(&bat_priv->hop_penalty);
- 	return (tq * (TQ_MAX_VALUE - hop_penalty)) / (TQ_MAX_VALUE);
- }
- 
- /* when do we schedule our own packet to be sent */
- static unsigned long own_send_time(const struct bat_priv *bat_priv)
- {
- 	return jiffies + msecs_to_jiffies(
- 		   atomic_read(&bat_priv->orig_interval) -
- 		   JITTER + (random32() % 2*JITTER));
- }
- 
- /* when do we schedule a forwarded packet to be sent */
- static unsigned long forward_send_time(void)
- {
- 	return jiffies + msecs_to_jiffies(random32() % (JITTER/2));
- }
- 
  /* send out an already prepared packet to the given address via the
   * specified batman interface */
  int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface,
@@@ -99,141 -78,17 +78,17 @@@ send_skb_err
    return NET_XMIT_DROP;
  }
- /* Send a packet to a given interface */
- static void send_packet_to_if(struct forw_packet *forw_packet,
- 			      struct hard_iface *hard_iface)
- {
- 	struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
- 	char *fwd_str;
- 	uint8_t packet_num;
- 	int16_t buff_pos;
- 	struct batman_packet *batman_packet;
- 	struct sk_buff *skb;
- 
- 	if (hard_iface->if_status != IF_ACTIVE)
- 		return;
- 
- 	packet_num = 0;
- 	buff_pos = 0;
- 	batman_packet = (struct batman_packet *)forw_packet->skb->data;
- 
- 	/* adjust all flags and log packets */
- 	while (aggregated_packet(buff_pos,
- 				 forw_packet->packet_len,
- 				 batman_packet->tt_num_changes)) {
- 
- 		/* we might have aggregated direct link packets with an
- 		 * ordinary base packet */
- 		if ((forw_packet->direct_link_flags & (1 << packet_num)) &&
- 		    (forw_packet->if_incoming == hard_iface))
- 			batman_packet->flags |= DIRECTLINK;
- 		else
- 			batman_packet->flags &= ~DIRECTLINK;
- 
- 		fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
- 							    "Sending own" :
- 							    "Forwarding"));
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"%s %spacket (originator %pM, seqno %d, TQ %d, TTL %d,"
- 			" IDF %s, hvn %d) on interface %s [%pM]\n",
- 			fwd_str, (packet_num > 0 ? "aggregated " : ""),
- 			batman_packet->orig, ntohl(batman_packet->seqno),
- 			batman_packet->tq, batman_packet->ttl,
- 			(batman_packet->flags & DIRECTLINK ?
- 			 "on" : "off"),
- 			batman_packet->ttvn, hard_iface->net_dev->name,
- 			hard_iface->net_dev->dev_addr);
- 
- 		buff_pos += sizeof(*batman_packet) +
- 			tt_len(batman_packet->tt_num_changes);
- 		packet_num++;
- 		batman_packet = (struct batman_packet *)
- 			(forw_packet->skb->data + buff_pos);
- 	}
- 
- 	/* create clone because function is called more than once */
- 	skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
- 	if (skb)
- 		send_skb_packet(skb, hard_iface, broadcast_addr);
- }
- 
- /* send a batman packet */
- static void send_packet(struct forw_packet *forw_packet)
- {
- 	struct hard_iface *hard_iface;
- 	struct net_device *soft_iface;
- 	struct bat_priv *bat_priv;
- 	struct hard_iface *primary_if = NULL;
- 	struct batman_packet *batman_packet =
- 		(struct batman_packet *)(forw_packet->skb->data);
- 	int directlink = (batman_packet->flags & DIRECTLINK ? 1 : 0);
- 
- 	if (!forw_packet->if_incoming) {
- 		pr_err("Error - can't forward packet: incoming iface not "
- 		       "specified\n");
- 		goto out;
- 	}
- 
- 	soft_iface = forw_packet->if_incoming->soft_iface;
- 	bat_priv = netdev_priv(soft_iface);
- 
- 	if (forw_packet->if_incoming->if_status != IF_ACTIVE)
- 		goto out;
- 
- 	primary_if = primary_if_get_selected(bat_priv);
- 	if (!primary_if)
- 		goto out;
- 
- 	/* multihomed peer assumed */
- 	/* non-primary OGMs are only broadcasted on their interface */
- 	if ((directlink && (batman_packet->ttl == 1)) ||
- 	    (forw_packet->own && (forw_packet->if_incoming != primary_if))) {
- 
- 		/* FIXME: what about aggregated packets ? */
- 		bat_dbg(DBG_BATMAN, bat_priv,
- 			"%s packet (originator %pM, seqno %d, TTL %d) "
- 			"on interface %s [%pM]\n",
- 			(forw_packet->own ? "Sending own" : "Forwarding"),
- 			batman_packet->orig, ntohl(batman_packet->seqno),
- 			batman_packet->ttl,
- 			forw_packet->if_incoming->net_dev->name,
- 			forw_packet->if_incoming->net_dev->dev_addr);
- 
- 		/* skb is only used once and than forw_packet is free'd */
- 		send_skb_packet(forw_packet->skb, forw_packet->if_incoming,
- 				broadcast_addr);
- 		forw_packet->skb = NULL;
- 
- 		goto out;
- 	}
- 
- 	/* broadcast on every interface */
- 	rcu_read_lock();
- 	list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
- 		if (hard_iface->soft_iface != soft_iface)
- 			continue;
- 
- 		send_packet_to_if(forw_packet, hard_iface);
- 	}
- 	rcu_read_unlock();
- 
- out:
- 	if (primary_if)
- 		hardif_free_ref(primary_if);
- }
- 
  static void realloc_packet_buffer(struct hard_iface *hard_iface,
- 				int new_len)
+ 				  int new_len)
  {
    unsigned char *new_buff;
- 	struct batman_packet *batman_packet;
new_buff = kmalloc(new_len, GFP_ATOMIC);
/* keep old buffer if kmalloc should fail */
    if (new_buff) {
    	memcpy(new_buff, hard_iface->packet_buff,
- 		       sizeof(*batman_packet));
+ 		       BATMAN_OGM_LEN);
kfree(hard_iface->packet_buff);
    	hard_iface->packet_buff = new_buff;
@@@ -242,60 -97,48 +97,48 @@@
  }
/* when calling this function (hard_iface == primary_if) has to be true */
- static void prepare_packet_buffer(struct bat_priv *bat_priv,
+ static int prepare_packet_buffer(struct bat_priv *bat_priv,
    			  struct hard_iface *hard_iface)
  {
    int new_len;
- 	struct batman_packet *batman_packet;
- 	new_len = BAT_PACKET_LEN +
+ 	new_len = BATMAN_OGM_LEN +
    	  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 = BAT_PACKET_LEN;
+ 		new_len = BATMAN_OGM_LEN;
realloc_packet_buffer(hard_iface, new_len);
- 	batman_packet = (struct batman_packet *)hard_iface->packet_buff;
atomic_set(&bat_priv->tt_crc, tt_local_crc(bat_priv));
/* reset the sending counter */
    atomic_set(&bat_priv->tt_ogm_append_cnt, TT_OGM_APPEND_MAX);
- 	batman_packet->tt_num_changes = tt_changes_fill_buffer(bat_priv,
- 				hard_iface->packet_buff + BAT_PACKET_LEN,
- 				hard_iface->packet_len - BAT_PACKET_LEN);
- 
+ 	return tt_changes_fill_buffer(bat_priv,
+ 				      hard_iface->packet_buff + BATMAN_OGM_LEN,
+ 				      hard_iface->packet_len - BATMAN_OGM_LEN);
  }
- static void reset_packet_buffer(struct bat_priv *bat_priv,
- 	struct hard_iface *hard_iface)
+ static int reset_packet_buffer(struct bat_priv *bat_priv,
+ 				struct hard_iface *hard_iface)
  {
- 	struct batman_packet *batman_packet;
- 
- 	realloc_packet_buffer(hard_iface, BAT_PACKET_LEN);
- 
- 	batman_packet = (struct batman_packet *)hard_iface->packet_buff;
- 	batman_packet->tt_num_changes = 0;
+ 	realloc_packet_buffer(hard_iface, BATMAN_OGM_LEN);
+ 	return 0;
  }
- void schedule_own_packet(struct hard_iface *hard_iface)
+ void schedule_bat_ogm(struct hard_iface *hard_iface)
  {
    struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
    struct hard_iface *primary_if;
- 	unsigned long send_time;
- 	struct batman_packet *batman_packet;
- 	int vis_server;
+ 	int tt_num_changes = -1;
if ((hard_iface->if_status == IF_NOT_IN_USE) ||
        (hard_iface->if_status == IF_TO_BE_REMOVED))
    	return;
- 	vis_server = atomic_read(&bat_priv->vis_mode);
- 	primary_if = primary_if_get_selected(bat_priv);
- 
    /**
     * the interface gets activated here to avoid race conditions between
     * the moment of activating the interface in
@@@ -306,124 -149,26 +149,26 @@@
    if (hard_iface->if_status == IF_TO_BE_ACTIVATED)
    	hard_iface->if_status = IF_ACTIVE;
+ 	primary_if = primary_if_get_selected(bat_priv);
+ 
    if (hard_iface == primary_if) {
    	/* if at least one change happened */
    	if (atomic_read(&bat_priv->tt_local_changes) > 0) {
    		tt_commit_changes(bat_priv);
- 			prepare_packet_buffer(bat_priv, hard_iface);
+ 			tt_num_changes = prepare_packet_buffer(bat_priv,
+ 							       hard_iface);
    	}
- 		/* if the changes have been sent enough times */
+ 		/* if the changes have been sent often enough */
    	if (!atomic_dec_not_zero(&bat_priv->tt_ogm_append_cnt))
- 			reset_packet_buffer(bat_priv, hard_iface);
+ 			tt_num_changes = reset_packet_buffer(bat_priv,
+ 							     hard_iface);
    }
- 	/**
- 	 * NOTE: packet_buff might just have been re-allocated in
- 	 * prepare_packet_buffer() or in reset_packet_buffer()
- 	 */
- 	batman_packet = (struct batman_packet *)hard_iface->packet_buff;
- 
- 	/* change sequence number to network order */
- 	batman_packet->seqno =
- 		htonl((uint32_t)atomic_read(&hard_iface->seqno));
- 
- 	batman_packet->ttvn = atomic_read(&bat_priv->ttvn);
- 	batman_packet->tt_crc = htons((uint16_t)atomic_read(&bat_priv->tt_crc));
- 
- 	if (vis_server == VIS_TYPE_SERVER_SYNC)
- 		batman_packet->flags |= VIS_SERVER;
- 	else
- 		batman_packet->flags &= ~VIS_SERVER;
- 
- 	if ((hard_iface == primary_if) &&
- 	    (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER))
- 		batman_packet->gw_flags =
- 				(uint8_t)atomic_read(&bat_priv->gw_bandwidth);
- 	else
- 		batman_packet->gw_flags = NO_FLAGS;
- 
- 	atomic_inc(&hard_iface->seqno);
- 
- 	slide_own_bcast_window(hard_iface);
- 	send_time = own_send_time(bat_priv);
- 	add_bat_packet_to_list(bat_priv,
- 			       hard_iface->packet_buff,
- 			       hard_iface->packet_len,
- 			       hard_iface, 1, send_time);
- 
    if (primary_if)
    	hardif_free_ref(primary_if);
- }
- 
- void schedule_forward_packet(struct orig_node *orig_node,
- 			     const struct ethhdr *ethhdr,
- 			     struct batman_packet *batman_packet,
- 			     int directlink,
- 			     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;
- 	unsigned long send_time;
- 	uint8_t tt_num_changes;
- 
- 	if (batman_packet->ttl <= 1) {
- 		bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
- 		return;
- 	}
- 
- 	router = orig_node_get_router(orig_node);
- 
- 	in_tq = batman_packet->tq;
- 	in_ttl = batman_packet->ttl;
- 	tt_num_changes = batman_packet->tt_num_changes;
- 
- 	batman_packet->ttl--;
- 	memcpy(batman_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_packet->tq = router->tq_avg;
- 
- 			if (router->last_ttl)
- 				batman_packet->ttl = router->last_ttl - 1;
- 		}
- 
- 		tq_avg = router->tq_avg;
- 	}
- 
- 	if (router)
- 		neigh_node_free_ref(router);
- 
- 	/* apply hop penalty */
- 	batman_packet->tq = hop_penalty(batman_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_packet->tq, in_ttl - 1,
- 		batman_packet->ttl);
- 
- 	batman_packet->seqno = htonl(batman_packet->seqno);
- 	batman_packet->tt_crc = htons(batman_packet->tt_crc);
- 
- 	/* switch of primaries first hop flag when forwarding */
- 	batman_packet->flags &= ~PRIMARIES_FIRST_HOP;
- 	if (directlink)
- 		batman_packet->flags |= DIRECTLINK;
- 	else
- 		batman_packet->flags &= ~DIRECTLINK;
- 	send_time = forward_send_time();
- 	add_bat_packet_to_list(bat_priv,
- 			       (unsigned char *)batman_packet,
- 			       sizeof(*batman_packet) + tt_len(tt_num_changes),
- 			       if_incoming, 0, send_time);
+ 	bat_ogm_schedule(hard_iface, tt_num_changes);
  }
static void forw_packet_free(struct forw_packet *forw_packet)
@@@ -454,7 -199,7 +199,7 @@@ static void _add_bcast_packet_to_list(s
  }
/* add a broadcast packet to the queue and setup timers. broadcast packets
-  * are sent multiple times to increase probability for beeing received.
+  * are sent multiple times to increase probability for being received.
   *
   * This function returns NETDEV_TX_OK on success and NETDEV_TX_BUSY on
   * errors.
@@@ -557,7 -302,7 +302,7 @@@ out
    atomic_inc(&bat_priv->bcast_queue_left);
  }
- void send_outstanding_bat_packet(struct work_struct *work)
+ void send_outstanding_bat_ogm_packet(struct work_struct *work)
  {
    struct delayed_work *delayed_work =
    	container_of(work, struct delayed_work, work);
@@@ -573,7 -318,7 +318,7 @@@
    if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING)
    	goto out;
- 	send_packet(forw_packet);
+ 	bat_ogm_emit(forw_packet);
/**
     * we have to have at least one packet in the queue
@@@ -581,7 -326,7 +326,7 @@@
     * shutting down
     */
    if (forw_packet->own)
- 		schedule_own_packet(forw_packet->if_incoming);
+ 		schedule_bat_ogm(forw_packet->if_incoming);
out:
    /* don't count own packet */
@@@ -612,7 -357,7 +357,7 @@@ void purge_outstanding_packets(struct b
    			  &bat_priv->forw_bcast_list, list) {
/**
- 		 * if purge_outstanding_packets() was called with an argmument
+ 		 * if purge_outstanding_packets() was called with an argument
    	 * we delete only packets belonging to the given interface
    	 */
    	if ((hard_iface) &&
@@@ -641,7 -386,7 +386,7 @@@
    			  &bat_priv->forw_bat_list, list) {
/**
- 		 * if purge_outstanding_packets() was called with an argmument
+ 		 * if purge_outstanding_packets() was called with an argument
    	 * we delete only packets belonging to the given interface
    	 */
    	if ((hard_iface) &&
diff --combined net/batman-adv/send.h
index 1f2d1e8,c8ca3ef..c8ca3ef
--- a/net/batman-adv/send.h
+++ b/net/batman-adv/send.h
@@@ -24,15 -24,10 +24,10 @@@
int send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface,
    	    const uint8_t *dst_addr);
- void schedule_own_packet(struct hard_iface *hard_iface);
- void schedule_forward_packet(struct orig_node *orig_node,
- 			     const struct ethhdr *ethhdr,
- 			     struct batman_packet *batman_packet,
- 			     int directlink,
- 			     struct hard_iface *if_outgoing);
+ void schedule_bat_ogm(struct hard_iface *hard_iface);
  int add_bcast_packet_to_list(struct bat_priv *bat_priv,
    		     const struct sk_buff *skb, unsigned long delay);
- void send_outstanding_bat_packet(struct work_struct *work);
+ void send_outstanding_bat_ogm_packet(struct work_struct *work);
  void purge_outstanding_packets(struct bat_priv *bat_priv,
    		       const struct hard_iface *hard_iface);
diff --combined net/batman-adv/soft-interface.c
index 3e2f91f,aceeabc..aceeabc
--- a/net/batman-adv/soft-interface.c
+++ b/net/batman-adv/soft-interface.c
@@@ -445,30 -445,31 +445,31 @@@ static void softif_batman_recv(struct s
  {
    struct bat_priv *bat_priv = netdev_priv(dev);
    struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
- 	struct batman_packet *batman_packet;
+ 	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_packet = (struct batman_packet *)
+ 		batman_ogm_packet = (struct batman_ogm_packet *)
    				(skb->data + ETH_HLEN + VLAN_HLEN);
    else
- 		batman_packet = (struct batman_packet *)(skb->data + ETH_HLEN);
+ 		batman_ogm_packet = (struct batman_ogm_packet *)
+ 							(skb->data + ETH_HLEN);
- 	if (batman_packet->version != COMPAT_VERSION)
+ 	if (batman_ogm_packet->version != COMPAT_VERSION)
    	goto out;
- 	if (batman_packet->packet_type != BAT_PACKET)
+ 	if (batman_ogm_packet->packet_type != BAT_OGM)
    	goto out;
- 	if (!(batman_packet->flags & PRIMARIES_FIRST_HOP))
+ 	if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
    	goto out;
- 	if (is_my_mac(batman_packet->orig))
+ 	if (is_my_mac(batman_ogm_packet->orig))
    	goto out;
- 	softif_neigh = softif_neigh_get(bat_priv, batman_packet->orig, vid);
+ 	softif_neigh = softif_neigh_get(bat_priv, batman_ogm_packet->orig, vid);
    if (!softif_neigh)
    	goto out;
@@@ -532,11 -533,11 +533,11 @@@ static int interface_set_mac_addr(struc
    if (!is_valid_ether_addr(addr->sa_data))
    	return -EADDRNOTAVAIL;
- 	/* only modify transtable if it has been initialised before */
+ 	/* only modify transtable if it has been initialized before */
    if (atomic_read(&bat_priv->mesh_state) == MESH_ACTIVE) {
    	tt_local_remove(bat_priv, dev->dev_addr,
    			"mac address changed", false);
- 		tt_local_add(dev, addr->sa_data);
+ 		tt_local_add(dev, addr->sa_data, NULL_IFINDEX);
    }
memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
@@@ -595,9 -596,10 +596,10 @@@ static int interface_tx(struct sk_buff 
    	goto dropped;
/* Register the client MAC in the transtable */
- 	tt_local_add(soft_iface, ethhdr->h_source);
+ 	tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
- 	orig_node = transtable_search(bat_priv, ethhdr->h_dest);
+ 	orig_node = transtable_search(bat_priv, ethhdr->h_source,
+ 				      ethhdr->h_dest);
    if (is_multicast_ether_addr(ethhdr->h_dest) ||
    			(orig_node && orig_node->gw_flags)) {
    	ret = gw_is_target(bat_priv, skb, orig_node);
@@@ -739,6 -741,9 +741,9 @@@ void interface_rx(struct net_device *so
soft_iface->last_rx = jiffies;
+ 	if (is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest))
+ 		goto dropped;
+ 
    netif_rx(skb);
    goto out;
@@@ -796,10 -801,8 +801,8 @@@ struct net_device *softif_create(const
soft_iface = alloc_netdev(sizeof(*bat_priv), name, interface_setup);
- 	if (!soft_iface) {
- 		pr_err("Unable to allocate the batman interface: %s\n", name);
+ 	if (!soft_iface)
    	goto out;
- 	}
ret = register_netdevice(soft_iface);
    if (ret < 0) {
@@@ -812,6 -815,7 +815,7 @@@
atomic_set(&bat_priv->aggregated_ogms, 1);
    atomic_set(&bat_priv->bonding, 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);
diff --combined net/batman-adv/translation-table.c
index fb6931d,cc53f78..cc53f78
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@@ -183,7 -183,8 +183,8 @@@ static int tt_local_init(struct bat_pri
    return 1;
  }
- void tt_local_add(struct net_device *soft_iface, const uint8_t *addr)
+ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
+ 		  int ifindex)
  {
    struct bat_priv *bat_priv = netdev_priv(soft_iface);
    struct tt_local_entry *tt_local_entry = NULL;
@@@ -207,6 -208,8 +208,8 @@@
    memcpy(tt_local_entry->addr, addr, ETH_ALEN);
    tt_local_entry->last_seen = jiffies;
    tt_local_entry->flags = NO_FLAGS;
+ 	if (is_wifi_iface(ifindex))
+ 		tt_local_entry->flags |= TT_CLIENT_WIFI;
    atomic_set(&tt_local_entry->refcount, 2);
/* the batman interface mac address should never be purged */
@@@ -329,7 -332,7 +332,7 @@@ int tt_local_seq_print_text(struct seq_
rcu_read_lock();
    	__hlist_for_each_rcu(node, head)
- 			buf_size += 21;
+ 			buf_size += 29;
    	rcu_read_unlock();
    }
@@@ -348,8 -351,19 +351,19 @@@
    	rcu_read_lock();
    	hlist_for_each_entry_rcu(tt_local_entry, node,
    				 head, hash_entry) {
- 			pos += snprintf(buff + pos, 22, " * %pM\n",
- 					tt_local_entry->addr);
+ 			pos += snprintf(buff + pos, 30, " * %pM "
+ 					"[%c%c%c%c%c]\n",
+ 					tt_local_entry->addr,
+ 					(tt_local_entry->flags &
+ 					 TT_CLIENT_ROAM ? 'R' : '.'),
+ 					(tt_local_entry->flags &
+ 					 TT_CLIENT_NOPURGE ? 'P' : '.'),
+ 					(tt_local_entry->flags &
+ 					 TT_CLIENT_NEW ? 'N' : '.'),
+ 					(tt_local_entry->flags &
+ 					 TT_CLIENT_PENDING ? 'X' : '.'),
+ 					(tt_local_entry->flags &
+ 					 TT_CLIENT_WIFI ? 'W' : '.'));
    	}
    	rcu_read_unlock();
    }
@@@ -369,8 -383,8 +383,8 @@@ static void tt_local_set_pending(struc
    tt_local_event(bat_priv, tt_local_entry->addr,
    	       tt_local_entry->flags | flags);
- 	/* The local client has to be merked as "pending to be removed" but has
- 	 * to be kept in the table in order to send it in an full tables
+ 	/* The local client has to be marked as "pending to be removed" but has
+ 	 * to be kept in the table in order to send it in a full table
     * response issued before the net ttvn increment (consistency check) */
    tt_local_entry->flags |= TT_CLIENT_PENDING;
  }
@@@ -495,7 -509,8 +509,8 @@@ static void tt_changes_list_free(struc
/* 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)
+ 		  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;
@@@ -537,6 -552,9 +552,9 @@@
    	tt_global_entry->roam_at = 0;
    }
+ 	if (wifi)
+ 		tt_global_entry->flags |= TT_CLIENT_WIFI;
+ 
    bat_dbg(DBG_TT, bat_priv,
    	"Creating new global tt entry: %pM (via %pM)\n",
    	tt_global_entry->addr, orig_node->orig);
@@@ -582,8 -600,8 +600,8 @@@ int tt_global_seq_print_text(struct seq
    seq_printf(seq,
    	   "Globally announced TT entries received via the mesh %s\n",
    	   net_dev->name);
- 	seq_printf(seq, "       %-13s %s       %-15s %s\n",
- 		   "Client", "(TTVN)", "Originator", "(Curr TTVN)");
+ 	seq_printf(seq, "       %-13s %s       %-15s %s %s\n",
+ 		   "Client", "(TTVN)", "Originator", "(Curr TTVN)", "Flags");
buf_size = 1;
    /* Estimate length for: " * xx:xx:xx:xx:xx:xx (ttvn) via
@@@ -593,7 -611,7 +611,7 @@@
rcu_read_lock();
    	__hlist_for_each_rcu(node, head)
- 			buf_size += 59;
+ 			buf_size += 67;
    	rcu_read_unlock();
    }
@@@ -612,14 -630,20 +630,20 @@@
    	rcu_read_lock();
    	hlist_for_each_entry_rcu(tt_global_entry, node,
    				 head, hash_entry) {
- 			pos += snprintf(buff + pos, 61,
- 					" * %pM  (%3u) via %pM     (%3u)\n",
- 					tt_global_entry->addr,
+ 			pos += snprintf(buff + pos, 69,
+ 					" * %pM  (%3u) via %pM     (%3u)   "
+ 					"[%c%c%c]\n", tt_global_entry->addr,
    				tt_global_entry->ttvn,
    				tt_global_entry->orig_node->orig,
    				(uint8_t) atomic_read(
    					&tt_global_entry->orig_node->
- 						last_ttvn));
+ 						last_ttvn),
+ 					(tt_global_entry->flags &
+ 					 TT_CLIENT_ROAM ? 'R' : '.'),
+ 					(tt_global_entry->flags &
+ 					 TT_CLIENT_PENDING ? 'X' : '.'),
+ 					(tt_global_entry->flags &
+ 					 TT_CLIENT_WIFI ? 'W' : '.'));
    	}
    	rcu_read_unlock();
    }
@@@ -774,30 -798,56 +798,56 @@@ static void tt_global_table_free(struc
    bat_priv->tt_global_hash = NULL;
  }
+ static bool _is_ap_isolated(struct tt_local_entry *tt_local_entry,
+ 			    struct tt_global_entry *tt_global_entry)
+ {
+ 	bool ret = false;
+ 
+ 	if (tt_local_entry->flags & TT_CLIENT_WIFI &&
+ 	    tt_global_entry->flags & TT_CLIENT_WIFI)
+ 		ret = true;
+ 
+ 	return ret;
+ }
+ 
  struct orig_node *transtable_search(struct bat_priv *bat_priv,
- 				    const uint8_t *addr)
+ 				    const uint8_t *src, const uint8_t *addr)
  {
- 	struct tt_global_entry *tt_global_entry;
+ 	struct tt_local_entry *tt_local_entry = NULL;
+ 	struct tt_global_entry *tt_global_entry = NULL;
    struct orig_node *orig_node = NULL;
- 	tt_global_entry = tt_global_hash_find(bat_priv, addr);
+ 	if (src && atomic_read(&bat_priv->ap_isolation)) {
+ 		tt_local_entry = tt_local_hash_find(bat_priv, src);
+ 		if (!tt_local_entry)
+ 			goto out;
+ 	}
+ 	tt_global_entry = tt_global_hash_find(bat_priv, addr);
    if (!tt_global_entry)
    	goto out;
+ 	/* check whether the clients should not communicate due to AP
+ 	 * isolation */
+ 	if (tt_local_entry && _is_ap_isolated(tt_local_entry, tt_global_entry))
+ 		goto out;
+ 
    if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount))
- 		goto free_tt;
+ 		goto out;
/* A global client marked as PENDING has already moved from that
     * originator */
    if (tt_global_entry->flags & TT_CLIENT_PENDING)
- 		goto free_tt;
+ 		goto out;
orig_node = tt_global_entry->orig_node;
- free_tt:
- 	tt_global_entry_free_ref(tt_global_entry);
  out:
+ 	if (tt_global_entry)
+ 		tt_global_entry_free_ref(tt_global_entry);
+ 	if (tt_local_entry)
+ 		tt_local_entry_free_ref(tt_local_entry);
+ 
    return orig_node;
  }
@@@ -1029,8 -1079,9 +1079,9 @@@ out
    return skb;
  }
- int send_tt_request(struct bat_priv *bat_priv, struct orig_node *dst_orig_node,
- 		    uint8_t ttvn, uint16_t tt_crc, bool full_table)
+ static int send_tt_request(struct bat_priv *bat_priv,
+ 			   struct orig_node *dst_orig_node,
+ 			   uint8_t ttvn, uint16_t tt_crc, bool full_table)
  {
    struct sk_buff *skb = NULL;
    struct tt_query_packet *tt_request;
@@@ -1137,12 -1188,12 +1188,12 @@@ static bool send_other_tt_response(stru
    orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
    req_ttvn = tt_request->ttvn;
- 	/* I have not the requested data */
+ 	/* I don't have the requested data */
    if (orig_ttvn != req_ttvn ||
        tt_request->tt_data != req_dst_orig_node->tt_crc)
    	goto out;
- 	/* If it has explicitly been requested the full table */
+ 	/* If the full table has been explicitly requested */
    if (tt_request->flags & TT_FULL_TABLE ||
        !req_dst_orig_node->tt_buff)
    	full_table = true;
@@@ -1363,7 -1414,9 +1414,9 @@@ static void _tt_update_changes(struct b
    			      (tt_change + i)->flags & TT_CLIENT_ROAM);
    	else
    		if (!tt_global_add(bat_priv, orig_node,
- 					   (tt_change + i)->addr, ttvn, false))
+ 					   (tt_change + i)->addr, ttvn, false,
+ 					   (tt_change + i)->flags &
+ 							TT_CLIENT_WIFI))
    			/* In case of problem while storing a
    			 * global_entry, we stop the updating
    			 * procedure without committing the
@@@ -1403,9 -1456,10 +1456,10 @@@ out
    	orig_node_free_ref(orig_node);
  }
- void tt_update_changes(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 		       uint16_t tt_num_changes, uint8_t ttvn,
- 		       struct tt_change *tt_change)
+ static void tt_update_changes(struct bat_priv *bat_priv,
+ 			      struct orig_node *orig_node,
+ 			      uint16_t tt_num_changes, uint8_t ttvn,
+ 			      struct tt_change *tt_change)
  {
    _tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes,
    		   ttvn);
@@@ -1720,3 -1774,90 +1774,90 @@@ void tt_commit_changes(struct bat_priv 
    atomic_inc(&bat_priv->ttvn);
    bat_priv->tt_poss_change = false;
  }
+ 
+ bool is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, uint8_t *dst)
+ {
+ 	struct tt_local_entry *tt_local_entry = NULL;
+ 	struct tt_global_entry *tt_global_entry = NULL;
+ 	bool ret = true;
+ 
+ 	if (!atomic_read(&bat_priv->ap_isolation))
+ 		return false;
+ 
+ 	tt_local_entry = tt_local_hash_find(bat_priv, dst);
+ 	if (!tt_local_entry)
+ 		goto out;
+ 
+ 	tt_global_entry = tt_global_hash_find(bat_priv, src);
+ 	if (!tt_global_entry)
+ 		goto out;
+ 
+ 	if (_is_ap_isolated(tt_local_entry, tt_global_entry))
+ 		goto out;
+ 
+ 	ret = false;
+ 
+ out:
+ 	if (tt_global_entry)
+ 		tt_global_entry_free_ref(tt_global_entry);
+ 	if (tt_local_entry)
+ 		tt_local_entry_free_ref(tt_local_entry);
+ 	return ret;
+ }
+ 
+ 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)
+ {
+ 	uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
+ 	bool full_table = true;
+ 
+ 	/* the ttvn increased by one -> we can apply the attached changes */
+ 	if (ttvn - orig_ttvn == 1) {
+ 		/* the OGM could not contain the changes due to their size or
+ 		 * because they have already been sent TT_OGM_APPEND_MAX times.
+ 		 * In this case send a tt request */
+ 		if (!tt_num_changes) {
+ 			full_table = false;
+ 			goto request_table;
+ 		}
+ 
+ 		tt_update_changes(bat_priv, orig_node, tt_num_changes, ttvn,
+ 				  (struct tt_change *)tt_buff);
+ 
+ 		/* Even if we received the precomputed crc with the OGM, we
+ 		 * prefer to recompute it to spot any possible inconsistency
+ 		 * in the global table */
+ 		orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
+ 
+ 		/* The ttvn alone is not enough to guarantee consistency
+ 		 * because a single value could represent different states
+ 		 * (due to the wrap around). Thus a node has to check whether
+ 		 * the resulting table (after applying the changes) is still
+ 		 * consistent or not. E.g. a node could disconnect while its
+ 		 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
+ 		 * checking the CRC value is mandatory to detect the
+ 		 * inconsistency */
+ 		if (orig_node->tt_crc != tt_crc)
+ 			goto request_table;
+ 
+ 		/* Roaming phase is over: tables are in sync again. I can
+ 		 * unset the flag */
+ 		orig_node->tt_poss_change = false;
+ 	} else {
+ 		/* if we missed more than one change or our tables are not
+ 		 * in sync anymore -> request fresh tt data */
+ 		if (ttvn != orig_ttvn || orig_node->tt_crc != tt_crc) {
+ request_table:
+ 			bat_dbg(DBG_TT, bat_priv, "TT inconsistency for %pM. "
+ 				"Need to retrieve the correct information "
+ 				"(ttvn: %u last_ttvn: %u crc: %u last_crc: "
+ 				"%u num_changes: %u)\n", orig_node->orig, ttvn,
+ 				orig_ttvn, tt_crc, orig_node->tt_crc,
+ 				tt_num_changes);
+ 			send_tt_request(bat_priv, orig_node, ttvn, tt_crc,
+ 					full_table);
+ 			return;
+ 		}
+ 	}
+ }
diff --combined net/batman-adv/translation-table.h
index d4122cb,30efd49..30efd49
--- a/net/batman-adv/translation-table.h
+++ b/net/batman-adv/translation-table.h
@@@ -26,15 -26,16 +26,16 @@@ int tt_len(int changes_num)
  int tt_changes_fill_buffer(struct bat_priv *bat_priv,
    		   unsigned char *buff, int buff_len);
  int tt_init(struct bat_priv *bat_priv);
- void tt_local_add(struct net_device *soft_iface, const uint8_t *addr);
+ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
+ 		  int ifindex);
  void tt_local_remove(struct bat_priv *bat_priv,
    	     const uint8_t *addr, const char *message, bool roaming);
  int tt_local_seq_print_text(struct seq_file *seq, void *offset);
  void tt_global_add_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
    		const unsigned char *tt_buff, int tt_buff_len);
- int tt_global_add(struct bat_priv *bat_priv,
- 		  struct orig_node *orig_node, const unsigned char *addr,
- 		  uint8_t ttvn, bool roaming);
+ int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
+ 		  const unsigned char *addr, uint8_t ttvn, bool roaming,
+ 		  bool wifi);
  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);
@@@ -42,25 -43,23 +43,23 @@@ void tt_global_del(struct bat_priv *bat
    	   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 *addr);
+ 				    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);
- int send_tt_request(struct bat_priv *bat_priv,
- 		    struct orig_node *dst_orig_node, uint8_t hvn,
- 		    uint16_t tt_crc, bool full_table);
  bool send_tt_response(struct bat_priv *bat_priv,
    	      struct tt_query_packet *tt_request);
- void tt_update_changes(struct bat_priv *bat_priv, struct orig_node *orig_node,
- 		       uint16_t tt_num_changes, uint8_t ttvn,
- 		       struct tt_change *tt_change);
  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);
#endif /* _NET_BATMAN_ADV_TRANSLATION_TABLE_H_ */
diff --combined net/batman-adv/types.h
index 25bd1db,1ae3557..1ae3557
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@@ -57,7 -57,7 +57,7 @@@ struct hard_iface 
   *	@batman_seqno_reset: time when the batman seqno window was reset
   *	@gw_flags: flags related to gateway class
   *	@flags: for now only VIS_SERVER flag
-  *	@last_real_seqno: last and best known squence number
+  *	@last_real_seqno: last and best known sequence number
   *	@last_ttl: ttl of last received packet
   *	@last_bcast_seqno: last broadcast sequence number received by this host
   *
@@@ -146,6 -146,7 +146,7 @@@ struct bat_priv 
    atomic_t aggregated_ogms;	/* boolean */
    atomic_t bonding;		/* boolean */
    atomic_t fragmentation;		/* boolean */
+ 	atomic_t ap_isolation;		/* boolean */
    atomic_t vis_mode;		/* VIS_TYPE_* */
    atomic_t gw_mode;		/* GW_MODE_* */
    atomic_t gw_sel_class;		/* uint */
@@@ -156,7 -157,7 +157,7 @@@
    atomic_t bcast_seqno;
    atomic_t bcast_queue_left;
    atomic_t batman_queue_left;
- 	atomic_t ttvn; /* tranlation table version number */
+ 	atomic_t ttvn; /* translation table version number */
    atomic_t tt_ogm_append_cnt;
    atomic_t tt_local_changes; /* changes registered in a OGM interval */
    /* The tt_poss_change flag is used to detect an ongoing roaming phase.
diff --combined net/batman-adv/unicast.c
index 32b125f,07d1c1d..07d1c1d
--- a/net/batman-adv/unicast.c
+++ b/net/batman-adv/unicast.c
@@@ -299,8 -299,10 +299,10 @@@ int unicast_send_skb(struct sk_buff *sk
    		goto find_router;
    }
- 	/* check for tt host - increases orig_node refcount */
- 	orig_node = transtable_search(bat_priv, ethhdr->h_dest);
+ 	/* check for tt host - increases orig_node refcount.
+ 	 * returns NULL in case of AP isolation */
+ 	orig_node = transtable_search(bat_priv, ethhdr->h_source,
+ 				      ethhdr->h_dest);
find_router:
    /**
diff --combined net/batman-adv/unicast.h
index 62f54b9,8fd5535..8fd5535
--- a/net/batman-adv/unicast.h
+++ b/net/batman-adv/unicast.h
@@@ -24,7 -24,7 +24,7 @@@
#include "packet.h"
- #define FRAG_TIMEOUT 10000	/* purge frag list entrys after time in ms */
+ #define FRAG_TIMEOUT 10000	/* purge frag list entries after time in ms */
  #define FRAG_BUFFER_SIZE 6	/* number of list elements in buffer */
int frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv,
diff --combined net/batman-adv/vis.c
index 8a1b985,f81a6b6..f81a6b6
--- a/net/batman-adv/vis.c
+++ b/net/batman-adv/vis.c
@@@ -131,7 -131,7 +131,7 @@@ static void vis_data_insert_interface(c
    		return;
    }
- 	/* its a new address, add it to the list */
+ 	/* it's a new address, add it to the list */
    entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
    if (!entry)
    	return;
@@@ -465,7 -465,7 +465,7 @@@ static struct vis_info *add_packet(stru
    /* try to add it */
    hash_added = hash_add(bat_priv->vis_hash, vis_info_cmp, vis_info_choose,
    		      info, &info->hash_entry);
- 	if (hash_added < 0) {
+ 	if (hash_added != 0) {
    	/* did not work (for some reason) */
    	kref_put(&info->refcount, free_info);
    	info = NULL;
@@@ -887,10 -887,8 +887,8 @@@ int vis_init(struct bat_priv *bat_priv
    }
bat_priv->my_vis_info = kmalloc(MAX_VIS_PACKET_SIZE, GFP_ATOMIC);
- 	if (!bat_priv->my_vis_info) {
- 		pr_err("Can't initialize vis packet\n");
+ 	if (!bat_priv->my_vis_info)
    	goto err;
- 	}
bat_priv->my_vis_info->skb_packet = dev_alloc_skb(sizeof(*packet) +
    						  MAX_VIS_PACKET_SIZE +
@@@ -920,7 -918,7 +918,7 @@@
    hash_added = hash_add(bat_priv->vis_hash, vis_info_cmp, vis_info_choose,
    		      bat_priv->my_vis_info,
    		      &bat_priv->my_vis_info->hash_entry);
- 	if (hash_added < 0) {
+ 	if (hash_added != 0) {
    	pr_err("Can't add own vis packet into hash\n");
    	/* not in hash, need to remove it manually. */
    	kref_put(&bat_priv->my_vis_info->refcount, free_info);
-- 
linux integration

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

[commits] linux integration; branch, merge/master, updated. v3.1-rc1-1105-g7ff4216