[commits] linux integration; branch, linux, updated. v2.6.36-rc8-530-g137f968

25 Oct 2010

The following commit has been merged in the linux branch:
commit 137f96870c4736bb7a9a27b1851ab9341f6c6758
Merge: 4f5cbb3ec93661322de87d9756e9a38c7708d268 ac7816995707ee7446a828c7245baba69113d56d
Author: Sven Eckelmann sven.eckelmann@gmx.de
Date:   Mon Oct 25 23:30:47 2010 +0200
Merge remote branch 'origin/next' into linux
diff --combined drivers/staging/batman-adv/hard-interface.c
index 7b77cf2,0000000..80cfa86
mode 100644,000000..100644

--- a/drivers/staging/batman-adv/hard-interface.c
+++ b/drivers/staging/batman-adv/hard-interface.c
@@@ -1,637 -1,0 +1,635 @@@
 +/*
 + * Copyright (C) 2007-2010 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 "hard-interface.h"
 +#include "soft-interface.h"
 +#include "send.h"
 +#include "translation-table.h"
 +#include "routing.h"
 +#include "bat_sysfs.h"
 +#include "originator.h"
 +#include "hash.h"
 +
 +#include <linux/if_arp.h>
 +
 +#define MIN(x, y) ((x) < (y) ? (x) : (y))
 +
 +/* protect update critical side of if_list - but not the content */
 +static DEFINE_SPINLOCK(if_list_lock);
 +
 +struct batman_if *get_batman_if_by_netdev(struct net_device *net_dev)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->net_dev == net_dev)
 +			goto out;
 +	}
 +
 +	batman_if = NULL;
 +
 +out:
 +	if (batman_if)
 +		hardif_hold(batman_if);
 +
 +	rcu_read_unlock();
 +	return batman_if;
 +}
 +
 +static int is_valid_iface(struct net_device *net_dev)
 +{
 +	if (net_dev->flags & IFF_LOOPBACK)
 +		return 0;
 +
 +	if (net_dev->type != ARPHRD_ETHER)
 +		return 0;
 +
 +	if (net_dev->addr_len != ETH_ALEN)
 +		return 0;
 +
 +	/* no batman over batman */
 +#ifdef HAVE_NET_DEVICE_OPS
 +	if (net_dev->netdev_ops->ndo_start_xmit == interface_tx)
 +		return 0;
 +#else
 +	if (net_dev->hard_start_xmit == interface_tx)
 +		return 0;
 +#endif
 +
 +	/* Device is being bridged */
 +	/* if (net_dev->priv_flags & IFF_BRIDGE_PORT)
 +		return 0; */
 +
 +	return 1;
 +}
 +
 +static struct batman_if *get_active_batman_if(struct net_device *soft_iface)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->soft_iface != soft_iface)
 +			continue;
 +
 +		if (batman_if->if_status == IF_ACTIVE)
 +			goto out;
 +	}
 +
 +	batman_if = NULL;
 +
 +out:
 +	if (batman_if)
 +		hardif_hold(batman_if);
 +
 +	rcu_read_unlock();
 +	return batman_if;
 +}
 +
 +static void update_primary_addr(struct bat_priv *bat_priv)
 +{
 +	struct vis_packet *vis_packet;
 +
 +	vis_packet = (struct vis_packet *)
 +				bat_priv->my_vis_info->skb_packet->data;
 +	memcpy(vis_packet->vis_orig,
 +	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +	memcpy(vis_packet->sender_orig,
 +	       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +}
 +
 +static void set_primary_if(struct bat_priv *bat_priv,
 +			   struct batman_if *batman_if)
 +{
 +	struct batman_packet *batman_packet;
 +	struct batman_if *old_if;
 +
 +	if (batman_if)
 +		hardif_hold(batman_if);
 +
 +	old_if = bat_priv->primary_if;
 +	bat_priv->primary_if = batman_if;
 +
 +	if (old_if)
 +		hardif_put(old_if);
 +
 +	if (!bat_priv->primary_if)
 +		return;
 +
 +	batman_packet = (struct batman_packet *)(batman_if->packet_buff);
 +	batman_packet->flags = PRIMARIES_FIRST_HOP;
 +	batman_packet->ttl = TTL;
 +
 +	update_primary_addr(bat_priv);
 +
 +	/***
 +	 * hacky trick to make sure that we send the HNA information via
 +	 * our new primary interface
 +	 */
 +	atomic_set(&bat_priv->hna_local_changed, 1);
 +}
 +
 +static bool hardif_is_iface_up(struct batman_if *batman_if)
 +{
 +	if (batman_if->net_dev->flags & IFF_UP)
 +		return true;
 +
 +	return false;
 +}
 +
 +static void update_mac_addresses(struct batman_if *batman_if)
 +{
- 	addr_to_string(batman_if->addr_str, batman_if->net_dev->dev_addr);
- 
 +	memcpy(((struct batman_packet *)(batman_if->packet_buff))->orig,
 +	       batman_if->net_dev->dev_addr, ETH_ALEN);
 +	memcpy(((struct batman_packet *)(batman_if->packet_buff))->prev_sender,
 +	       batman_if->net_dev->dev_addr, ETH_ALEN);
 +}
 +
 +static void check_known_mac_addr(uint8_t *addr)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if ((batman_if->if_status != IF_ACTIVE) &&
 +		    (batman_if->if_status != IF_TO_BE_ACTIVATED))
 +			continue;
 +
 +		if (!compare_orig(batman_if->net_dev->dev_addr, addr))
 +			continue;
 +
 +		pr_warning("The newly added mac address (%pM) already exists "
 +			   "on: %s\n", addr, batman_if->net_dev->name);
 +		pr_warning("It is strongly recommended to keep mac addresses "
 +			   "unique to avoid problems!\n");
 +	}
 +	rcu_read_unlock();
 +}
 +
 +int hardif_min_mtu(struct net_device *soft_iface)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +	struct batman_if *batman_if;
 +	/* allow big frames if all devices are capable to do so
 +	 * (have MTU > 1500 + BAT_HEADER_LEN) */
 +	int min_mtu = ETH_DATA_LEN;
 +
 +	if (atomic_read(&bat_priv->frag_enabled))
 +		goto out;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if ((batman_if->if_status != IF_ACTIVE) &&
 +		    (batman_if->if_status != IF_TO_BE_ACTIVATED))
 +			continue;
 +
 +		if (batman_if->soft_iface != soft_iface)
 +			continue;
 +
 +		min_mtu = MIN(batman_if->net_dev->mtu - BAT_HEADER_LEN,
 +			      min_mtu);
 +	}
 +	rcu_read_unlock();
 +out:
 +	return min_mtu;
 +}
 +
 +/* adjusts the MTU if a new interface with a smaller MTU appeared. */
 +void update_min_mtu(struct net_device *soft_iface)
 +{
 +	int min_mtu;
 +
 +	min_mtu = hardif_min_mtu(soft_iface);
 +	if (soft_iface->mtu != min_mtu)
 +		soft_iface->mtu = min_mtu;
 +}
 +
 +static void hardif_activate_interface(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv;
 +
 +	if (batman_if->if_status != IF_INACTIVE)
 +		return;
 +
 +	bat_priv = netdev_priv(batman_if->soft_iface);
 +
 +	update_mac_addresses(batman_if);
 +	batman_if->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
 +	 */
 +	if (!bat_priv->primary_if)
 +		set_primary_if(bat_priv, batman_if);
 +
 +	bat_info(batman_if->soft_iface, "Interface activated: %s\n",
 +		 batman_if->net_dev->name);
 +
 +	update_min_mtu(batman_if->soft_iface);
 +	return;
 +}
 +
 +static void hardif_deactivate_interface(struct batman_if *batman_if)
 +{
 +	if ((batman_if->if_status != IF_ACTIVE) &&
 +	   (batman_if->if_status != IF_TO_BE_ACTIVATED))
 +		return;
 +
 +	batman_if->if_status = IF_INACTIVE;
 +
 +	bat_info(batman_if->soft_iface, "Interface deactivated: %s\n",
 +		 batman_if->net_dev->name);
 +
 +	update_min_mtu(batman_if->soft_iface);
 +}
 +
 +int hardif_enable_interface(struct batman_if *batman_if, char *iface_name)
 +{
 +	struct bat_priv *bat_priv;
 +	struct batman_packet *batman_packet;
 +
 +	if (batman_if->if_status != IF_NOT_IN_USE)
 +		goto out;
 +
 +	batman_if->soft_iface = dev_get_by_name(&init_net, iface_name);
 +
 +	if (!batman_if->soft_iface) {
 +		batman_if->soft_iface = softif_create(iface_name);
 +
 +		if (!batman_if->soft_iface)
 +			goto err;
 +
 +		/* dev_get_by_name() increases the reference counter for us */
 +		dev_hold(batman_if->soft_iface);
 +	}
 +
 +	bat_priv = netdev_priv(batman_if->soft_iface);
 +	batman_if->packet_len = BAT_PACKET_LEN;
 +	batman_if->packet_buff = kmalloc(batman_if->packet_len, GFP_ATOMIC);
 +
 +	if (!batman_if->packet_buff) {
 +		bat_err(batman_if->soft_iface, "Can't add interface packet "
 +			"(%s): out of memory\n", batman_if->net_dev->name);
 +		goto err;
 +	}
 +
 +	batman_packet = (struct batman_packet *)(batman_if->packet_buff);
 +	batman_packet->packet_type = BAT_PACKET;
 +	batman_packet->version = COMPAT_VERSION;
 +	batman_packet->flags = 0;
 +	batman_packet->ttl = 2;
 +	batman_packet->tq = TQ_MAX_VALUE;
 +	batman_packet->num_hna = 0;
 +
 +	batman_if->if_num = bat_priv->num_ifaces;
 +	bat_priv->num_ifaces++;
 +	batman_if->if_status = IF_INACTIVE;
 +	orig_hash_add_if(batman_if, bat_priv->num_ifaces);
 +
 +	batman_if->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN);
 +	batman_if->batman_adv_ptype.func = batman_skb_recv;
 +	batman_if->batman_adv_ptype.dev = batman_if->net_dev;
 +	hardif_hold(batman_if);
 +	dev_add_pack(&batman_if->batman_adv_ptype);
 +
 +	atomic_set(&batman_if->seqno, 1);
 +	atomic_set(&batman_if->frag_seqno, 1);
 +	bat_info(batman_if->soft_iface, "Adding interface: %s\n",
 +		 batman_if->net_dev->name);
 +
 +	if (atomic_read(&bat_priv->frag_enabled) && batman_if->net_dev->mtu <
 +		ETH_DATA_LEN + BAT_HEADER_LEN)
 +		bat_info(batman_if->soft_iface,
 +			"The MTU of interface %s is too small (%i) to handle "
 +			"the transport of batman-adv packets. Packets going "
 +			"over this interface will be fragmented on layer2 "
 +			"which could impact the performance. Setting the MTU "
 +			"to %zi would solve the problem.\n",
 +			batman_if->net_dev->name, batman_if->net_dev->mtu,
 +			ETH_DATA_LEN + BAT_HEADER_LEN);
 +
 +	if (!atomic_read(&bat_priv->frag_enabled) && batman_if->net_dev->mtu <
 +		ETH_DATA_LEN + BAT_HEADER_LEN)
 +		bat_info(batman_if->soft_iface,
 +			"The MTU of interface %s is too small (%i) to handle "
 +			"the transport of batman-adv packets. If you experience"
 +			" problems getting traffic through try increasing the "
 +			"MTU to %zi.\n",
 +			batman_if->net_dev->name, batman_if->net_dev->mtu,
 +			ETH_DATA_LEN + BAT_HEADER_LEN);
 +
 +	if (hardif_is_iface_up(batman_if))
 +		hardif_activate_interface(batman_if);
 +	else
 +		bat_err(batman_if->soft_iface, "Not using interface %s "
 +			"(retrying later): interface not active\n",
 +			batman_if->net_dev->name);
 +
 +	/* begin scheduling originator messages on that interface */
 +	schedule_own_packet(batman_if);
 +
 +out:
 +	return 0;
 +
 +err:
 +	return -ENOMEM;
 +}
 +
 +void hardif_disable_interface(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +
 +	if (batman_if->if_status == IF_ACTIVE)
 +		hardif_deactivate_interface(batman_if);
 +
 +	if (batman_if->if_status != IF_INACTIVE)
 +		return;
 +
 +	bat_info(batman_if->soft_iface, "Removing interface: %s\n",
 +		 batman_if->net_dev->name);
 +	dev_remove_pack(&batman_if->batman_adv_ptype);
 +	hardif_put(batman_if);
 +
 +	bat_priv->num_ifaces--;
 +	orig_hash_del_if(batman_if, bat_priv->num_ifaces);
 +
 +	if (batman_if == bat_priv->primary_if) {
 +		struct batman_if *new_if;
 +
 +		new_if = get_active_batman_if(batman_if->soft_iface);
 +		set_primary_if(bat_priv, new_if);
 +
 +		if (new_if)
 +			hardif_put(new_if);
 +	}
 +
 +	kfree(batman_if->packet_buff);
 +	batman_if->packet_buff = NULL;
 +	batman_if->if_status = IF_NOT_IN_USE;
 +
 +	/* delete all references to this batman_if */
 +	purge_orig_ref(bat_priv);
 +	purge_outstanding_packets(bat_priv, batman_if);
 +	dev_put(batman_if->soft_iface);
 +
 +	/* nobody uses this interface anymore */
 +	if (!bat_priv->num_ifaces)
 +		softif_destroy(batman_if->soft_iface);
 +
 +	batman_if->soft_iface = NULL;
 +}
 +
 +static struct batman_if *hardif_add_interface(struct net_device *net_dev)
 +{
 +	struct batman_if *batman_if;
 +	int ret;
 +
 +	ret = is_valid_iface(net_dev);
 +	if (ret != 1)
 +		goto out;
 +
 +	dev_hold(net_dev);
 +
 +	batman_if = kmalloc(sizeof(struct batman_if), GFP_ATOMIC);
 +	if (!batman_if) {
 +		pr_err("Can't add interface (%s): out of memory\n",
 +		       net_dev->name);
 +		goto release_dev;
 +	}
 +
 +	ret = sysfs_add_hardif(&batman_if->hardif_obj, net_dev);
 +	if (ret)
 +		goto free_if;
 +
 +	batman_if->if_num = -1;
 +	batman_if->net_dev = net_dev;
 +	batman_if->soft_iface = NULL;
 +	batman_if->if_status = IF_NOT_IN_USE;
 +	INIT_LIST_HEAD(&batman_if->list);
 +	atomic_set(&batman_if->refcnt, 0);
 +	hardif_hold(batman_if);
 +
 +	check_known_mac_addr(batman_if->net_dev->dev_addr);
 +
 +	spin_lock(&if_list_lock);
 +	list_add_tail_rcu(&batman_if->list, &if_list);
 +	spin_unlock(&if_list_lock);
 +
 +	/* extra reference for return */
 +	hardif_hold(batman_if);
 +	return batman_if;
 +
 +free_if:
 +	kfree(batman_if);
 +release_dev:
 +	dev_put(net_dev);
 +out:
 +	return NULL;
 +}
 +
 +static void hardif_remove_interface(struct batman_if *batman_if)
 +{
 +	/* first deactivate interface */
 +	if (batman_if->if_status != IF_NOT_IN_USE)
 +		hardif_disable_interface(batman_if);
 +
 +	if (batman_if->if_status != IF_NOT_IN_USE)
 +		return;
 +
 +	batman_if->if_status = IF_TO_BE_REMOVED;
 +
 +	/* caller must take if_list_lock */
 +	list_del_rcu(&batman_if->list);
 +	synchronize_rcu();
 +	sysfs_del_hardif(&batman_if->hardif_obj);
 +	hardif_put(batman_if);
 +}
 +
 +void hardif_remove_interfaces(void)
 +{
 +	struct batman_if *batman_if, *batman_if_tmp;
 +
 +	rtnl_lock();
 +	spin_lock(&if_list_lock);
 +	list_for_each_entry_safe(batman_if, batman_if_tmp, &if_list, list) {
 +		hardif_remove_interface(batman_if);
 +	}
 +	spin_unlock(&if_list_lock);
 +	rtnl_unlock();
 +}
 +
 +static int hard_if_event(struct notifier_block *this,
 +			 unsigned long event, void *ptr)
 +{
 +	struct net_device *net_dev = (struct net_device *)ptr;
 +	struct batman_if *batman_if = get_batman_if_by_netdev(net_dev);
 +	struct bat_priv *bat_priv;
 +
 +	if (!batman_if && event == NETDEV_REGISTER)
 +		batman_if = hardif_add_interface(net_dev);
 +
 +	if (!batman_if)
 +		goto out;
 +
 +	switch (event) {
 +	case NETDEV_UP:
 +		hardif_activate_interface(batman_if);
 +		break;
 +	case NETDEV_GOING_DOWN:
 +	case NETDEV_DOWN:
 +		hardif_deactivate_interface(batman_if);
 +		break;
 +	case NETDEV_UNREGISTER:
 +		spin_lock(&if_list_lock);
 +		hardif_remove_interface(batman_if);
 +		spin_unlock(&if_list_lock);
 +		break;
 +	case NETDEV_CHANGEMTU:
 +		if (batman_if->soft_iface)
 +			update_min_mtu(batman_if->soft_iface);
 +		break;
 +	case NETDEV_CHANGEADDR:
 +		if (batman_if->if_status == IF_NOT_IN_USE) {
 +			hardif_put(batman_if);
 +			goto out;
 +		}
 +
 +		check_known_mac_addr(batman_if->net_dev->dev_addr);
 +		update_mac_addresses(batman_if);
 +
 +		bat_priv = netdev_priv(batman_if->soft_iface);
 +		if (batman_if == bat_priv->primary_if)
 +			update_primary_addr(bat_priv);
 +		break;
 +	default:
 +		break;
 +	};
 +	hardif_put(batman_if);
 +
 +out:
 +	return NOTIFY_DONE;
 +}
 +
 +/* receive a packet with the batman ethertype coming on a hard
 + * interface */
 +int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
 +	struct packet_type *ptype, struct net_device *orig_dev)
 +{
 +	struct bat_priv *bat_priv;
 +	struct batman_packet *batman_packet;
 +	struct batman_if *batman_if;
 +	int ret;
 +
 +	batman_if = container_of(ptype, struct batman_if, batman_adv_ptype);
 +	skb = skb_share_check(skb, GFP_ATOMIC);
 +
 +	/* skb was released by skb_share_check() */
 +	if (!skb)
 +		goto err_out;
 +
 +	/* packet should hold at least type and version */
 +	if (unlikely(!pskb_may_pull(skb, 2)))
 +		goto err_free;
 +
 +	/* expect a valid ethernet header here. */
 +	if (unlikely(skb->mac_len != sizeof(struct ethhdr)
 +				|| !skb_mac_header(skb)))
 +		goto err_free;
 +
 +	if (!batman_if->soft_iface)
 +		goto err_free;
 +
 +	bat_priv = netdev_priv(batman_if->soft_iface);
 +
 +	if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
 +		goto err_free;
 +
 +	/* discard frames on not active interfaces */
 +	if (batman_if->if_status != IF_ACTIVE)
 +		goto err_free;
 +
 +	batman_packet = (struct batman_packet *)skb->data;
 +
 +	if (batman_packet->version != COMPAT_VERSION) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: incompatible batman version (%i)\n",
 +			batman_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) {
 +		/* batman originator packet */
 +	case BAT_PACKET:
 +		ret = recv_bat_packet(skb, batman_if);
 +		break;
 +
 +		/* batman icmp packet */
 +	case BAT_ICMP:
 +		ret = recv_icmp_packet(skb, batman_if);
 +		break;
 +
 +		/* unicast packet */
 +	case BAT_UNICAST:
 +		ret = recv_unicast_packet(skb, batman_if);
 +		break;
 +
 +		/* fragmented unicast packet */
 +	case BAT_UNICAST_FRAG:
 +		ret = recv_ucast_frag_packet(skb, batman_if);
 +		break;
 +
 +		/* broadcast packet */
 +	case BAT_BCAST:
 +		ret = recv_bcast_packet(skb, batman_if);
 +		break;
 +
 +		/* vis packet */
 +	case BAT_VIS:
 +		ret = recv_vis_packet(skb, batman_if);
 +		break;
 +	default:
 +		ret = NET_RX_DROP;
 +	}
 +
 +	if (ret == NET_RX_DROP)
 +		kfree_skb(skb);
 +
 +	/* return NET_RX_SUCCESS in any case as we
 +	 * most probably dropped the packet for
 +	 * routing-logical reasons. */
 +
 +	return NET_RX_SUCCESS;
 +
 +err_free:
 +	kfree_skb(skb);
 +err_out:
 +	return NET_RX_DROP;
 +}
 +
 +struct notifier_block hard_if_notifier = {
 +	.notifier_call = hard_if_event,
 +};
diff --combined drivers/staging/batman-adv/main.c
index 580ca02,0000000..0587940
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/main.c
+++ b/drivers/staging/batman-adv/main.c
@@@ -1,222 -1,0 +1,217 @@@
 +/*
 + * Copyright (C) 2007-2010 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_sysfs.h"
 +#include "bat_debugfs.h"
 +#include "routing.h"
 +#include "send.h"
 +#include "originator.h"
 +#include "soft-interface.h"
 +#include "icmp_socket.h"
 +#include "translation-table.h"
 +#include "hard-interface.h"
 +#include "types.h"
 +#include "vis.h"
 +#include "hash.h"
 +
 +struct list_head if_list;
 +
 +unsigned char broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 +
 +struct workqueue_struct *bat_event_workqueue;
 +
 +static int __init batman_init(void)
 +{
 +	INIT_LIST_HEAD(&if_list);
 +
 +	/* the name should not be longer than 10 chars - see
 +	 * http://lwn.net/Articles/23634/ */
 +	bat_event_workqueue = create_singlethread_workqueue("bat_events");
 +
 +	if (!bat_event_workqueue)
 +		return -ENOMEM;
 +
 +	bat_socket_init();
 +	debugfs_init();
 +
 +	register_netdevice_notifier(&hard_if_notifier);
 +
 +	pr_info("B.A.T.M.A.N. advanced %s%s (compatibility version %i) "
 +		"loaded\n", SOURCE_VERSION, REVISION_VERSION_STR,
 +		COMPAT_VERSION);
 +
 +	return 0;
 +}
 +
 +static void __exit batman_exit(void)
 +{
 +	debugfs_destroy();
 +	unregister_netdevice_notifier(&hard_if_notifier);
 +	hardif_remove_interfaces();
 +
 +	flush_workqueue(bat_event_workqueue);
 +	destroy_workqueue(bat_event_workqueue);
 +	bat_event_workqueue = NULL;
 +
 +	rcu_barrier();
 +}
 +
 +int mesh_init(struct net_device *soft_iface)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +
 +	spin_lock_init(&bat_priv->orig_hash_lock);
 +	spin_lock_init(&bat_priv->forw_bat_list_lock);
 +	spin_lock_init(&bat_priv->forw_bcast_list_lock);
 +	spin_lock_init(&bat_priv->hna_lhash_lock);
 +	spin_lock_init(&bat_priv->hna_ghash_lock);
 +	spin_lock_init(&bat_priv->vis_hash_lock);
 +	spin_lock_init(&bat_priv->vis_list_lock);
 +
 +	INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
 +	INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
 +
 +	if (originator_init(bat_priv) < 1)
 +		goto err;
 +
 +	if (hna_local_init(bat_priv) < 1)
 +		goto err;
 +
 +	if (hna_global_init(bat_priv) < 1)
 +		goto err;
 +
 +	hna_local_add(soft_iface, soft_iface->dev_addr);
 +
 +	if (vis_init(bat_priv) < 1)
 +		goto err;
 +
 +	atomic_set(&bat_priv->mesh_state, MESH_ACTIVE);
 +	goto end;
 +
 +err:
 +	pr_err("Unable to allocate memory for mesh information structures: "
 +	       "out of mem ?\n");
 +	mesh_free(soft_iface);
 +	return -1;
 +
 +end:
 +	return 0;
 +}
 +
 +void mesh_free(struct net_device *soft_iface)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +
 +	atomic_set(&bat_priv->mesh_state, MESH_DEACTIVATING);
 +
 +	purge_outstanding_packets(bat_priv, NULL);
 +
 +	vis_quit(bat_priv);
 +
 +	originator_free(bat_priv);
 +
 +	hna_local_free(bat_priv);
 +	hna_global_free(bat_priv);
 +
 +	atomic_set(&bat_priv->mesh_state, MESH_INACTIVE);
 +}
 +
 +void inc_module_count(void)
 +{
 +	try_module_get(THIS_MODULE);
 +}
 +
 +void dec_module_count(void)
 +{
 +	module_put(THIS_MODULE);
 +}
 +
- int addr_to_string(char *buff, uint8_t *addr)
- {
- 	return sprintf(buff, "%pM", addr);
- }
- 
 +/* returns 1 if they are the same originator */
 +
 +int compare_orig(void *data1, void *data2)
 +{
 +	return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
 +}
 +
 +/* hashfunction to choose an entry in a hash table of given size */
 +/* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
 +int choose_orig(void *data, int32_t size)
 +{
 +	unsigned char *key = data;
 +	uint32_t hash = 0;
 +	size_t i;
 +
 +	for (i = 0; i < 6; i++) {
 +		hash += key[i];
 +		hash += (hash << 10);
 +		hash ^= (hash >> 6);
 +	}
 +
 +	hash += (hash << 3);
 +	hash ^= (hash >> 11);
 +	hash += (hash << 15);
 +
 +	return hash % size;
 +}
 +
 +int is_my_mac(uint8_t *addr)
 +{
 +	struct batman_if *batman_if;
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->if_status != IF_ACTIVE)
 +			continue;
 +
 +		if (compare_orig(batman_if->net_dev->dev_addr, addr)) {
 +			rcu_read_unlock();
 +			return 1;
 +		}
 +	}
 +	rcu_read_unlock();
 +	return 0;
 +
 +}
 +
 +int is_bcast(uint8_t *addr)
 +{
 +	return (addr[0] == (uint8_t)0xff) && (addr[1] == (uint8_t)0xff);
 +}
 +
 +int is_mcast(uint8_t *addr)
 +{
 +	return *addr & 0x01;
 +}
 +
 +module_init(batman_init);
 +module_exit(batman_exit);
 +
 +MODULE_LICENSE("GPL");
 +
 +MODULE_AUTHOR(DRIVER_AUTHOR);
 +MODULE_DESCRIPTION(DRIVER_DESC);
 +MODULE_SUPPORTED_DEVICE(DRIVER_DEVICE);
 +#ifdef REVISION_VERSION
 +MODULE_VERSION(SOURCE_VERSION "-" REVISION_VERSION);
 +#else
 +MODULE_VERSION(SOURCE_VERSION);
 +#endif
diff --combined drivers/staging/batman-adv/main.h
index ca97589,5e3f516..5e3f516
--- a/drivers/staging/batman-adv/main.h
+++ b/drivers/staging/batman-adv/main.h
@@@ -58,7 -58,6 +58,6 @@@
#define PACKBUFF_SIZE 2000
  #define LOG_BUF_LEN 8192	  /* has to be a power of 2 */
- #define ETH_STR_LEN 20
#define VIS_INTERVAL 5000	/* 5 seconds */
@@@ -136,7 -135,6 +135,6 @@@ int mesh_init(struct net_device *soft_i
  void mesh_free(struct net_device *soft_iface);
  void inc_module_count(void);
  void dec_module_count(void);
- int addr_to_string(char *buff, uint8_t *addr);
  int compare_orig(void *data1, void *data2);
  int choose_orig(void *data, int32_t size);
  int is_my_mac(uint8_t *addr);
diff --combined drivers/staging/batman-adv/originator.c
index 865211d,0000000..5527008
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/originator.c
+++ b/drivers/staging/batman-adv/originator.c
@@@ -1,537 -1,0 +1,533 @@@
 +/*
 + * Copyright (C) 2009-2010 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
 + *
 + */
 +
 +/* increase the reference counter for this originator */
 +
 +#include "main.h"
 +#include "originator.h"
 +#include "hash.h"
 +#include "translation-table.h"
 +#include "routing.h"
 +#include "hard-interface.h"
 +#include "unicast.h"
 +
 +static void purge_orig(struct work_struct *work);
 +
 +static void start_purge_timer(struct bat_priv *bat_priv)
 +{
 +	INIT_DELAYED_WORK(&bat_priv->orig_work, purge_orig);
 +	queue_delayed_work(bat_event_workqueue, &bat_priv->orig_work, 1 * HZ);
 +}
 +
 +int originator_init(struct bat_priv *bat_priv)
 +{
 +	unsigned long flags;
 +	if (bat_priv->orig_hash)
 +		return 1;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	bat_priv->orig_hash = hash_new(128, compare_orig, choose_orig);
 +
 +	if (!bat_priv->orig_hash)
 +		goto err;
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	start_purge_timer(bat_priv);
 +	return 1;
 +
 +err:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return 0;
 +}
 +
 +struct neigh_node *
 +create_neighbor(struct orig_node *orig_node, struct orig_node *orig_neigh_node,
 +		uint8_t *neigh, struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct neigh_node *neigh_node;
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Creating new last-hop neighbor of originator\n");
 +
 +	neigh_node = kzalloc(sizeof(struct neigh_node), GFP_ATOMIC);
 +	if (!neigh_node)
 +		return NULL;
 +
 +	INIT_LIST_HEAD(&neigh_node->list);
 +
 +	memcpy(neigh_node->addr, neigh, ETH_ALEN);
 +	neigh_node->orig_node = orig_neigh_node;
 +	neigh_node->if_incoming = if_incoming;
 +
 +	list_add_tail(&neigh_node->list, &orig_node->neigh_list);
 +	return neigh_node;
 +}
 +
 +static void free_orig_node(void *data, void *arg)
 +{
 +	struct list_head *list_pos, *list_pos_tmp;
 +	struct neigh_node *neigh_node;
 +	struct orig_node *orig_node = (struct orig_node *)data;
 +	struct bat_priv *bat_priv = (struct bat_priv *)arg;
 +
 +	/* for all neighbors towards this originator ... */
 +	list_for_each_safe(list_pos, list_pos_tmp, &orig_node->neigh_list) {
 +		neigh_node = list_entry(list_pos, struct neigh_node, list);
 +
 +		list_del(list_pos);
 +		kfree(neigh_node);
 +	}
 +
 +	frag_list_free(&orig_node->frag_list);
 +	hna_global_del_orig(bat_priv, orig_node, "originator timed out");
 +
 +	kfree(orig_node->bcast_own);
 +	kfree(orig_node->bcast_own_sum);
 +	kfree(orig_node);
 +}
 +
 +void originator_free(struct bat_priv *bat_priv)
 +{
 +	unsigned long flags;
 +
 +	if (!bat_priv->orig_hash)
 +		return;
 +
 +	cancel_delayed_work_sync(&bat_priv->orig_work);
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	hash_delete(bat_priv->orig_hash, free_orig_node, bat_priv);
 +	bat_priv->orig_hash = NULL;
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +/* this function finds or creates an originator entry for the given
 + * address if it does not exits */
 +struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr)
 +{
 +	struct orig_node *orig_node;
 +	struct hashtable_t *swaphash;
 +	int size;
 +
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash, addr));
 +
 +	if (orig_node)
 +		return orig_node;
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Creating new originator: %pM\n", addr);
 +
 +	orig_node = kzalloc(sizeof(struct orig_node), GFP_ATOMIC);
 +	if (!orig_node)
 +		return NULL;
 +
 +	INIT_LIST_HEAD(&orig_node->neigh_list);
 +
 +	memcpy(orig_node->orig, addr, ETH_ALEN);
 +	orig_node->router = NULL;
 +	orig_node->hna_buff = NULL;
 +	orig_node->bcast_seqno_reset = jiffies - 1
 +					- msecs_to_jiffies(RESET_PROTECTION_MS);
 +	orig_node->batman_seqno_reset = jiffies - 1
 +					- msecs_to_jiffies(RESET_PROTECTION_MS);
 +
 +	size = bat_priv->num_ifaces * sizeof(TYPE_OF_WORD) * NUM_WORDS;
 +
 +	orig_node->bcast_own = kzalloc(size, GFP_ATOMIC);
 +	if (!orig_node->bcast_own)
 +		goto free_orig_node;
 +
 +	size = bat_priv->num_ifaces * sizeof(uint8_t);
 +	orig_node->bcast_own_sum = kzalloc(size, GFP_ATOMIC);
 +
 +	INIT_LIST_HEAD(&orig_node->frag_list);
 +	orig_node->last_frag_packet = 0;
 +
 +	if (!orig_node->bcast_own_sum)
 +		goto free_bcast_own;
 +
 +	if (hash_add(bat_priv->orig_hash, orig_node) < 0)
 +		goto free_bcast_own_sum;
 +
 +	if (bat_priv->orig_hash->elements * 4 > bat_priv->orig_hash->size) {
 +		swaphash = hash_resize(bat_priv->orig_hash,
 +				       bat_priv->orig_hash->size * 2);
 +
 +		if (!swaphash)
 +			bat_dbg(DBG_BATMAN, bat_priv,
 +				"Couldn't resize orig hash table\n");
 +		else
 +			bat_priv->orig_hash = swaphash;
 +	}
 +
 +	return orig_node;
 +free_bcast_own_sum:
 +	kfree(orig_node->bcast_own_sum);
 +free_bcast_own:
 +	kfree(orig_node->bcast_own);
 +free_orig_node:
 +	kfree(orig_node);
 +	return NULL;
 +}
 +
 +static bool purge_orig_neighbors(struct bat_priv *bat_priv,
 +				 struct orig_node *orig_node,
 +				 struct neigh_node **best_neigh_node)
 +{
 +	struct list_head *list_pos, *list_pos_tmp;
 +	struct neigh_node *neigh_node;
 +	bool neigh_purged = false;
 +
 +	*best_neigh_node = NULL;
 +
 +	/* for all neighbors towards this originator ... */
 +	list_for_each_safe(list_pos, list_pos_tmp, &orig_node->neigh_list) {
 +		neigh_node = list_entry(list_pos, struct neigh_node, list);
 +
 +		if ((time_after(jiffies,
 +			neigh_node->last_valid + PURGE_TIMEOUT * HZ)) ||
 +		    (neigh_node->if_incoming->if_status == IF_INACTIVE) ||
 +		    (neigh_node->if_incoming->if_status == IF_TO_BE_REMOVED)) {
 +
 +			if (neigh_node->if_incoming->if_status ==
 +							IF_TO_BE_REMOVED)
 +				bat_dbg(DBG_BATMAN, bat_priv,
 +					"neighbor purge: originator %pM, "
 +					"neighbor: %pM, iface: %s\n",
 +					orig_node->orig, neigh_node->addr,
 +					neigh_node->if_incoming->net_dev->name);
 +			else
 +				bat_dbg(DBG_BATMAN, bat_priv,
 +					"neighbor timeout: originator %pM, "
 +					"neighbor: %pM, last_valid: %lu\n",
 +					orig_node->orig, neigh_node->addr,
 +					(neigh_node->last_valid / HZ));
 +
 +			neigh_purged = true;
 +			list_del(list_pos);
 +			kfree(neigh_node);
 +		} else {
 +			if ((*best_neigh_node == NULL) ||
 +			    (neigh_node->tq_avg > (*best_neigh_node)->tq_avg))
 +				*best_neigh_node = neigh_node;
 +		}
 +	}
 +	return neigh_purged;
 +}
 +
 +static bool purge_orig_node(struct bat_priv *bat_priv,
 +			    struct orig_node *orig_node)
 +{
 +	struct neigh_node *best_neigh_node;
 +
 +	if (time_after(jiffies,
 +		orig_node->last_valid + 2 * PURGE_TIMEOUT * HZ)) {
 +
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Originator timeout: originator %pM, last_valid %lu\n",
 +			orig_node->orig, (orig_node->last_valid / HZ));
 +		return true;
 +	} else {
 +		if (purge_orig_neighbors(bat_priv, orig_node,
 +							&best_neigh_node)) {
 +			update_routes(bat_priv, orig_node,
 +				      best_neigh_node,
 +				      orig_node->hna_buff,
 +				      orig_node->hna_buff_len);
 +			/* update bonding candidates, we could have lost
 +			 * some candidates. */
 +			update_bonding_candidates(bat_priv, orig_node);
 +		}
 +	}
 +
 +	return false;
 +}
 +
 +static void _purge_orig(struct bat_priv *bat_priv)
 +{
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	/* for all origins... */
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		if (purge_orig_node(bat_priv, orig_node)) {
 +			hash_remove_bucket(bat_priv->orig_hash, &hashit);
 +			free_orig_node(orig_node, bat_priv);
 +		}
 +
 +		if (time_after(jiffies, (orig_node->last_frag_packet +
 +					msecs_to_jiffies(FRAG_TIMEOUT))))
 +			frag_list_free(&orig_node->frag_list);
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +}
 +
 +static void purge_orig(struct work_struct *work)
 +{
 +	struct delayed_work *delayed_work =
 +		container_of(work, struct delayed_work, work);
 +	struct bat_priv *bat_priv =
 +		container_of(delayed_work, struct bat_priv, orig_work);
 +
 +	_purge_orig(bat_priv);
 +	start_purge_timer(bat_priv);
 +}
 +
 +void purge_orig_ref(struct bat_priv *bat_priv)
 +{
 +	_purge_orig(bat_priv);
 +}
 +
 +int orig_seq_print_text(struct seq_file *seq, void *offset)
 +{
 +	HASHIT(hashit);
 +	struct net_device *net_dev = (struct net_device *)seq->private;
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	struct orig_node *orig_node;
 +	struct neigh_node *neigh_node;
 +	int batman_count = 0;
 +	int last_seen_secs;
 +	int last_seen_msecs;
 +	unsigned long flags;
- 	char orig_str[ETH_STR_LEN], router_str[ETH_STR_LEN];
 +
 +	if ((!bat_priv->primary_if) ||
 +	    (bat_priv->primary_if->if_status != IF_ACTIVE)) {
 +		if (!bat_priv->primary_if)
 +			return seq_printf(seq, "BATMAN mesh %s disabled - "
 +				     "please specify interfaces to enable it\n",
 +				     net_dev->name);
 +
 +		return seq_printf(seq, "BATMAN mesh %s "
 +				  "disabled - primary interface not active\n",
 +				  net_dev->name);
 +	}
 +
- 	seq_printf(seq, "[B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%s (%s)]\n",
++	seq_printf(seq, "[B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%pM (%s)]\n",
 +		   SOURCE_VERSION, REVISION_VERSION_STR,
 +		   bat_priv->primary_if->net_dev->name,
- 		   bat_priv->primary_if->addr_str, net_dev->name);
++		   bat_priv->primary_if->net_dev->dev_addr, net_dev->name);
 +	seq_printf(seq, "  %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
 +		   "Originator", "last-seen", "#", TQ_MAX_VALUE, "Nexthop",
 +		   "outgoingIF", "Potential nexthops");
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +
 +		orig_node = hashit.bucket->data;
 +
 +		if (!orig_node->router)
 +			continue;
 +
 +		if (orig_node->router->tq_avg == 0)
 +			continue;
 +
- 		addr_to_string(orig_str, orig_node->orig);
- 		addr_to_string(router_str, orig_node->router->addr);
 +		last_seen_secs = jiffies_to_msecs(jiffies -
 +						orig_node->last_valid) / 1000;
 +		last_seen_msecs = jiffies_to_msecs(jiffies -
 +						orig_node->last_valid) % 1000;
 +
- 		seq_printf(seq, "%-17s %4i.%03is   (%3i) %17s [%10s]:",
- 			   orig_str, last_seen_secs, last_seen_msecs,
- 			   orig_node->router->tq_avg, router_str,
++		seq_printf(seq, "%pM %4i.%03is   (%3i) %pM [%10s]:",
++			   orig_node->orig, last_seen_secs, last_seen_msecs,
++			   orig_node->router->tq_avg, orig_node->router->addr,
 +			   orig_node->router->if_incoming->net_dev->name);
 +
 +		list_for_each_entry(neigh_node, &orig_node->neigh_list, list) {
- 			addr_to_string(orig_str, neigh_node->addr);
- 			seq_printf(seq, " %17s (%3i)", orig_str,
++			seq_printf(seq, " %pM (%3i)", neigh_node->addr,
 +					   neigh_node->tq_avg);
 +		}
 +
 +		seq_printf(seq, "\n");
 +		batman_count++;
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	if ((batman_count == 0))
 +		seq_printf(seq, "No batman nodes in range ...\n");
 +
 +	return 0;
 +}
 +
 +static int orig_node_add_if(struct orig_node *orig_node, int max_if_num)
 +{
 +	void *data_ptr;
 +
 +	data_ptr = kmalloc(max_if_num * sizeof(TYPE_OF_WORD) * NUM_WORDS,
 +			   GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	memcpy(data_ptr, orig_node->bcast_own,
 +	       (max_if_num - 1) * sizeof(TYPE_OF_WORD) * NUM_WORDS);
 +	kfree(orig_node->bcast_own);
 +	orig_node->bcast_own = data_ptr;
 +
 +	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	memcpy(data_ptr, orig_node->bcast_own_sum,
 +	       (max_if_num - 1) * sizeof(uint8_t));
 +	kfree(orig_node->bcast_own_sum);
 +	orig_node->bcast_own_sum = data_ptr;
 +
 +	return 0;
 +}
 +
 +int orig_hash_add_if(struct batman_if *batman_if, int max_if_num)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	struct orig_node *orig_node;
 +	unsigned long flags;
 +	HASHIT(hashit);
 +
 +	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
 +	 * if_num */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		if (orig_node_add_if(orig_node, max_if_num) == -1)
 +			goto err;
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return 0;
 +
 +err:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return -ENOMEM;
 +}
 +
 +static int orig_node_del_if(struct orig_node *orig_node,
 +		     int max_if_num, int del_if_num)
 +{
 +	void *data_ptr = NULL;
 +	int chunk_size;
 +
 +	/* last interface was removed */
 +	if (max_if_num == 0)
 +		goto free_bcast_own;
 +
 +	chunk_size = sizeof(TYPE_OF_WORD) * 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");
 +		return -1;
 +	}
 +
 +	/* copy first part */
 +	memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
 +
 +	/* copy second part */
 +	memcpy(data_ptr + del_if_num * chunk_size,
 +	       orig_node->bcast_own + ((del_if_num + 1) * chunk_size),
 +	       (max_if_num - del_if_num) * chunk_size);
 +
 +free_bcast_own:
 +	kfree(orig_node->bcast_own);
 +	orig_node->bcast_own = data_ptr;
 +
 +	if (max_if_num == 0)
 +		goto free_own_sum;
 +
 +	data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
 +	if (!data_ptr) {
 +		pr_err("Can't resize orig: out of memory\n");
 +		return -1;
 +	}
 +
 +	memcpy(data_ptr, orig_node->bcast_own_sum,
 +	       del_if_num * sizeof(uint8_t));
 +
 +	memcpy(data_ptr + del_if_num * sizeof(uint8_t),
 +	       orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),
 +	       (max_if_num - del_if_num) * sizeof(uint8_t));
 +
 +free_own_sum:
 +	kfree(orig_node->bcast_own_sum);
 +	orig_node->bcast_own_sum = data_ptr;
 +
 +	return 0;
 +}
 +
 +int orig_hash_del_if(struct batman_if *batman_if, int max_if_num)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	struct batman_if *batman_if_tmp;
 +	struct orig_node *orig_node;
 +	unsigned long flags;
 +	HASHIT(hashit);
 +	int ret;
 +
 +	/* resize all orig nodes because orig_node->bcast_own(_sum) depend on
 +	 * if_num */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		ret = orig_node_del_if(orig_node, max_if_num,
 +				       batman_if->if_num);
 +
 +		if (ret == -1)
 +			goto err;
 +	}
 +
 +	/* renumber remaining batman interfaces _inside_ of orig_hash_lock */
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if_tmp, &if_list, list) {
 +		if (batman_if_tmp->if_status == IF_NOT_IN_USE)
 +			continue;
 +
 +		if (batman_if == batman_if_tmp)
 +			continue;
 +
 +		if (batman_if->soft_iface != batman_if_tmp->soft_iface)
 +			continue;
 +
 +		if (batman_if_tmp->if_num > batman_if->if_num)
 +			batman_if_tmp->if_num--;
 +	}
 +	rcu_read_unlock();
 +
 +	batman_if->if_num = -1;
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return 0;
 +
 +err:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	return -ENOMEM;
 +}
diff --combined drivers/staging/batman-adv/routing.c
index 58aa99e,0000000..9010263
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/routing.c
+++ b/drivers/staging/batman-adv/routing.c
@@@ -1,1393 -1,0 +1,1393 @@@
 +/*
 + * Copyright (C) 2007-2010 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 "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 "types.h"
 +#include "ring_buffer.h"
 +#include "vis.h"
 +#include "aggregation.h"
 +#include "unicast.h"
 +
 +void slide_own_bcast_window(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	TYPE_OF_WORD *word;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +		word = &(orig_node->bcast_own[batman_if->if_num * NUM_WORDS]);
 +
 +		bit_get_packet(bat_priv, word, 1, 0);
 +		orig_node->bcast_own_sum[batman_if->if_num] =
 +			bit_packet_count(word);
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +static void update_HNA(struct bat_priv *bat_priv, struct orig_node *orig_node,
 +		       unsigned char *hna_buff, int hna_buff_len)
 +{
 +	if ((hna_buff_len != orig_node->hna_buff_len) ||
 +	    ((hna_buff_len > 0) &&
 +	     (orig_node->hna_buff_len > 0) &&
 +	     (memcmp(orig_node->hna_buff, hna_buff, hna_buff_len) != 0))) {
 +
 +		if (orig_node->hna_buff_len > 0)
 +			hna_global_del_orig(bat_priv, orig_node,
 +					    "originator changed hna");
 +
 +		if ((hna_buff_len > 0) && (hna_buff != NULL))
 +			hna_global_add_orig(bat_priv, orig_node,
 +					    hna_buff, hna_buff_len);
 +	}
 +}
 +
 +static void update_route(struct bat_priv *bat_priv,
 +			 struct orig_node *orig_node,
 +			 struct neigh_node *neigh_node,
 +			 unsigned char *hna_buff, int hna_buff_len)
 +{
 +	/* route deleted */
 +	if ((orig_node->router != NULL) && (neigh_node == NULL)) {
 +
 +		bat_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n",
 +			orig_node->orig);
 +		hna_global_del_orig(bat_priv, orig_node,
 +				    "originator timed out");
 +
 +		/* route added */
 +	} else if ((orig_node->router == NULL) && (neigh_node != NULL)) {
 +
 +		bat_dbg(DBG_ROUTES, bat_priv,
 +			"Adding route towards: %pM (via %pM)\n",
 +			orig_node->orig, neigh_node->addr);
 +		hna_global_add_orig(bat_priv, orig_node,
 +				    hna_buff, hna_buff_len);
 +
 +		/* route changed */
 +	} else {
 +		bat_dbg(DBG_ROUTES, bat_priv,
 +			"Changing route towards: %pM "
 +			"(now via %pM - was via %pM)\n",
 +			orig_node->orig, neigh_node->addr,
 +			orig_node->router->addr);
 +	}
 +
 +	orig_node->router = neigh_node;
 +}
 +
 +
 +void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node,
 +		   struct neigh_node *neigh_node, unsigned char *hna_buff,
 +		   int hna_buff_len)
 +{
 +
 +	if (orig_node == NULL)
 +		return;
 +
 +	if (orig_node->router != neigh_node)
 +		update_route(bat_priv, orig_node, neigh_node,
 +			     hna_buff, hna_buff_len);
 +	/* may be just HNA changed */
 +	else
 +		update_HNA(bat_priv, orig_node, hna_buff, hna_buff_len);
 +}
 +
 +static int is_bidirectional_neigh(struct orig_node *orig_node,
 +				struct orig_node *orig_neigh_node,
 +				struct batman_packet *batman_packet,
 +				struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
 +	unsigned char total_count;
 +
 +	if (orig_node == orig_neigh_node) {
 +		list_for_each_entry(tmp_neigh_node,
 +				    &orig_node->neigh_list,
 +				    list) {
 +
 +			if (compare_orig(tmp_neigh_node->addr,
 +					 orig_neigh_node->orig) &&
 +			    (tmp_neigh_node->if_incoming == if_incoming))
 +				neigh_node = tmp_neigh_node;
 +		}
 +
 +		if (!neigh_node)
 +			neigh_node = create_neighbor(orig_node,
 +						     orig_neigh_node,
 +						     orig_neigh_node->orig,
 +						     if_incoming);
 +		/* create_neighbor failed, return 0 */
 +		if (!neigh_node)
 +			return 0;
 +
 +		neigh_node->last_valid = jiffies;
 +	} else {
 +		/* find packet count of corresponding one hop neighbor */
 +		list_for_each_entry(tmp_neigh_node,
 +				    &orig_neigh_node->neigh_list, list) {
 +
 +			if (compare_orig(tmp_neigh_node->addr,
 +					 orig_neigh_node->orig) &&
 +			    (tmp_neigh_node->if_incoming == if_incoming))
 +				neigh_node = tmp_neigh_node;
 +		}
 +
 +		if (!neigh_node)
 +			neigh_node = create_neighbor(orig_neigh_node,
 +						     orig_neigh_node,
 +						     orig_neigh_node->orig,
 +						     if_incoming);
 +		/* create_neighbor failed, return 0 */
 +		if (!neigh_node)
 +			return 0;
 +	}
 +
 +	orig_node->last_valid = jiffies;
 +
 +	/* pay attention to not get a value bigger than 100 % */
 +	total_count = (orig_neigh_node->bcast_own_sum[if_incoming->if_num] >
 +		       neigh_node->real_packet_count ?
 +		       neigh_node->real_packet_count :
 +		       orig_neigh_node->bcast_own_sum[if_incoming->if_num]);
 +
 +	/* 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_node->real_packet_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM))
 +		orig_neigh_node->tq_own = 0;
 +	else
 +		/* neigh_node->real_packet_count is never zero as we
 +		 * only purge old information when getting new
 +		 * information */
 +		orig_neigh_node->tq_own = (TQ_MAX_VALUE * total_count) /
 +			neigh_node->real_packet_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
 +	 */
 +	orig_neigh_node->tq_asym_penalty =
 +		TQ_MAX_VALUE -
 +		(TQ_MAX_VALUE *
 +		 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count) *
 +		 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count) *
 +		 (TQ_LOCAL_WINDOW_SIZE - neigh_node->real_packet_count)) /
 +		(TQ_LOCAL_WINDOW_SIZE *
 +		 TQ_LOCAL_WINDOW_SIZE *
 +		 TQ_LOCAL_WINDOW_SIZE);
 +
 +	batman_packet->tq = ((batman_packet->tq *
 +			      orig_neigh_node->tq_own *
 +			      orig_neigh_node->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_node->real_packet_count, orig_neigh_node->tq_own,
 +		orig_neigh_node->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)
 +		return 1;
 +
 +	return 0;
 +}
 +
 +static void update_orig(struct bat_priv *bat_priv,
 +			struct orig_node *orig_node,
 +			struct ethhdr *ethhdr,
 +			struct batman_packet *batman_packet,
 +			struct batman_if *if_incoming,
 +			unsigned char *hna_buff, int hna_buff_len,
 +			char is_duplicate)
 +{
 +	struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
 +	int tmp_hna_buff_len;
 +
 +	bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): "
 +		"Searching and updating originator entry of received packet\n");
 +
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +		if (compare_orig(tmp_neigh_node->addr, ethhdr->h_source) &&
 +		    (tmp_neigh_node->if_incoming == if_incoming)) {
 +			neigh_node = tmp_neigh_node;
 +			continue;
 +		}
 +
 +		if (is_duplicate)
 +			continue;
 +
 +		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);
 +	}
 +
 +	if (!neigh_node) {
 +		struct orig_node *orig_tmp;
 +
 +		orig_tmp = get_orig_node(bat_priv, ethhdr->h_source);
 +		if (!orig_tmp)
 +			return;
 +
 +		neigh_node = create_neighbor(orig_node, orig_tmp,
 +					     ethhdr->h_source, if_incoming);
 +		if (!neigh_node)
 +			return;
 +	} else
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Updating existing last-hop neighbor of originator\n");
 +
 +	orig_node->flags = batman_packet->flags;
 +	neigh_node->last_valid = jiffies;
 +
 +	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);
 +
 +	if (!is_duplicate) {
 +		orig_node->last_ttl = batman_packet->ttl;
 +		neigh_node->last_ttl = batman_packet->ttl;
 +	}
 +
 +	tmp_hna_buff_len = (hna_buff_len > batman_packet->num_hna * ETH_ALEN ?
 +			    batman_packet->num_hna * ETH_ALEN : hna_buff_len);
 +
 +	/* if this neighbor already is our next hop there is nothing
 +	 * to change */
 +	if (orig_node->router == neigh_node)
 +		goto update_hna;
 +
 +	/* if this neighbor does not offer a better TQ we won't consider it */
 +	if ((orig_node->router) &&
 +	    (orig_node->router->tq_avg > neigh_node->tq_avg))
 +		goto update_hna;
 +
 +	/* if the TQ is the same and the link not more symetric we
 +	 * won't consider it either */
 +	if ((orig_node->router) &&
 +	     ((neigh_node->tq_avg == orig_node->router->tq_avg) &&
 +	     (orig_node->router->orig_node->bcast_own_sum[if_incoming->if_num]
 +	      >= neigh_node->orig_node->bcast_own_sum[if_incoming->if_num])))
 +		goto update_hna;
 +
 +	update_routes(bat_priv, orig_node, neigh_node,
 +		      hna_buff, tmp_hna_buff_len);
 +	return;
 +
 +update_hna:
 +	update_routes(bat_priv, orig_node, orig_node->router,
 +		      hna_buff, tmp_hna_buff_len);
 +}
 +
 +/* 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)
 +{
 +	if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE)
 +		|| (seq_num_diff >= EXPECTED_SEQNO_RANGE)) {
 +		if (time_after(jiffies, *last_reset +
 +			msecs_to_jiffies(RESET_PROTECTION_MS))) {
 +
 +			*last_reset = jiffies;
 +			bat_dbg(DBG_BATMAN, bat_priv,
 +				"old packet received, start protection\n");
 +
 +			return 0;
 +		} else
 +			return 1;
 +	}
 +	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 char count_real_packets(struct ethhdr *ethhdr,
 +			       struct batman_packet *batman_packet,
 +			       struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct orig_node *orig_node;
 +	struct neigh_node *tmp_neigh_node;
 +	char is_duplicate = 0;
 +	int32_t seq_diff;
 +	int need_update = 0;
 +	int set_mark;
 +
 +	orig_node = get_orig_node(bat_priv, batman_packet->orig);
 +	if (orig_node == NULL)
 +		return 0;
 +
 +	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))
 +		return -1;
 +
 +	list_for_each_entry(tmp_neigh_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_orig(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);
 +	}
 +
 +	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;
 +	}
 +
 +	return is_duplicate;
 +}
 +
 +/* copy primary address for bonding */
 +static void mark_bonding_address(struct bat_priv *bat_priv,
 +				 struct orig_node *orig_node,
 +				 struct orig_node *orig_neigh_node,
 +				 struct batman_packet *batman_packet)
 +
 +{
 +	if (batman_packet->flags & PRIMARIES_FIRST_HOP)
 +		memcpy(orig_neigh_node->primary_addr,
 +		       orig_node->orig, ETH_ALEN);
 +
 +	return;
 +}
 +
 +/* mark possible bond.candidates in the neighbor list */
 +void update_bonding_candidates(struct bat_priv *bat_priv,
 +			       struct orig_node *orig_node)
 +{
 +	int candidates;
 +	int interference_candidate;
 +	int best_tq;
 +	struct neigh_node *tmp_neigh_node, *tmp_neigh_node2;
 +	struct neigh_node *first_candidate, *last_candidate;
 +
 +	/* update the candidates for this originator */
 +	if (!orig_node->router) {
 +		orig_node->bond.candidates = 0;
 +		return;
 +	}
 +
 +	best_tq = orig_node->router->tq_avg;
 +
 +	/* update bond.candidates */
 +
 +	candidates = 0;
 +
 +	/* mark other nodes which also received "PRIMARIES FIRST HOP" packets
 +	 * as "bonding partner" */
 +
 +	/* first, zero the list */
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +		tmp_neigh_node->next_bond_candidate = NULL;
 +	}
 +
 +	first_candidate = NULL;
 +	last_candidate = NULL;
 +	list_for_each_entry(tmp_neigh_node, &orig_node->neigh_list, list) {
 +
 +		/* only consider if it has the same primary address ...  */
 +		if (memcmp(orig_node->orig,
 +				tmp_neigh_node->orig_node->primary_addr,
 +				ETH_ALEN) != 0)
 +			continue;
 +
 +		/* ... and is good enough to be considered */
 +		if (tmp_neigh_node->tq_avg < best_tq - BONDING_TQ_THRESHOLD)
 +			continue;
 +
 +		/* check if we have another candidate with the same
 +		 * mac address or interface. If we do, we won't
 +		 * select this candidate because of possible interference. */
 +
 +		interference_candidate = 0;
 +		list_for_each_entry(tmp_neigh_node2,
 +				&orig_node->neigh_list, list) {
 +
 +			if (tmp_neigh_node2 == tmp_neigh_node)
 +				continue;
 +
 +			/* we only care if the other candidate is even
 +			 * considered as candidate. */
 +			if (tmp_neigh_node2->next_bond_candidate == NULL)
 +				continue;
 +
 +
 +			if ((tmp_neigh_node->if_incoming ==
 +				tmp_neigh_node2->if_incoming)
 +				|| (memcmp(tmp_neigh_node->addr,
 +				tmp_neigh_node2->addr, ETH_ALEN) == 0)) {
 +
 +				interference_candidate = 1;
 +				break;
 +			}
 +		}
 +		/* don't care further if it is an interference candidate */
 +		if (interference_candidate)
 +			continue;
 +
 +		if (first_candidate == NULL) {
 +			first_candidate = tmp_neigh_node;
 +			tmp_neigh_node->next_bond_candidate = first_candidate;
 +		} else
 +			tmp_neigh_node->next_bond_candidate = last_candidate;
 +
 +		last_candidate = tmp_neigh_node;
 +
 +		candidates++;
 +	}
 +
 +	if (candidates > 0) {
 +		first_candidate->next_bond_candidate = last_candidate;
 +		orig_node->bond.selected = first_candidate;
 +	}
 +
 +	orig_node->bond.candidates = candidates;
 +}
 +
 +void receive_bat_packet(struct ethhdr *ethhdr,
 +				struct batman_packet *batman_packet,
 +				unsigned char *hna_buff, int hna_buff_len,
 +				struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	struct batman_if *batman_if;
 +	struct orig_node *orig_neigh_node, *orig_node;
 +	char has_directlink_flag;
 +	char is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0;
 +	char is_broadcast = 0, is_bidirectional, is_single_hop_neigh;
 +	char 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_orig(ethhdr->h_source,
 +					    batman_packet->orig) ? 1 : 0);
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
- 		"Received BATMAN packet via NB: %pM, IF: %s [%s] "
++		"Received BATMAN packet via NB: %pM, IF: %s [%pM] "
 +		"(from OG: %pM, via prev OG: %pM, seqno %d, tq %d, "
 +		"TTL %d, V %d, IDF %d)\n",
 +		ethhdr->h_source, if_incoming->net_dev->name,
- 		if_incoming->addr_str, batman_packet->orig,
++		if_incoming->net_dev->dev_addr, batman_packet->orig,
 +		batman_packet->prev_sender, batman_packet->seqno,
 +		batman_packet->tq, batman_packet->ttl, batman_packet->version,
 +		has_directlink_flag);
 +
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->if_status != IF_ACTIVE)
 +			continue;
 +
 +		if (batman_if->soft_iface != if_incoming->soft_iface)
 +			continue;
 +
 +		if (compare_orig(ethhdr->h_source,
 +				 batman_if->net_dev->dev_addr))
 +			is_my_addr = 1;
 +
 +		if (compare_orig(batman_packet->orig,
 +				 batman_if->net_dev->dev_addr))
 +			is_my_orig = 1;
 +
 +		if (compare_orig(batman_packet->prev_sender,
 +				 batman_if->net_dev->dev_addr))
 +			is_my_oldorig = 1;
 +
 +		if (compare_orig(ethhdr->h_source, broadcast_addr))
 +			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) {
 +		TYPE_OF_WORD *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 */
 +		/* if received seqno equals last send seqno save new
 +		 * seqno for bidirectional check */
 +		if (has_directlink_flag &&
 +		    compare_orig(if_incoming->net_dev->dev_addr,
 +				 batman_packet->orig) &&
 +		    (batman_packet->seqno - if_incoming_seqno + 2 == 0)) {
 +			offset = if_incoming->if_num * NUM_WORDS;
 +			word = &(orig_neigh_node->bcast_own[offset]);
 +			bit_mark(word, 0);
 +			orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
 +				bit_packet_count(word);
 +		}
 +
 +		bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: "
 +			"originator packet from myself (via neighbor)\n");
 +		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 == NULL)
 +		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);
 +		return;
 +	}
 +
 +	if (batman_packet->tq == 0) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: originator packet with tq equal 0\n");
 +		return;
 +	}
 +
 +	/* avoid temporary routing loops */
 +	if ((orig_node->router) &&
 +	    (orig_node->router->orig_node->router) &&
 +	    (compare_orig(orig_node->router->addr,
 +			  batman_packet->prev_sender)) &&
 +	    !(compare_orig(batman_packet->orig, batman_packet->prev_sender)) &&
 +	    (compare_orig(orig_node->router->addr,
 +			  orig_node->router->orig_node->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);
 +		return;
 +	}
 +
 +	/* 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 == NULL)
 +		return;
 +
 +	/* drop packet if sender is not a direct neighbor and if we
 +	 * don't route towards it */
 +	if (!is_single_hop_neigh &&
 +	    (orig_neigh_node->router == NULL)) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: OGM via unknown neighbor!\n");
 +		return;
 +	}
 +
 +	is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node,
 +						batman_packet, if_incoming);
 +
 +	/* 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, hna_buff, hna_buff_len, is_duplicate);
 +
 +	mark_bonding_address(bat_priv, orig_node,
 +			     orig_neigh_node, batman_packet);
 +	update_bonding_candidates(bat_priv, orig_node);
 +
 +	/* 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, hna_buff_len, if_incoming);
 +
 +		bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
 +			"rebroadcast neighbor packet with direct link flag\n");
 +		return;
 +	}
 +
 +	/* multihop originator */
 +	if (!is_bidirectional) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: not received via bidirectional link\n");
 +		return;
 +	}
 +
 +	if (is_duplicate) {
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"Drop packet: duplicate packet received\n");
 +		return;
 +	}
 +
 +	bat_dbg(DBG_BATMAN, bat_priv,
 +		"Forwarding packet: rebroadcast originator packet\n");
 +	schedule_forward_packet(orig_node, ethhdr, batman_packet,
 +				0, hna_buff_len, if_incoming);
 +}
 +
 +int recv_bat_packet(struct sk_buff *skb, struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	struct ethhdr *ethhdr;
 +	unsigned long flags;
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet))))
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with broadcast indication but unicast recipient */
 +	if (!is_bcast(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	/* create a copy of the skb, if needed, to modify it. */
 +	if (skb_cow(skb, 0) < 0)
 +		return NET_RX_DROP;
 +
 +	/* keep skb linear */
 +	if (skb_linearize(skb) < 0)
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	receive_aggr_bat_packet(ethhdr,
 +				skb->data,
 +				skb_headlen(skb),
 +				batman_if);
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	kfree_skb(skb);
 +	return NET_RX_SUCCESS;
 +}
 +
 +static int recv_my_icmp_packet(struct bat_priv *bat_priv,
 +			       struct sk_buff *skb, size_t icmp_len)
 +{
 +	struct orig_node *orig_node;
 +	struct icmp_packet_rr *icmp_packet;
 +	struct ethhdr *ethhdr;
 +	struct batman_if *batman_if;
 +	int ret;
 +	unsigned long flags;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	icmp_packet = (struct icmp_packet_rr *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* add data to device queue */
 +	if (icmp_packet->msg_type != ECHO_REQUEST) {
 +		bat_socket_receive_packet(icmp_packet, icmp_len);
 +		return NET_RX_DROP;
 +	}
 +
 +	if (!bat_priv->primary_if)
 +		return NET_RX_DROP;
 +
 +	/* answer echo request (ping) */
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
 +						   icmp_packet->orig));
 +	ret = NET_RX_DROP;
 +
 +	if ((orig_node != NULL) &&
 +	    (orig_node->router != NULL)) {
 +
 +		/* don't lock while sending the packets ... we therefore
 +		 * copy the required data before sending */
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		/* create a copy of the skb, if needed, to modify it. */
 +		if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +			return NET_RX_DROP;
 +
 +		icmp_packet = (struct icmp_packet_rr *)skb->data;
 +		ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +		memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
 +		memcpy(icmp_packet->orig,
 +		       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +		icmp_packet->msg_type = ECHO_REPLY;
 +		icmp_packet->ttl = TTL;
 +
 +		send_skb_packet(skb, batman_if, dstaddr);
 +		ret = NET_RX_SUCCESS;
 +
 +	} else
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	return ret;
 +}
 +
 +static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv,
 +				  struct sk_buff *skb, size_t icmp_len)
 +{
 +	struct orig_node *orig_node;
 +	struct icmp_packet *icmp_packet;
 +	struct ethhdr *ethhdr;
 +	struct batman_if *batman_if;
 +	int ret;
 +	unsigned long flags;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	icmp_packet = (struct icmp_packet *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* send TTL exceeded if packet is an echo request (traceroute) */
 +	if (icmp_packet->msg_type != ECHO_REQUEST) {
 +		pr_debug("Warning - can't forward icmp packet from %pM to "
 +			 "%pM: ttl exceeded\n", icmp_packet->orig,
 +			 icmp_packet->dst);
 +		return NET_RX_DROP;
 +	}
 +
 +	if (!bat_priv->primary_if)
 +		return NET_RX_DROP;
 +
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, icmp_packet->orig));
 +	ret = NET_RX_DROP;
 +
 +	if ((orig_node != NULL) &&
 +	    (orig_node->router != NULL)) {
 +
 +		/* don't lock while sending the packets ... we therefore
 +		 * copy the required data before sending */
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		/* create a copy of the skb, if needed, to modify it. */
 +		if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +			return NET_RX_DROP;
 +
 +		icmp_packet = (struct icmp_packet *) skb->data;
 +		ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +		memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
 +		memcpy(icmp_packet->orig,
 +		       bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 +		icmp_packet->msg_type = TTL_EXCEEDED;
 +		icmp_packet->ttl = TTL;
 +
 +		send_skb_packet(skb, batman_if, dstaddr);
 +		ret = NET_RX_SUCCESS;
 +
 +	} else
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	return ret;
 +}
 +
 +
 +int recv_icmp_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct icmp_packet_rr *icmp_packet;
 +	struct ethhdr *ethhdr;
 +	struct orig_node *orig_node;
 +	struct batman_if *batman_if;
 +	int hdr_size = sizeof(struct icmp_packet);
 +	int ret;
 +	unsigned long flags;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	/**
 +	 * we truncate all incoming icmp packets if they don't match our size
 +	 */
 +	if (skb->len >= sizeof(struct icmp_packet_rr))
 +		hdr_size = sizeof(struct icmp_packet_rr);
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with unicast indication but broadcast recipient */
 +	if (is_bcast(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	/* not for me */
 +	if (!is_my_mac(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	icmp_packet = (struct icmp_packet_rr *)skb->data;
 +
 +	/* add record route information if not full */
 +	if ((hdr_size == sizeof(struct icmp_packet_rr)) &&
 +	    (icmp_packet->rr_cur < BAT_RR_LEN)) {
 +		memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
 +			ethhdr->h_dest, ETH_ALEN);
 +		icmp_packet->rr_cur++;
 +	}
 +
 +	/* packet for me */
 +	if (is_my_mac(icmp_packet->dst))
 +		return recv_my_icmp_packet(bat_priv, skb, hdr_size);
 +
 +	/* TTL exceeded */
 +	if (icmp_packet->ttl < 2)
 +		return recv_icmp_ttl_exceeded(bat_priv, skb, hdr_size);
 +
 +	ret = NET_RX_DROP;
 +
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, icmp_packet->dst));
 +
 +	if ((orig_node != NULL) &&
 +	    (orig_node->router != NULL)) {
 +
 +		/* don't lock while sending the packets ... we therefore
 +		 * copy the required data before sending */
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		/* create a copy of the skb, if needed, to modify it. */
 +		if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +			return NET_RX_DROP;
 +
 +		icmp_packet = (struct icmp_packet_rr *)skb->data;
 +		ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +		/* decrement ttl */
 +		icmp_packet->ttl--;
 +
 +		/* route it */
 +		send_skb_packet(skb, batman_if, dstaddr);
 +		ret = NET_RX_SUCCESS;
 +
 +	} else
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	return ret;
 +}
 +
 +/* find a suitable router for this originator, and use
 + * bonding if possible. */
 +struct neigh_node *find_router(struct orig_node *orig_node,
 +			       struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv;
 +	struct orig_node *primary_orig_node;
 +	struct orig_node *router_orig;
 +	struct neigh_node *router, *first_candidate, *best_router;
 +	static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
 +	int bonding_enabled;
 +
 +	if (!orig_node)
 +		return NULL;
 +
 +	if (!orig_node->router)
 +		return NULL;
 +
 +	/* without bonding, the first node should
 +	 * always choose the default router. */
 +
 +	if (!recv_if)
 +		return orig_node->router;
 +
 +	bat_priv = netdev_priv(recv_if->soft_iface);
 +	bonding_enabled = atomic_read(&bat_priv->bonding_enabled);
 +
 +	if (!bonding_enabled)
 +		return orig_node->router;
 +
 +	router_orig = orig_node->router->orig_node;
 +
 +	/* if we have something in the primary_addr, we can search
 +	 * for a potential bonding candidate. */
 +	if (memcmp(router_orig->primary_addr, zero_mac, ETH_ALEN) == 0)
 +		return orig_node->router;
 +
 +	/* find the orig_node which has the primary interface. might
 +	 * even be the same as our router_orig in many cases */
 +
 +	if (memcmp(router_orig->primary_addr,
 +				router_orig->orig, ETH_ALEN) == 0) {
 +		primary_orig_node = router_orig;
 +	} else {
 +		primary_orig_node = hash_find(bat_priv->orig_hash,
 +						router_orig->primary_addr);
 +
 +		if (!primary_orig_node)
 +			return orig_node->router;
 +	}
 +
 +	/* with less than 2 candidates, we can't do any
 +	 * bonding and prefer the original router. */
 +
 +	if (primary_orig_node->bond.candidates < 2)
 +		return orig_node->router;
 +
 +
 +	/* all nodes between should choose a candidate which
 +	 * is is not on the interface where the packet came
 +	 * in. */
 +	first_candidate = primary_orig_node->bond.selected;
 +	router = first_candidate;
 +
 +	if (bonding_enabled) {
 +		/* in the bonding case, send the packets in a round
 +		 * robin fashion over the remaining interfaces. */
 +		do {
 +			/* recv_if == NULL on the first node. */
 +			if (router->if_incoming != recv_if)
 +				break;
 +
 +			router = router->next_bond_candidate;
 +		} while (router != first_candidate);
 +
 +		primary_orig_node->bond.selected = router->next_bond_candidate;
 +
 +	} else {
 +		/* if bonding is disabled, use the best of the
 +		 * remaining candidates which are not using
 +		 * this interface. */
 +		best_router = first_candidate;
 +
 +		do {
 +			/* recv_if == NULL on the first node. */
 +			if ((router->if_incoming != recv_if) &&
 +				(router->tq_avg > best_router->tq_avg))
 +					best_router = router;
 +
 +			router = router->next_bond_candidate;
 +		} while (router != first_candidate);
 +
 +		router = best_router;
 +	}
 +
 +	return router;
 +}
 +
 +static int check_unicast_packet(struct sk_buff *skb, int hdr_size)
 +{
 +	struct ethhdr *ethhdr;
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return -1;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with unicast indication but broadcast recipient */
 +	if (is_bcast(ethhdr->h_dest))
 +		return -1;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return -1;
 +
 +	/* not for me */
 +	if (!is_my_mac(ethhdr->h_dest))
 +		return -1;
 +
 +	return 0;
 +}
 +
 +static int route_unicast_packet(struct sk_buff *skb,
 +				struct batman_if *recv_if, int hdr_size)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct orig_node *orig_node;
 +	struct neigh_node *router;
 +	struct batman_if *batman_if;
 +	uint8_t dstaddr[ETH_ALEN];
 +	unsigned long flags;
 +	struct unicast_packet *unicast_packet;
 +	struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	unicast_packet = (struct unicast_packet *)skb->data;
 +
 +	/* packet for me */
 +	if (is_my_mac(unicast_packet->dest)) {
 +		interface_rx(recv_if->soft_iface, skb, hdr_size);
 +		return NET_RX_SUCCESS;
 +	}
 +
 +	/* TTL exceeded */
 +	if (unicast_packet->ttl < 2) {
 +		pr_debug("Warning - can't forward unicast packet from %pM to "
 +			 "%pM: ttl exceeded\n", ethhdr->h_source,
 +			 unicast_packet->dest);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* get routing information */
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, unicast_packet->dest));
 +
 +	router = find_router(orig_node, recv_if);
 +
 +	if (!router) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* don't lock while sending the packets ... we therefore
 +	 * copy the required data before sending */
 +
 +	batman_if = router->if_incoming;
 +	memcpy(dstaddr, router->addr, ETH_ALEN);
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	/* create a copy of the skb, if needed, to modify it. */
 +	if (skb_cow(skb, sizeof(struct ethhdr)) < 0)
 +		return NET_RX_DROP;
 +
 +	unicast_packet = (struct unicast_packet *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* decrement ttl */
 +	unicast_packet->ttl--;
 +
 +	/* route it */
 +	send_skb_packet(skb, batman_if, dstaddr);
 +
 +	return NET_RX_SUCCESS;
 +}
 +
 +int recv_unicast_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct unicast_packet *unicast_packet;
 +	int hdr_size = sizeof(struct unicast_packet);
 +
 +	if (check_unicast_packet(skb, hdr_size) < 0)
 +		return NET_RX_DROP;
 +
 +	unicast_packet = (struct unicast_packet *)skb->data;
 +
 +	/* packet for me */
 +	if (is_my_mac(unicast_packet->dest)) {
 +		interface_rx(recv_if->soft_iface, skb, hdr_size);
 +		return NET_RX_SUCCESS;
 +	}
 +
 +	return route_unicast_packet(skb, recv_if, hdr_size);
 +}
 +
 +int recv_ucast_frag_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct unicast_frag_packet *unicast_packet;
 +	struct orig_node *orig_node;
 +	struct frag_packet_list_entry *tmp_frag_entry;
 +	int hdr_size = sizeof(struct unicast_frag_packet);
 +	unsigned long flags;
 +
 +	if (check_unicast_packet(skb, hdr_size) < 0)
 +		return NET_RX_DROP;
 +
 +	unicast_packet = (struct unicast_frag_packet *)skb->data;
 +
 +	/* packet for me */
 +	if (is_my_mac(unicast_packet->dest)) {
 +
 +		spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +		orig_node = ((struct orig_node *)
 +			hash_find(bat_priv->orig_hash, unicast_packet->orig));
 +
 +		if (!orig_node) {
 +			pr_debug("couldn't find orig node for fragmentation\n");
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return NET_RX_DROP;
 +		}
 +
 +		orig_node->last_frag_packet = jiffies;
 +
 +		if (list_empty(&orig_node->frag_list) &&
 +			create_frag_buffer(&orig_node->frag_list)) {
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return NET_RX_DROP;
 +		}
 +
 +		tmp_frag_entry =
 +			search_frag_packet(&orig_node->frag_list,
 +					   unicast_packet);
 +
 +		if (!tmp_frag_entry) {
 +			create_frag_entry(&orig_node->frag_list, skb);
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return NET_RX_SUCCESS;
 +		}
 +
 +		skb = merge_frag_packet(&orig_node->frag_list,
 +					tmp_frag_entry, skb);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		if (!skb)
 +			return NET_RX_DROP;
 +
 +		interface_rx(recv_if->soft_iface, skb, hdr_size);
 +		return NET_RX_SUCCESS;
 +	}
 +
 +	return route_unicast_packet(skb, recv_if, hdr_size);
 +}
 +
 +
 +int recv_bcast_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	struct orig_node *orig_node;
 +	struct bcast_packet *bcast_packet;
 +	struct ethhdr *ethhdr;
 +	int hdr_size = sizeof(struct bcast_packet);
 +	int32_t seq_diff;
 +	unsigned long flags;
 +
 +	/* drop packet if it has not necessary minimum size */
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return NET_RX_DROP;
 +
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* packet with broadcast indication but unicast recipient */
 +	if (!is_bcast(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* packet with broadcast sender address */
 +	if (is_bcast(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	/* ignore broadcasts sent by myself */
 +	if (is_my_mac(ethhdr->h_source))
 +		return NET_RX_DROP;
 +
 +	bcast_packet = (struct bcast_packet *)skb->data;
 +
 +	/* ignore broadcasts originated by myself */
 +	if (is_my_mac(bcast_packet->orig))
 +		return NET_RX_DROP;
 +
 +	if (bcast_packet->ttl < 2)
 +		return NET_RX_DROP;
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	orig_node = ((struct orig_node *)
 +		     hash_find(bat_priv->orig_hash, bcast_packet->orig));
 +
 +	if (orig_node == NULL) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* check whether the packet is a duplicate */
 +	if (get_bit_status(orig_node->bcast_bits,
 +			   orig_node->last_bcast_seqno,
 +			   ntohl(bcast_packet->seqno))) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
 +
 +	/* check whether the packet is old and the host just restarted. */
 +	if (window_protected(bat_priv, seq_diff,
 +			     &orig_node->bcast_seqno_reset)) {
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +		return NET_RX_DROP;
 +	}
 +
 +	/* mark broadcast in flood history, update window position
 +	 * if required. */
 +	if (bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
 +		orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +	/* rebroadcast packet */
 +	add_bcast_packet_to_list(bat_priv, skb);
 +
 +	/* broadcast for me */
 +	interface_rx(recv_if->soft_iface, skb, hdr_size);
 +
 +	return NET_RX_SUCCESS;
 +}
 +
 +int recv_vis_packet(struct sk_buff *skb, struct batman_if *recv_if)
 +{
 +	struct vis_packet *vis_packet;
 +	struct ethhdr *ethhdr;
 +	struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
 +	int hdr_size = sizeof(struct vis_packet);
 +
 +	/* keep skb linear */
 +	if (skb_linearize(skb) < 0)
 +		return NET_RX_DROP;
 +
 +	if (unlikely(!pskb_may_pull(skb, hdr_size)))
 +		return NET_RX_DROP;
 +
 +	vis_packet = (struct vis_packet *)skb->data;
 +	ethhdr = (struct ethhdr *)skb_mac_header(skb);
 +
 +	/* not for me */
 +	if (!is_my_mac(ethhdr->h_dest))
 +		return NET_RX_DROP;
 +
 +	/* ignore own packets */
 +	if (is_my_mac(vis_packet->vis_orig))
 +		return NET_RX_DROP;
 +
 +	if (is_my_mac(vis_packet->sender_orig))
 +		return NET_RX_DROP;
 +
 +	switch (vis_packet->vis_type) {
 +	case VIS_TYPE_SERVER_SYNC:
 +		receive_server_sync_packet(bat_priv, vis_packet,
 +					   skb_headlen(skb));
 +		break;
 +
 +	case VIS_TYPE_CLIENT_UPDATE:
 +		receive_client_update_packet(bat_priv, vis_packet,
 +					     skb_headlen(skb));
 +		break;
 +
 +	default:	/* ignore unknown packet */
 +		break;
 +	}
 +
 +	/* We take a copy of the data in the packet, so we should
 +	   always free the skbuf. */
 +	return NET_RX_DROP;
 +}
diff --combined drivers/staging/batman-adv/send.c
index 9032861,0000000..7adf76d
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/send.c
+++ b/drivers/staging/batman-adv/send.c
@@@ -1,580 -1,0 +1,580 @@@
 +/*
 + * Copyright (C) 2007-2010 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 "send.h"
 +#include "routing.h"
 +#include "translation-table.h"
 +#include "soft-interface.h"
 +#include "hard-interface.h"
 +#include "types.h"
 +#include "vis.h"
 +#include "aggregation.h"
 +
 +
 +static void send_outstanding_bcast_packet(struct work_struct *work);
 +
 +/* apply hop penalty for a normal link */
 +static uint8_t hop_penalty(const uint8_t tq)
 +{
 +	return (tq * (TQ_MAX_VALUE - TQ_HOP_PENALTY)) / (TQ_MAX_VALUE);
 +}
 +
 +/* when do we schedule our own packet to be sent */
 +static unsigned long own_send_time(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(struct bat_priv *bat_priv)
 +{
 +	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 batman_if *batman_if,
 +				uint8_t *dst_addr)
 +{
 +	struct ethhdr *ethhdr;
 +
 +	if (batman_if->if_status != IF_ACTIVE)
 +		goto send_skb_err;
 +
 +	if (unlikely(!batman_if->net_dev))
 +		goto send_skb_err;
 +
 +	if (!(batman_if->net_dev->flags & IFF_UP)) {
 +		pr_warning("Interface %s is not up - can't send packet via "
 +			   "that interface!\n", batman_if->net_dev->name);
 +		goto send_skb_err;
 +	}
 +
 +	/* push to the ethernet header. */
 +	if (my_skb_head_push(skb, sizeof(struct ethhdr)) < 0)
 +		goto send_skb_err;
 +
 +	skb_reset_mac_header(skb);
 +
 +	ethhdr = (struct ethhdr *) skb_mac_header(skb);
 +	memcpy(ethhdr->h_source, batman_if->net_dev->dev_addr, ETH_ALEN);
 +	memcpy(ethhdr->h_dest, dst_addr, ETH_ALEN);
 +	ethhdr->h_proto = __constant_htons(ETH_P_BATMAN);
 +
 +	skb_set_network_header(skb, ETH_HLEN);
 +	skb->priority = TC_PRIO_CONTROL;
 +	skb->protocol = __constant_htons(ETH_P_BATMAN);
 +
 +	skb->dev = batman_if->net_dev;
 +
 +	/* dev_queue_xmit() returns a negative result on error.	 However on
 +	 * congestion and traffic shaping, it drops and returns NET_XMIT_DROP
 +	 * (which is > 0). This will not be treated as an error. */
 +
 +	return dev_queue_xmit(skb);
 +send_skb_err:
 +	kfree_skb(skb);
 +	return NET_XMIT_DROP;
 +}
 +
 +/* Send a packet to a given interface */
 +static void send_packet_to_if(struct forw_packet *forw_packet,
 +			      struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	char *fwd_str;
 +	uint8_t packet_num;
 +	int16_t buff_pos;
 +	struct batman_packet *batman_packet;
 +	struct sk_buff *skb;
 +
 +	if (batman_if->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->num_hna)) {
 +
 +		/* 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 == batman_if))
 +			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) on interface %s [%s]\n",
++			" IDF %s) 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_if->net_dev->name, batman_if->addr_str);
++			batman_if->net_dev->name, batman_if->net_dev->dev_addr);
 +
 +		buff_pos += sizeof(struct batman_packet) +
 +			(batman_packet->num_hna * ETH_ALEN);
 +		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, batman_if, broadcast_addr);
 +}
 +
 +/* send a batman packet */
 +static void send_packet(struct forw_packet *forw_packet)
 +{
 +	struct batman_if *batman_if;
 +	struct net_device *soft_iface;
 +	struct bat_priv *bat_priv;
 +	struct batman_packet *batman_packet =
 +		(struct batman_packet *)(forw_packet->skb->data);
 +	unsigned char directlink = (batman_packet->flags & DIRECTLINK ? 1 : 0);
 +
 +	if (!forw_packet->if_incoming) {
 +		pr_err("Error - can't forward packet: incoming iface not "
 +		       "specified\n");
 +		return;
 +	}
 +
 +	soft_iface = forw_packet->if_incoming->soft_iface;
 +	bat_priv = netdev_priv(soft_iface);
 +
 +	if (forw_packet->if_incoming->if_status != IF_ACTIVE)
 +		return;
 +
 +	/* 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->if_num > 0))) {
 +
 +		/* FIXME: what about aggregated packets ? */
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"%s packet (originator %pM, seqno %d, TTL %d) "
- 			"on interface %s [%s]\n",
++			"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->addr_str);
++			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;
 +
 +		return;
 +	}
 +
 +	/* broadcast on every interface */
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->soft_iface != soft_iface)
 +			continue;
 +
 +		send_packet_to_if(forw_packet, batman_if);
 +	}
 +	rcu_read_unlock();
 +}
 +
 +static void rebuild_batman_packet(struct bat_priv *bat_priv,
 +				  struct batman_if *batman_if)
 +{
 +	int new_len;
 +	unsigned char *new_buff;
 +	struct batman_packet *batman_packet;
 +
 +	new_len = sizeof(struct batman_packet) +
 +			(bat_priv->num_local_hna * ETH_ALEN);
 +	new_buff = kmalloc(new_len, GFP_ATOMIC);
 +
 +	/* keep old buffer if kmalloc should fail */
 +	if (new_buff) {
 +		memcpy(new_buff, batman_if->packet_buff,
 +		       sizeof(struct batman_packet));
 +		batman_packet = (struct batman_packet *)new_buff;
 +
 +		batman_packet->num_hna = hna_local_fill_buffer(bat_priv,
 +				new_buff + sizeof(struct batman_packet),
 +				new_len - sizeof(struct batman_packet));
 +
 +		kfree(batman_if->packet_buff);
 +		batman_if->packet_buff = new_buff;
 +		batman_if->packet_len = new_len;
 +	}
 +}
 +
 +void schedule_own_packet(struct batman_if *batman_if)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 +	unsigned long send_time;
 +	struct batman_packet *batman_packet;
 +	int vis_server;
 +
 +	if ((batman_if->if_status == IF_NOT_IN_USE) ||
 +	    (batman_if->if_status == IF_TO_BE_REMOVED))
 +		return;
 +
 +	vis_server = atomic_read(&bat_priv->vis_mode);
 +
 +	/**
 +	 * the interface gets activated here to avoid race conditions between
 +	 * the moment of activating the interface in
 +	 * hardif_activate_interface() where the originator mac is set and
 +	 * outdated packets (especially uninitialized mac addresses) in the
 +	 * packet queue
 +	 */
 +	if (batman_if->if_status == IF_TO_BE_ACTIVATED)
 +		batman_if->if_status = IF_ACTIVE;
 +
 +	/* if local hna has changed and interface is a primary interface */
 +	if ((atomic_read(&bat_priv->hna_local_changed)) &&
 +	    (batman_if == bat_priv->primary_if))
 +		rebuild_batman_packet(bat_priv, batman_if);
 +
 +	/**
 +	 * NOTE: packet_buff might just have been re-allocated in
 +	 * rebuild_batman_packet()
 +	 */
 +	batman_packet = (struct batman_packet *)batman_if->packet_buff;
 +
 +	/* change sequence number to network order */
 +	batman_packet->seqno =
 +		htonl((uint32_t)atomic_read(&batman_if->seqno));
 +
 +	if (vis_server == VIS_TYPE_SERVER_SYNC)
 +		batman_packet->flags |= VIS_SERVER;
 +	else
 +		batman_packet->flags &= ~VIS_SERVER;
 +
 +	atomic_inc(&batman_if->seqno);
 +
 +	slide_own_bcast_window(batman_if);
 +	send_time = own_send_time(bat_priv);
 +	add_bat_packet_to_list(bat_priv,
 +			       batman_if->packet_buff,
 +			       batman_if->packet_len,
 +			       batman_if, 1, send_time);
 +}
 +
 +void schedule_forward_packet(struct orig_node *orig_node,
 +			     struct ethhdr *ethhdr,
 +			     struct batman_packet *batman_packet,
 +			     uint8_t directlink, int hna_buff_len,
 +			     struct batman_if *if_incoming)
 +{
 +	struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 +	unsigned char in_tq, in_ttl, tq_avg = 0;
 +	unsigned long send_time;
 +
 +	if (batman_packet->ttl <= 1) {
 +		bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
 +		return;
 +	}
 +
 +	in_tq = batman_packet->tq;
 +	in_ttl = batman_packet->ttl;
 +
 +	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 ((orig_node->router) && (orig_node->router->tq_avg != 0)) {
 +
 +		/* rebroadcast ogm of best ranking neighbor as is */
 +		if (!compare_orig(orig_node->router->addr, ethhdr->h_source)) {
 +			batman_packet->tq = orig_node->router->tq_avg;
 +
 +			if (orig_node->router->last_ttl)
 +				batman_packet->ttl = orig_node->router->last_ttl
 +							- 1;
 +		}
 +
 +		tq_avg = orig_node->router->tq_avg;
 +	}
 +
 +	/* apply hop penalty */
 +	batman_packet->tq = hop_penalty(batman_packet->tq);
 +
 +	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);
 +
 +	/* 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(bat_priv);
 +	add_bat_packet_to_list(bat_priv,
 +			       (unsigned char *)batman_packet,
 +			       sizeof(struct batman_packet) + hna_buff_len,
 +			       if_incoming, 0, send_time);
 +}
 +
 +static void forw_packet_free(struct forw_packet *forw_packet)
 +{
 +	if (forw_packet->skb)
 +		kfree_skb(forw_packet->skb);
 +	kfree(forw_packet);
 +}
 +
 +static void _add_bcast_packet_to_list(struct bat_priv *bat_priv,
 +				      struct forw_packet *forw_packet,
 +				      unsigned long send_time)
 +{
 +	unsigned long flags;
 +	INIT_HLIST_NODE(&forw_packet->list);
 +
 +	/* add new packet to packet list */
 +	spin_lock_irqsave(&bat_priv->forw_bcast_list_lock, flags);
 +	hlist_add_head(&forw_packet->list, &bat_priv->forw_bcast_list);
 +	spin_unlock_irqrestore(&bat_priv->forw_bcast_list_lock, flags);
 +
 +	/* start timer for this packet */
 +	INIT_DELAYED_WORK(&forw_packet->delayed_work,
 +			  send_outstanding_bcast_packet);
 +	queue_delayed_work(bat_event_workqueue, &forw_packet->delayed_work,
 +			   send_time);
 +}
 +
 +#define atomic_dec_not_zero(v)          atomic_add_unless((v), -1, 0)
 +/* add a broadcast packet to the queue and setup timers. broadcast packets
 + * are sent multiple times to increase probability for beeing received.
 + *
 + * This function returns NETDEV_TX_OK on success and NETDEV_TX_BUSY on
 + * errors.
 + *
 + * The skb is not consumed, so the caller should make sure that the
 + * skb is freed. */
 +int add_bcast_packet_to_list(struct bat_priv *bat_priv, struct sk_buff *skb)
 +{
 +	struct forw_packet *forw_packet;
 +	struct bcast_packet *bcast_packet;
 +
 +	if (!atomic_dec_not_zero(&bat_priv->bcast_queue_left)) {
 +		bat_dbg(DBG_BATMAN, bat_priv, "bcast packet queue full\n");
 +		goto out;
 +	}
 +
 +	if (!bat_priv->primary_if)
 +		goto out;
 +
 +	forw_packet = kmalloc(sizeof(struct forw_packet), GFP_ATOMIC);
 +
 +	if (!forw_packet)
 +		goto out_and_inc;
 +
 +	skb = skb_copy(skb, GFP_ATOMIC);
 +	if (!skb)
 +		goto packet_free;
 +
 +	/* as we have a copy now, it is safe to decrease the TTL */
 +	bcast_packet = (struct bcast_packet *)skb->data;
 +	bcast_packet->ttl--;
 +
 +	skb_reset_mac_header(skb);
 +
 +	forw_packet->skb = skb;
 +	forw_packet->if_incoming = bat_priv->primary_if;
 +
 +	/* how often did we send the bcast packet ? */
 +	forw_packet->num_packets = 0;
 +
 +	_add_bcast_packet_to_list(bat_priv, forw_packet, 1);
 +	return NETDEV_TX_OK;
 +
 +packet_free:
 +	kfree(forw_packet);
 +out_and_inc:
 +	atomic_inc(&bat_priv->bcast_queue_left);
 +out:
 +	return NETDEV_TX_BUSY;
 +}
 +
 +static void send_outstanding_bcast_packet(struct work_struct *work)
 +{
 +	struct batman_if *batman_if;
 +	struct delayed_work *delayed_work =
 +		container_of(work, struct delayed_work, work);
 +	struct forw_packet *forw_packet =
 +		container_of(delayed_work, struct forw_packet, delayed_work);
 +	unsigned long flags;
 +	struct sk_buff *skb1;
 +	struct net_device *soft_iface = forw_packet->if_incoming->soft_iface;
 +	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 +
 +	spin_lock_irqsave(&bat_priv->forw_bcast_list_lock, flags);
 +	hlist_del(&forw_packet->list);
 +	spin_unlock_irqrestore(&bat_priv->forw_bcast_list_lock, flags);
 +
 +	if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING)
 +		goto out;
 +
 +	/* rebroadcast packet */
 +	rcu_read_lock();
 +	list_for_each_entry_rcu(batman_if, &if_list, list) {
 +		if (batman_if->soft_iface != soft_iface)
 +			continue;
 +
 +		/* send a copy of the saved skb */
 +		skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC);
 +		if (skb1)
 +			send_skb_packet(skb1, batman_if, broadcast_addr);
 +	}
 +	rcu_read_unlock();
 +
 +	forw_packet->num_packets++;
 +
 +	/* if we still have some more bcasts to send */
 +	if (forw_packet->num_packets < 3) {
 +		_add_bcast_packet_to_list(bat_priv, forw_packet,
 +					  ((5 * HZ) / 1000));
 +		return;
 +	}
 +
 +out:
 +	forw_packet_free(forw_packet);
 +	atomic_inc(&bat_priv->bcast_queue_left);
 +}
 +
 +void send_outstanding_bat_packet(struct work_struct *work)
 +{
 +	struct delayed_work *delayed_work =
 +		container_of(work, struct delayed_work, work);
 +	struct forw_packet *forw_packet =
 +		container_of(delayed_work, struct forw_packet, delayed_work);
 +	unsigned long flags;
 +	struct bat_priv *bat_priv;
 +
 +	bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
 +	spin_lock_irqsave(&bat_priv->forw_bat_list_lock, flags);
 +	hlist_del(&forw_packet->list);
 +	spin_unlock_irqrestore(&bat_priv->forw_bat_list_lock, flags);
 +
 +	if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING)
 +		goto out;
 +
 +	send_packet(forw_packet);
 +
 +	/**
 +	 * we have to have at least one packet in the queue
 +	 * to determine the queues wake up time unless we are
 +	 * shutting down
 +	 */
 +	if (forw_packet->own)
 +		schedule_own_packet(forw_packet->if_incoming);
 +
 +out:
 +	/* don't count own packet */
 +	if (!forw_packet->own)
 +		atomic_inc(&bat_priv->batman_queue_left);
 +
 +	forw_packet_free(forw_packet);
 +}
 +
 +void purge_outstanding_packets(struct bat_priv *bat_priv,
 +			       struct batman_if *batman_if)
 +{
 +	struct forw_packet *forw_packet;
 +	struct hlist_node *tmp_node, *safe_tmp_node;
 +	unsigned long flags;
 +
 +	if (batman_if)
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"purge_outstanding_packets(): %s\n",
 +			batman_if->net_dev->name);
 +	else
 +		bat_dbg(DBG_BATMAN, bat_priv,
 +			"purge_outstanding_packets()\n");
 +
 +	/* free bcast list */
 +	spin_lock_irqsave(&bat_priv->forw_bcast_list_lock, flags);
 +	hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node,
 +				  &bat_priv->forw_bcast_list, list) {
 +
 +		/**
 +		 * if purge_outstanding_packets() was called with an argmument
 +		 * we delete only packets belonging to the given interface
 +		 */
 +		if ((batman_if) &&
 +		    (forw_packet->if_incoming != batman_if))
 +			continue;
 +
 +		spin_unlock_irqrestore(&bat_priv->forw_bcast_list_lock, flags);
 +
 +		/**
 +		 * send_outstanding_bcast_packet() will lock the list to
 +		 * delete the item from the list
 +		 */
 +		cancel_delayed_work_sync(&forw_packet->delayed_work);
 +		spin_lock_irqsave(&bat_priv->forw_bcast_list_lock, flags);
 +	}
 +	spin_unlock_irqrestore(&bat_priv->forw_bcast_list_lock, flags);
 +
 +	/* free batman packet list */
 +	spin_lock_irqsave(&bat_priv->forw_bat_list_lock, flags);
 +	hlist_for_each_entry_safe(forw_packet, tmp_node, safe_tmp_node,
 +				  &bat_priv->forw_bat_list, list) {
 +
 +		/**
 +		 * if purge_outstanding_packets() was called with an argmument
 +		 * we delete only packets belonging to the given interface
 +		 */
 +		if ((batman_if) &&
 +		    (forw_packet->if_incoming != batman_if))
 +			continue;
 +
 +		spin_unlock_irqrestore(&bat_priv->forw_bat_list_lock, flags);
 +
 +		/**
 +		 * send_outstanding_bat_packet() will lock the list to
 +		 * delete the item from the list
 +		 */
 +		cancel_delayed_work_sync(&forw_packet->delayed_work);
 +		spin_lock_irqsave(&bat_priv->forw_bat_list_lock, flags);
 +	}
 +	spin_unlock_irqrestore(&bat_priv->forw_bat_list_lock, flags);
 +}
diff --combined drivers/staging/batman-adv/types.h
index bb5827f,f3f7366..f3f7366
--- a/drivers/staging/batman-adv/types.h
+++ b/drivers/staging/batman-adv/types.h
@@@ -37,7 -37,6 +37,6 @@@ struct batman_if 
    struct list_head list;
    int16_t if_num;
    char if_status;
- 	char addr_str[ETH_STR_LEN];
    struct net_device *net_dev;
    atomic_t seqno;
    atomic_t frag_seqno;
diff --combined drivers/staging/batman-adv/vis.c
index 6b102a3,0000000..4473cc8
mode 100644,000000..100644
--- a/drivers/staging/batman-adv/vis.c
+++ b/drivers/staging/batman-adv/vis.c
@@@ -1,901 -1,0 +1,894 @@@
 +/*
 + * Copyright (C) 2008-2010 B.A.T.M.A.N. contributors:
 + *
 + * Simon Wunderlich
 + *
 + * This program is free software; you can redistribute it and/or
 + * modify it under the terms of version 2 of the GNU General Public
 + * License as published by the Free Software Foundation.
 + *
 + * This program is distributed in the hope that it will be useful, but
 + * WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 + * General Public License for more details.
 + *
 + * You should have received a copy of the GNU General Public License
 + * along with this program; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 + * 02110-1301, USA
 + *
 + */
 +
 +#include "main.h"
 +#include "send.h"
 +#include "translation-table.h"
 +#include "vis.h"
 +#include "soft-interface.h"
 +#include "hard-interface.h"
 +#include "hash.h"
 +
 +#define MAX_VIS_PACKET_SIZE 1000
 +
 +/* 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) _dummy = (x - y); \
 +			_dummy > smallest_signed_int(_dummy); })
 +#define seq_after(x, y) seq_before(y, x)
 +
 +static void start_vis_timer(struct bat_priv *bat_priv);
 +
 +/* free the info */
 +static void free_info(struct kref *ref)
 +{
 +	struct vis_info *info = container_of(ref, struct vis_info, refcount);
 +	struct bat_priv *bat_priv = info->bat_priv;
 +	struct recvlist_node *entry, *tmp;
 +	unsigned long flags;
 +
 +	list_del_init(&info->send_list);
 +	spin_lock_irqsave(&bat_priv->vis_list_lock, flags);
 +	list_for_each_entry_safe(entry, tmp, &info->recv_list, list) {
 +		list_del(&entry->list);
 +		kfree(entry);
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->vis_list_lock, flags);
 +	kfree_skb(info->skb_packet);
 +}
 +
 +/* Compare two vis packets, used by the hashing algorithm */
 +static int vis_info_cmp(void *data1, void *data2)
 +{
 +	struct vis_info *d1, *d2;
 +	struct vis_packet *p1, *p2;
 +	d1 = data1;
 +	d2 = data2;
 +	p1 = (struct vis_packet *)d1->skb_packet->data;
 +	p2 = (struct vis_packet *)d2->skb_packet->data;
 +	return compare_orig(p1->vis_orig, p2->vis_orig);
 +}
 +
 +/* hash function to choose an entry in a hash table of given size */
 +/* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
 +static int vis_info_choose(void *data, int size)
 +{
 +	struct vis_info *vis_info = data;
 +	struct vis_packet *packet;
 +	unsigned char *key;
 +	uint32_t hash = 0;
 +	size_t i;
 +
 +	packet = (struct vis_packet *)vis_info->skb_packet->data;
 +	key = packet->vis_orig;
 +	for (i = 0; i < ETH_ALEN; i++) {
 +		hash += key[i];
 +		hash += (hash << 10);
 +		hash ^= (hash >> 6);
 +	}
 +
 +	hash += (hash << 3);
 +	hash ^= (hash >> 11);
 +	hash += (hash << 15);
 +
 +	return hash % size;
 +}
 +
 +/* insert interface to the list of interfaces of one originator, if it
 + * does not already exist in the list */
 +static void vis_data_insert_interface(const uint8_t *interface,
 +				      struct hlist_head *if_list,
 +				      bool primary)
 +{
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos;
 +
 +	hlist_for_each_entry(entry, pos, if_list, list) {
 +		if (compare_orig(entry->addr, (void *)interface))
 +			return;
 +	}
 +
 +	/* its a new address, add it to the list */
 +	entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
 +	if (!entry)
 +		return;
 +	memcpy(entry->addr, interface, ETH_ALEN);
 +	entry->primary = primary;
 +	hlist_add_head(&entry->list, if_list);
 +}
 +
 +static ssize_t vis_data_read_prim_sec(char *buff, struct hlist_head *if_list)
 +{
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos;
- 	char tmp_addr_str[ETH_STR_LEN];
 +	size_t len = 0;
 +
 +	hlist_for_each_entry(entry, pos, if_list, list) {
 +		if (entry->primary)
 +			len += sprintf(buff + len, "PRIMARY, ");
- 		else {
- 			addr_to_string(tmp_addr_str, entry->addr);
- 			len += sprintf(buff + len,  "SEC %s, ", tmp_addr_str);
- 		}
++		else
++			len += sprintf(buff + len,  "SEC %pM, ", entry->addr);
 +	}
 +
 +	return len;
 +}
 +
 +static size_t vis_data_count_prim_sec(struct hlist_head *if_list)
 +{
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos;
 +	size_t count = 0;
 +
 +	hlist_for_each_entry(entry, pos, if_list, list) {
 +		if (entry->primary)
 +			count += 9;
 +		else
 +			count += 23;
 +	}
 +
 +	return count;
 +}
 +
 +/* read an entry  */
 +static ssize_t vis_data_read_entry(char *buff, struct vis_info_entry *entry,
 +				   uint8_t *src, bool primary)
 +{
- 	char to[18];
- 
 +	/* maximal length: max(4+17+2, 3+17+1+3+2) == 26 */
- 	addr_to_string(to, entry->dest);
 +	if (primary && entry->quality == 0)
- 		return sprintf(buff, "HNA %s, ", to);
++		return sprintf(buff, "HNA %pM, ", entry->dest);
 +	else if (compare_orig(entry->src, src))
- 		return sprintf(buff, "TQ %s %d, ", to, entry->quality);
++		return sprintf(buff, "TQ %pM %d, ", entry->dest,
++			       entry->quality);
 +
 +	return 0;
 +}
 +
 +int vis_seq_print_text(struct seq_file *seq, void *offset)
 +{
 +	HASHIT(hashit);
 +	HASHIT(hashit_count);
 +	struct vis_info *info;
 +	struct vis_packet *packet;
 +	struct vis_info_entry *entries;
 +	struct net_device *net_dev = (struct net_device *)seq->private;
 +	struct bat_priv *bat_priv = netdev_priv(net_dev);
 +	HLIST_HEAD(vis_if_list);
 +	struct if_list_entry *entry;
 +	struct hlist_node *pos, *n;
 +	int i;
- 	char tmp_addr_str[ETH_STR_LEN];
 +	unsigned long flags;
 +	int vis_server = atomic_read(&bat_priv->vis_mode);
 +	size_t buff_pos, buf_size;
 +	char *buff;
 +
 +	if ((!bat_priv->primary_if) ||
 +	    (vis_server == VIS_TYPE_CLIENT_UPDATE))
 +		return 0;
 +
 +	buf_size = 1;
 +	/* Estimate length */
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	while (hash_iterate(bat_priv->vis_hash, &hashit_count)) {
 +		info = hashit_count.bucket->data;
 +		packet = (struct vis_packet *)info->skb_packet->data;
 +		entries = (struct vis_info_entry *)
 +			  ((char *)packet + sizeof(struct vis_packet));
 +
 +		for (i = 0; i < packet->entries; i++) {
 +			if (entries[i].quality == 0)
 +				continue;
 +			vis_data_insert_interface(entries[i].src, &vis_if_list,
 +				compare_orig(entries[i].src, packet->vis_orig));
 +		}
 +
 +		hlist_for_each_entry(entry, pos, &vis_if_list, list) {
 +			buf_size += 18 + 26 * packet->entries;
 +
 +			/* add primary/secondary records */
 +			if (compare_orig(entry->addr, packet->vis_orig))
 +				buf_size +=
 +					vis_data_count_prim_sec(&vis_if_list);
 +
 +			buf_size += 1;
 +		}
 +
 +		hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
 +			hlist_del(&entry->list);
 +			kfree(entry);
 +		}
 +	}
 +
 +	buff = kmalloc(buf_size, GFP_ATOMIC);
 +	if (!buff) {
 +		spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +		return -ENOMEM;
 +	}
 +	buff[0] = '\0';
 +	buff_pos = 0;
 +
 +	while (hash_iterate(bat_priv->vis_hash, &hashit)) {
 +		info = hashit.bucket->data;
 +		packet = (struct vis_packet *)info->skb_packet->data;
 +		entries = (struct vis_info_entry *)
 +			  ((char *)packet + sizeof(struct vis_packet));
 +
 +		for (i = 0; i < packet->entries; i++) {
 +			if (entries[i].quality == 0)
 +				continue;
 +			vis_data_insert_interface(entries[i].src, &vis_if_list,
 +				compare_orig(entries[i].src, packet->vis_orig));
 +		}
 +
 +		hlist_for_each_entry(entry, pos, &vis_if_list, list) {
- 			addr_to_string(tmp_addr_str, entry->addr);
- 			buff_pos += sprintf(buff + buff_pos, "%s,",
- 					    tmp_addr_str);
++			buff_pos += sprintf(buff + buff_pos, "%pM,",
++					    entry->addr);
 +
 +			for (i = 0; i < packet->entries; i++)
 +				buff_pos += vis_data_read_entry(buff + buff_pos,
 +								&entries[i],
 +								entry->addr,
 +								entry->primary);
 +
 +			/* add primary/secondary records */
 +			if (compare_orig(entry->addr, packet->vis_orig))
 +				buff_pos +=
 +					vis_data_read_prim_sec(buff + buff_pos,
 +							       &vis_if_list);
 +
 +			buff_pos += sprintf(buff + buff_pos, "\n");
 +		}
 +
 +		hlist_for_each_entry_safe(entry, pos, n, &vis_if_list, list) {
 +			hlist_del(&entry->list);
 +			kfree(entry);
 +		}
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +
 +	seq_printf(seq, "%s", buff);
 +	kfree(buff);
 +
 +	return 0;
 +}
 +
 +/* add the info packet to the send list, if it was not
 + * already linked in. */
 +static void send_list_add(struct bat_priv *bat_priv, struct vis_info *info)
 +{
 +	if (list_empty(&info->send_list)) {
 +		kref_get(&info->refcount);
 +		list_add_tail(&info->send_list, &bat_priv->vis_send_list);
 +	}
 +}
 +
 +/* delete the info packet from the send list, if it was
 + * linked in. */
 +static void send_list_del(struct vis_info *info)
 +{
 +	if (!list_empty(&info->send_list)) {
 +		list_del_init(&info->send_list);
 +		kref_put(&info->refcount, free_info);
 +	}
 +}
 +
 +/* tries to add one entry to the receive list. */
 +static void recv_list_add(struct bat_priv *bat_priv,
 +			  struct list_head *recv_list, char *mac)
 +{
 +	struct recvlist_node *entry;
 +	unsigned long flags;
 +
 +	entry = kmalloc(sizeof(struct recvlist_node), GFP_ATOMIC);
 +	if (!entry)
 +		return;
 +
 +	memcpy(entry->mac, mac, ETH_ALEN);
 +	spin_lock_irqsave(&bat_priv->vis_list_lock, flags);
 +	list_add_tail(&entry->list, recv_list);
 +	spin_unlock_irqrestore(&bat_priv->vis_list_lock, flags);
 +}
 +
 +/* returns 1 if this mac is in the recv_list */
 +static int recv_list_is_in(struct bat_priv *bat_priv,
 +			   struct list_head *recv_list, char *mac)
 +{
 +	struct recvlist_node *entry;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->vis_list_lock, flags);
 +	list_for_each_entry(entry, recv_list, list) {
 +		if (memcmp(entry->mac, mac, ETH_ALEN) == 0) {
 +			spin_unlock_irqrestore(&bat_priv->vis_list_lock,
 +					       flags);
 +			return 1;
 +		}
 +	}
 +	spin_unlock_irqrestore(&bat_priv->vis_list_lock, flags);
 +	return 0;
 +}
 +
 +/* try to add the packet to the vis_hash. return NULL if invalid (e.g. too old,
 + * broken.. ).	vis hash must be locked outside.  is_new is set when the packet
 + * is newer than old entries in the hash. */
 +static struct vis_info *add_packet(struct bat_priv *bat_priv,
 +				   struct vis_packet *vis_packet,
 +				   int vis_info_len, int *is_new,
 +				   int make_broadcast)
 +{
 +	struct vis_info *info, *old_info;
 +	struct vis_packet *search_packet, *old_packet;
 +	struct vis_info search_elem;
 +	struct vis_packet *packet;
 +
 +	*is_new = 0;
 +	/* sanity check */
 +	if (!bat_priv->vis_hash)
 +		return NULL;
 +
 +	/* see if the packet is already in vis_hash */
 +	search_elem.skb_packet = dev_alloc_skb(sizeof(struct vis_packet));
 +	if (!search_elem.skb_packet)
 +		return NULL;
 +	search_packet = (struct vis_packet *)skb_put(search_elem.skb_packet,
 +						     sizeof(struct vis_packet));
 +
 +	memcpy(search_packet->vis_orig, vis_packet->vis_orig, ETH_ALEN);
 +	old_info = hash_find(bat_priv->vis_hash, &search_elem);
 +	kfree_skb(search_elem.skb_packet);
 +
 +	if (old_info != NULL) {
 +		old_packet = (struct vis_packet *)old_info->skb_packet->data;
 +		if (!seq_after(ntohl(vis_packet->seqno),
 +			       ntohl(old_packet->seqno))) {
 +			if (old_packet->seqno == vis_packet->seqno) {
 +				recv_list_add(bat_priv, &old_info->recv_list,
 +					      vis_packet->sender_orig);
 +				return old_info;
 +			} else {
 +				/* newer packet is already in hash. */
 +				return NULL;
 +			}
 +		}
 +		/* remove old entry */
 +		hash_remove(bat_priv->vis_hash, old_info);
 +		send_list_del(old_info);
 +		kref_put(&old_info->refcount, free_info);
 +	}
 +
 +	info = kmalloc(sizeof(struct vis_info), GFP_ATOMIC);
 +	if (!info)
 +		return NULL;
 +
 +	info->skb_packet = dev_alloc_skb(sizeof(struct vis_packet) +
 +					 vis_info_len + sizeof(struct ethhdr));
 +	if (!info->skb_packet) {
 +		kfree(info);
 +		return NULL;
 +	}
 +	skb_reserve(info->skb_packet, sizeof(struct ethhdr));
 +	packet = (struct vis_packet *)skb_put(info->skb_packet,
 +					      sizeof(struct vis_packet) +
 +					      vis_info_len);
 +
 +	kref_init(&info->refcount);
 +	INIT_LIST_HEAD(&info->send_list);
 +	INIT_LIST_HEAD(&info->recv_list);
 +	info->first_seen = jiffies;
 +	info->bat_priv = bat_priv;
 +	memcpy(packet, vis_packet, sizeof(struct vis_packet) + vis_info_len);
 +
 +	/* initialize and add new packet. */
 +	*is_new = 1;
 +
 +	/* Make it a broadcast packet, if required */
 +	if (make_broadcast)
 +		memcpy(packet->target_orig, broadcast_addr, ETH_ALEN);
 +
 +	/* repair if entries is longer than packet. */
 +	if (packet->entries * sizeof(struct vis_info_entry) > vis_info_len)
 +		packet->entries = vis_info_len / sizeof(struct vis_info_entry);
 +
 +	recv_list_add(bat_priv, &info->recv_list, packet->sender_orig);
 +
 +	/* try to add it */
 +	if (hash_add(bat_priv->vis_hash, info) < 0) {
 +		/* did not work (for some reason) */
 +		kref_put(&old_info->refcount, free_info);
 +		info = NULL;
 +	}
 +
 +	return info;
 +}
 +
 +/* handle the server sync packet, forward if needed. */
 +void receive_server_sync_packet(struct bat_priv *bat_priv,
 +				struct vis_packet *vis_packet,
 +				int vis_info_len)
 +{
 +	struct vis_info *info;
 +	int is_new, make_broadcast;
 +	unsigned long flags;
 +	int vis_server = atomic_read(&bat_priv->vis_mode);
 +
 +	make_broadcast = (vis_server == VIS_TYPE_SERVER_SYNC);
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	info = add_packet(bat_priv, vis_packet, vis_info_len,
 +			  &is_new, make_broadcast);
 +	if (!info)
 +		goto end;
 +
 +	/* only if we are server ourselves and packet is newer than the one in
 +	 * hash.*/
 +	if (vis_server == VIS_TYPE_SERVER_SYNC && is_new)
 +		send_list_add(bat_priv, info);
 +end:
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +}
 +
 +/* handle an incoming client update packet and schedule forward if needed. */
 +void receive_client_update_packet(struct bat_priv *bat_priv,
 +				  struct vis_packet *vis_packet,
 +				  int vis_info_len)
 +{
 +	struct vis_info *info;
 +	struct vis_packet *packet;
 +	int is_new;
 +	unsigned long flags;
 +	int vis_server = atomic_read(&bat_priv->vis_mode);
 +	int are_target = 0;
 +
 +	/* clients shall not broadcast. */
 +	if (is_bcast(vis_packet->target_orig))
 +		return;
 +
 +	/* Are we the target for this VIS packet? */
 +	if (vis_server == VIS_TYPE_SERVER_SYNC	&&
 +	    is_my_mac(vis_packet->target_orig))
 +		are_target = 1;
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	info = add_packet(bat_priv, vis_packet, vis_info_len,
 +			  &is_new, are_target);
 +
 +	if (!info)
 +		goto end;
 +	/* note that outdated packets will be dropped at this point. */
 +
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	/* send only if we're the target server or ... */
 +	if (are_target && is_new) {
 +		packet->vis_type = VIS_TYPE_SERVER_SYNC;	/* upgrade! */
 +		send_list_add(bat_priv, info);
 +
 +		/* ... we're not the recipient (and thus need to forward). */
 +	} else if (!is_my_mac(packet->target_orig)) {
 +		send_list_add(bat_priv, info);
 +	}
 +
 +end:
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +}
 +
 +/* Walk the originators and find the VIS server with the best tq. Set the packet
 + * address to its address and return the best_tq.
 + *
 + * Must be called with the originator hash locked */
 +static int find_best_vis_server(struct bat_priv *bat_priv,
 +				struct vis_info *info)
 +{
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	struct vis_packet *packet;
 +	int best_tq = -1;
 +
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +		if ((orig_node) && (orig_node->router) &&
 +		    (orig_node->flags & VIS_SERVER) &&
 +		    (orig_node->router->tq_avg > best_tq)) {
 +			best_tq = orig_node->router->tq_avg;
 +			memcpy(packet->target_orig, orig_node->orig, ETH_ALEN);
 +		}
 +	}
 +	return best_tq;
 +}
 +
 +/* Return true if the vis packet is full. */
 +static bool vis_packet_full(struct vis_info *info)
 +{
 +	struct vis_packet *packet;
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	if (MAX_VIS_PACKET_SIZE / sizeof(struct vis_info_entry)
 +		< packet->entries + 1)
 +		return true;
 +	return false;
 +}
 +
 +/* generates a packet of own vis data,
 + * returns 0 on success, -1 if no packet could be generated */
 +static int generate_vis_packet(struct bat_priv *bat_priv)
 +{
 +	HASHIT(hashit_local);
 +	HASHIT(hashit_global);
 +	struct orig_node *orig_node;
 +	struct vis_info *info = (struct vis_info *)bat_priv->my_vis_info;
 +	struct vis_packet *packet = (struct vis_packet *)info->skb_packet->data;
 +	struct vis_info_entry *entry;
 +	struct hna_local_entry *hna_local_entry;
 +	int best_tq = -1;
 +	unsigned long flags;
 +
 +	info->first_seen = jiffies;
 +	packet->vis_type = atomic_read(&bat_priv->vis_mode);
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	memcpy(packet->target_orig, broadcast_addr, ETH_ALEN);
 +	packet->ttl = TTL;
 +	packet->seqno = htonl(ntohl(packet->seqno) + 1);
 +	packet->entries = 0;
 +	skb_trim(info->skb_packet, sizeof(struct vis_packet));
 +
 +	if (packet->vis_type == VIS_TYPE_CLIENT_UPDATE) {
 +		best_tq = find_best_vis_server(bat_priv, info);
 +
 +		if (best_tq < 0) {
 +			spin_unlock_irqrestore(&bat_priv->orig_hash_lock,
 +					       flags);
 +			return -1;
 +		}
 +	}
 +
 +	while (hash_iterate(bat_priv->orig_hash, &hashit_global)) {
 +		orig_node = hashit_global.bucket->data;
 +
 +		if (!orig_node->router)
 +			continue;
 +
 +		if (!compare_orig(orig_node->router->addr, orig_node->orig))
 +			continue;
 +
 +		if (orig_node->router->if_incoming->if_status != IF_ACTIVE)
 +			continue;
 +
 +		if (orig_node->router->tq_avg < 1)
 +			continue;
 +
 +		/* fill one entry into buffer. */
 +		entry = (struct vis_info_entry *)
 +				skb_put(info->skb_packet, sizeof(*entry));
 +		memcpy(entry->src,
 +		       orig_node->router->if_incoming->net_dev->dev_addr,
 +		       ETH_ALEN);
 +		memcpy(entry->dest, orig_node->orig, ETH_ALEN);
 +		entry->quality = orig_node->router->tq_avg;
 +		packet->entries++;
 +
 +		if (vis_packet_full(info)) {
 +			spin_unlock_irqrestore(
 +					&bat_priv->orig_hash_lock, flags);
 +			return 0;
 +		}
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	spin_lock_irqsave(&bat_priv->hna_lhash_lock, flags);
 +	while (hash_iterate(bat_priv->hna_local_hash, &hashit_local)) {
 +		hna_local_entry = hashit_local.bucket->data;
 +		entry = (struct vis_info_entry *)skb_put(info->skb_packet,
 +							 sizeof(*entry));
 +		memset(entry->src, 0, ETH_ALEN);
 +		memcpy(entry->dest, hna_local_entry->addr, ETH_ALEN);
 +		entry->quality = 0; /* 0 means HNA */
 +		packet->entries++;
 +
 +		if (vis_packet_full(info)) {
 +			spin_unlock_irqrestore(&bat_priv->hna_lhash_lock,
 +					       flags);
 +			return 0;
 +		}
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->hna_lhash_lock, flags);
 +	return 0;
 +}
 +
 +/* free old vis packets. Must be called with this vis_hash_lock
 + * held */
 +static void purge_vis_packets(struct bat_priv *bat_priv)
 +{
 +	HASHIT(hashit);
 +	struct vis_info *info;
 +
 +	while (hash_iterate(bat_priv->vis_hash, &hashit)) {
 +		info = hashit.bucket->data;
 +
 +		/* never purge own data. */
 +		if (info == bat_priv->my_vis_info)
 +			continue;
 +
 +		if (time_after(jiffies,
 +			       info->first_seen + VIS_TIMEOUT * HZ)) {
 +			hash_remove_bucket(bat_priv->vis_hash, &hashit);
 +			send_list_del(info);
 +			kref_put(&info->refcount, free_info);
 +		}
 +	}
 +}
 +
 +static void broadcast_vis_packet(struct bat_priv *bat_priv,
 +				 struct vis_info *info)
 +{
 +	HASHIT(hashit);
 +	struct orig_node *orig_node;
 +	struct vis_packet *packet;
 +	struct sk_buff *skb;
 +	unsigned long flags;
 +	struct batman_if *batman_if;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +
 +	/* send to all routers in range. */
 +	while (hash_iterate(bat_priv->orig_hash, &hashit)) {
 +		orig_node = hashit.bucket->data;
 +
 +		/* if it's a vis server and reachable, send it. */
 +		if ((!orig_node) || (!orig_node->router))
 +			continue;
 +		if (!(orig_node->flags & VIS_SERVER))
 +			continue;
 +		/* don't send it if we already received the packet from
 +		 * this node. */
 +		if (recv_list_is_in(bat_priv, &info->recv_list,
 +							orig_node->orig))
 +			continue;
 +
 +		memcpy(packet->target_orig, orig_node->orig, ETH_ALEN);
 +		batman_if = orig_node->router->if_incoming;
 +		memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +		spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +		skb = skb_clone(info->skb_packet, GFP_ATOMIC);
 +		if (skb)
 +			send_skb_packet(skb, batman_if, dstaddr);
 +
 +		spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +static void unicast_vis_packet(struct bat_priv *bat_priv,
 +			       struct vis_info *info)
 +{
 +	struct orig_node *orig_node;
 +	struct sk_buff *skb;
 +	struct vis_packet *packet;
 +	unsigned long flags;
 +	struct batman_if *batman_if;
 +	uint8_t dstaddr[ETH_ALEN];
 +
 +	spin_lock_irqsave(&bat_priv->orig_hash_lock, flags);
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +	orig_node = ((struct orig_node *)hash_find(bat_priv->orig_hash,
 +						   packet->target_orig));
 +
 +	if ((!orig_node) || (!orig_node->router))
 +		goto out;
 +
 +	/* don't lock while sending the packets ... we therefore
 +	 * copy the required data before sending */
 +	batman_if = orig_node->router->if_incoming;
 +	memcpy(dstaddr, orig_node->router->addr, ETH_ALEN);
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +
 +	skb = skb_clone(info->skb_packet, GFP_ATOMIC);
 +	if (skb)
 +		send_skb_packet(skb, batman_if, dstaddr);
 +
 +	return;
 +
 +out:
 +	spin_unlock_irqrestore(&bat_priv->orig_hash_lock, flags);
 +}
 +
 +/* only send one vis packet. called from send_vis_packets() */
 +static void send_vis_packet(struct bat_priv *bat_priv, struct vis_info *info)
 +{
 +	struct vis_packet *packet;
 +
 +	packet = (struct vis_packet *)info->skb_packet->data;
 +	if (packet->ttl < 2) {
 +		pr_debug("Error - can't send vis packet: ttl exceeded\n");
 +		return;
 +	}
 +
 +	memcpy(packet->sender_orig, bat_priv->primary_if->net_dev->dev_addr,
 +	       ETH_ALEN);
 +	packet->ttl--;
 +
 +	if (is_bcast(packet->target_orig))
 +		broadcast_vis_packet(bat_priv, info);
 +	else
 +		unicast_vis_packet(bat_priv, info);
 +	packet->ttl++; /* restore TTL */
 +}
 +
 +/* called from timer; send (and maybe generate) vis packet. */
 +static void send_vis_packets(struct work_struct *work)
 +{
 +	struct delayed_work *delayed_work =
 +		container_of(work, struct delayed_work, work);
 +	struct bat_priv *bat_priv =
 +		container_of(delayed_work, struct bat_priv, vis_work);
 +	struct vis_info *info, *temp;
 +	unsigned long flags;
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	purge_vis_packets(bat_priv);
 +
 +	if (generate_vis_packet(bat_priv) == 0) {
 +		/* schedule if generation was successful */
 +		send_list_add(bat_priv, bat_priv->my_vis_info);
 +	}
 +
 +	list_for_each_entry_safe(info, temp, &bat_priv->vis_send_list,
 +				 send_list) {
 +
 +		kref_get(&info->refcount);
 +		spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +
 +		if (bat_priv->primary_if)
 +			send_vis_packet(bat_priv, info);
 +
 +		spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +		send_list_del(info);
 +		kref_put(&info->refcount, free_info);
 +	}
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +	start_vis_timer(bat_priv);
 +}
 +
 +/* init the vis server. this may only be called when if_list is already
 + * initialized (e.g. bat0 is initialized, interfaces have been added) */
 +int vis_init(struct bat_priv *bat_priv)
 +{
 +	struct vis_packet *packet;
 +	unsigned long flags;
 +
 +	if (bat_priv->vis_hash)
 +		return 1;
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +
 +	bat_priv->vis_hash = hash_new(256, vis_info_cmp, vis_info_choose);
 +	if (!bat_priv->vis_hash) {
 +		pr_err("Can't initialize vis_hash\n");
 +		goto err;
 +	}
 +
 +	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");
 +		goto err;
 +	}
 +
 +	bat_priv->my_vis_info->skb_packet = dev_alloc_skb(
 +						sizeof(struct vis_packet) +
 +						MAX_VIS_PACKET_SIZE +
 +						sizeof(struct ethhdr));
 +	if (!bat_priv->my_vis_info->skb_packet)
 +		goto free_info;
 +
 +	skb_reserve(bat_priv->my_vis_info->skb_packet, sizeof(struct ethhdr));
 +	packet = (struct vis_packet *)skb_put(
 +					bat_priv->my_vis_info->skb_packet,
 +					sizeof(struct vis_packet));
 +
 +	/* prefill the vis info */
 +	bat_priv->my_vis_info->first_seen = jiffies -
 +						msecs_to_jiffies(VIS_INTERVAL);
 +	INIT_LIST_HEAD(&bat_priv->my_vis_info->recv_list);
 +	INIT_LIST_HEAD(&bat_priv->my_vis_info->send_list);
 +	kref_init(&bat_priv->my_vis_info->refcount);
 +	bat_priv->my_vis_info->bat_priv = bat_priv;
 +	packet->version = COMPAT_VERSION;
 +	packet->packet_type = BAT_VIS;
 +	packet->ttl = TTL;
 +	packet->seqno = 0;
 +	packet->entries = 0;
 +
 +	INIT_LIST_HEAD(&bat_priv->vis_send_list);
 +
 +	if (hash_add(bat_priv->vis_hash, bat_priv->my_vis_info) < 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);
 +		goto err;
 +	}
 +
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +	start_vis_timer(bat_priv);
 +	return 1;
 +
 +free_info:
 +	kfree(bat_priv->my_vis_info);
 +	bat_priv->my_vis_info = NULL;
 +err:
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +	vis_quit(bat_priv);
 +	return 0;
 +}
 +
 +/* Decrease the reference count on a hash item info */
 +static void free_info_ref(void *data, void *arg)
 +{
 +	struct vis_info *info = data;
 +
 +	send_list_del(info);
 +	kref_put(&info->refcount, free_info);
 +}
 +
 +/* shutdown vis-server */
 +void vis_quit(struct bat_priv *bat_priv)
 +{
 +	unsigned long flags;
 +	if (!bat_priv->vis_hash)
 +		return;
 +
 +	cancel_delayed_work_sync(&bat_priv->vis_work);
 +
 +	spin_lock_irqsave(&bat_priv->vis_hash_lock, flags);
 +	/* properly remove, kill timers ... */
 +	hash_delete(bat_priv->vis_hash, free_info_ref, NULL);
 +	bat_priv->vis_hash = NULL;
 +	bat_priv->my_vis_info = NULL;
 +	spin_unlock_irqrestore(&bat_priv->vis_hash_lock, flags);
 +}
 +
 +/* schedule packets for (re)transmission */
 +static void start_vis_timer(struct bat_priv *bat_priv)
 +{
 +	INIT_DELAYED_WORK(&bat_priv->vis_work, send_vis_packets);
 +	queue_delayed_work(bat_event_workqueue, &bat_priv->vis_work,
 +			   msecs_to_jiffies(VIS_INTERVAL));
 +}
-- 
linux integration

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

[commits] linux integration; branch, linux, updated. v2.6.36-rc8-530-g137f968