16 files changed, 411 insertions, 345 deletions

diff --git a/net/batman-adv/bat_sysfs.c b/net/batman-adv/bat_sysfs.c
index b8a7414c3571..c25492f7d665 100644
--- a/net/batman-adv/bat_sysfs.c
+++ b/net/batman-adv/bat_sysfs.c
@@ -174,7 +174,7 @@ static int store_uint_attr(const char *buff, size_t count,
         unsigned long uint_val;
         int ret;
 
-        ret = strict_strtoul(buff, 10, &uint_val);
+        ret = kstrtoul(buff, 10, &uint_val);
         if (ret) {
                 bat_info(net_dev,
                          "%s: Invalid parameter received: %s\n",
@@ -239,7 +239,7 @@ static ssize_t store_vis_mode(struct kobject *kobj, struct attribute *attr,
         unsigned long val;
         int ret, vis_mode_tmp = -1;
 
-        ret = strict_strtoul(buff, 10, &val);
+        ret = kstrtoul(buff, 10, &val);
 
         if (((count == 2) && (!ret) && (val == VIS_TYPE_CLIENT_UPDATE)) ||
             (strncmp(buff, "client", 6) == 0) ||
diff --git a/net/batman-adv/bitarray.c b/net/batman-adv/bitarray.c
index 0be9ff346fa0..9bc63b209b3f 100644
--- a/net/batman-adv/bitarray.c
+++ b/net/batman-adv/bitarray.c
@@ -155,7 +155,7 @@ int bit_get_packet(void *priv, unsigned long *seq_bits,
         /* sequence number is much newer, probably missed a lot of packets */
 
         if ((seq_num_diff >= TQ_LOCAL_WINDOW_SIZE)
-                || (seq_num_diff < EXPECTED_SEQNO_RANGE)) {
+                && (seq_num_diff < EXPECTED_SEQNO_RANGE)) {
                 bat_dbg(DBG_BATMAN, bat_priv,
                         "We missed a lot of packets (%i) !\n",
                         seq_num_diff - 1);
diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c
index 619fb73b3b76..24403a7350f7 100644
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@ -25,6 +25,7 @@
 #include "gateway_common.h"
 #include "hard-interface.h"
 #include "originator.h"
+#include "translation-table.h"
 #include "routing.h"
 #include <linux/ip.h>
 #include <linux/ipv6.h>
@@ -572,108 +573,142 @@ out:
         return ret;
 }
 
-int gw_is_target(struct bat_priv *bat_priv, struct sk_buff *skb,
-                 struct orig_node *old_gw)
+bool gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len)
 {
         struct ethhdr *ethhdr;
         struct iphdr *iphdr;
         struct ipv6hdr *ipv6hdr;
         struct udphdr *udphdr;
-        struct gw_node *curr_gw;
-        struct neigh_node *neigh_curr = NULL, *neigh_old = NULL;
-        unsigned int header_len = 0;
-        int ret = 1;
-
-        if (atomic_read(&bat_priv->gw_mode) == GW_MODE_OFF)
-                return 0;
 
         /* check for ethernet header */
-        if (!pskb_may_pull(skb, header_len + ETH_HLEN))
-                return 0;
+        if (!pskb_may_pull(skb, *header_len + ETH_HLEN))
+                return false;
         ethhdr = (struct ethhdr *)skb->data;
-        header_len += ETH_HLEN;
+        *header_len += ETH_HLEN;
 
         /* check for initial vlan header */
         if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
-                if (!pskb_may_pull(skb, header_len + VLAN_HLEN))
-                        return 0;
+                if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))
+                        return false;
                 ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);
-                header_len += VLAN_HLEN;
+                *header_len += VLAN_HLEN;
         }
 
         /* check for ip header */
         switch (ntohs(ethhdr->h_proto)) {
         case ETH_P_IP:
-                if (!pskb_may_pull(skb, header_len + sizeof(*iphdr)))
-                        return 0;
-                iphdr = (struct iphdr *)(skb->data + header_len);
-                header_len += iphdr->ihl * 4;
+                if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))
+                        return false;
+                iphdr = (struct iphdr *)(skb->data + *header_len);
+                *header_len += iphdr->ihl * 4;
 
                 /* check for udp header */
                 if (iphdr->protocol != IPPROTO_UDP)
-                        return 0;
+                        return false;
 
                 break;
         case ETH_P_IPV6:
-                if (!pskb_may_pull(skb, header_len + sizeof(*ipv6hdr)))
-                        return 0;
-                ipv6hdr = (struct ipv6hdr *)(skb->data + header_len);
-                header_len += sizeof(*ipv6hdr);
+                if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))
+                        return false;
+                ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);
+                *header_len += sizeof(*ipv6hdr);
 
                 /* check for udp header */
                 if (ipv6hdr->nexthdr != IPPROTO_UDP)
-                        return 0;
+                        return false;
 
                 break;
         default:
-                return 0;
+                return false;
         }
 
-        if (!pskb_may_pull(skb, header_len + sizeof(*udphdr)))
-                return 0;
-        udphdr = (struct udphdr *)(skb->data + header_len);
-        header_len += sizeof(*udphdr);
+        if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
+                return false;
+        udphdr = (struct udphdr *)(skb->data + *header_len);
+        *header_len += sizeof(*udphdr);
 
         /* check for bootp port */
         if ((ntohs(ethhdr->h_proto) == ETH_P_IP) &&
              (ntohs(udphdr->dest) != 67))
-                return 0;
+                return false;
 
         if ((ntohs(ethhdr->h_proto) == ETH_P_IPV6) &&
             (ntohs(udphdr->dest) != 547))
-                return 0;
+                return false;
 
-        if (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER)
-                return -1;
+        return true;
+}
 
-        curr_gw = gw_get_selected_gw_node(bat_priv);
-        if (!curr_gw)
-                return 0;
-
-        /* If old_gw != NULL then this packet is unicast.
-         * So, at this point we have to check the message type: if it is a
-         * DHCPREQUEST we have to decide whether to drop it or not */
-        if (old_gw && curr_gw->orig_node != old_gw) {
-                if (is_type_dhcprequest(skb, header_len)) {
-                        /* If the dhcp packet has been sent to a different gw,
-                         * we have to evaluate whether the old gw is still
-                         * reliable enough */
-                        neigh_curr = find_router(bat_priv, curr_gw->orig_node,
-                                                 NULL);
-                        neigh_old = find_router(bat_priv, old_gw, NULL);
-                        if (!neigh_curr || !neigh_old)
-                                goto free_neigh;
-                        if (neigh_curr->tq_avg - neigh_old->tq_avg <
-                                                                GW_THRESHOLD)
-                                ret = -1;
-                }
+bool gw_out_of_range(struct bat_priv *bat_priv,
+                     struct sk_buff *skb, struct ethhdr *ethhdr)
+{
+        struct neigh_node *neigh_curr = NULL, *neigh_old = NULL;
+        struct orig_node *orig_dst_node = NULL;
+        struct gw_node *curr_gw = NULL;
+        bool ret, out_of_range = false;
+        unsigned int header_len = 0;
+        uint8_t curr_tq_avg;
+
+        ret = gw_is_dhcp_target(skb, &header_len);
+        if (!ret)
+                goto out;
+
+        orig_dst_node = transtable_search(bat_priv, ethhdr->h_source,
+                                          ethhdr->h_dest);
+        if (!orig_dst_node)
+                goto out;
+
+        if (!orig_dst_node->gw_flags)
+                goto out;
+
+        ret = is_type_dhcprequest(skb, header_len);
+        if (!ret)
+                goto out;
+
+        switch (atomic_read(&bat_priv->gw_mode)) {
+        case GW_MODE_SERVER:
+                /* If we are a GW then we are our best GW. We can artificially
+                 * set the tq towards ourself as the maximum value */
+                curr_tq_avg = TQ_MAX_VALUE;
+                break;
+        case GW_MODE_CLIENT:
+                curr_gw = gw_get_selected_gw_node(bat_priv);
+                if (!curr_gw)
+                        goto out;
+
+                /* packet is going to our gateway */
+                if (curr_gw->orig_node == orig_dst_node)
+                        goto out;
+
+                /* If the dhcp packet has been sent to a different gw,
+                 * we have to evaluate whether the old gw is still
+                 * reliable enough */
+                neigh_curr = find_router(bat_priv, curr_gw->orig_node, NULL);
+                if (!neigh_curr)
+                        goto out;
+
+                curr_tq_avg = neigh_curr->tq_avg;
+                break;
+        case GW_MODE_OFF:
+        default:
+                goto out;
         }
-free_neigh:
+
+        neigh_old = find_router(bat_priv, orig_dst_node, NULL);
+        if (!neigh_old)
+                goto out;
+
+        if (curr_tq_avg - neigh_old->tq_avg > GW_THRESHOLD)
+                out_of_range = true;
+
+out:
+        if (orig_dst_node)
+                orig_node_free_ref(orig_dst_node);
+        if (curr_gw)
+                gw_node_free_ref(curr_gw);
         if (neigh_old)
                 neigh_node_free_ref(neigh_old);
         if (neigh_curr)
                 neigh_node_free_ref(neigh_curr);
-        if (curr_gw)
-                gw_node_free_ref(curr_gw);
-        return ret;
+        return out_of_range;
 }
diff --git a/net/batman-adv/gateway_client.h b/net/batman-adv/gateway_client.h
index b9b983c07feb..e1edba08eb1d 100644
--- a/net/batman-adv/gateway_client.h
+++ b/net/batman-adv/gateway_client.h
@@ -31,7 +31,8 @@ void gw_node_update(struct bat_priv *bat_priv,
 void gw_node_delete(struct bat_priv *bat_priv, struct orig_node *orig_node);
 void gw_node_purge(struct bat_priv *bat_priv);
 int gw_client_seq_print_text(struct seq_file *seq, void *offset);
-int gw_is_target(struct bat_priv *bat_priv, struct sk_buff *skb,
-                 struct orig_node *old_gw);
+bool gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len);
+bool gw_out_of_range(struct bat_priv *bat_priv,
+                     struct sk_buff *skb, struct ethhdr *ethhdr);
 
 #endif /* _NET_BATMAN_ADV_GATEWAY_CLIENT_H_ */
diff --git a/net/batman-adv/gateway_common.c b/net/batman-adv/gateway_common.c
index 18661af0bc3b..c4ac7b0a2a63 100644
--- a/net/batman-adv/gateway_common.c
+++ b/net/batman-adv/gateway_common.c
@@ -97,7 +97,7 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
                         *tmp_ptr = '\0';
         }
 
-        ret = strict_strtol(buff, 10, &ldown);
+        ret = kstrtol(buff, 10, &ldown);
         if (ret) {
                 bat_err(net_dev,
                         "Download speed of gateway mode invalid: %s\n",
@@ -122,7 +122,7 @@ static bool parse_gw_bandwidth(struct net_device *net_dev, char *buff,
                                 *tmp_ptr = '\0';
                 }
 
-                ret = strict_strtol(slash_ptr + 1, 10, &lup);
+                ret = kstrtol(slash_ptr + 1, 10, &lup);
                 if (ret) {
                         bat_err(net_dev,
                                 "Upload speed of gateway mode invalid: "
diff --git a/net/batman-adv/hash.c b/net/batman-adv/hash.c
index 2a172505f513..d1da29da333b 100644
--- a/net/batman-adv/hash.c
+++ b/net/batman-adv/hash.c
@@ -25,7 +25,7 @@
 /* clears the hash */
 static void hash_init(struct hashtable_t *hash)
 {
-        int i;
+        uint32_t i;
 
         for (i = 0 ; i < hash->size; i++) {
                 INIT_HLIST_HEAD(&hash->table[i]);
@@ -42,7 +42,7 @@ void hash_destroy(struct hashtable_t *hash)
 }
 
 /* allocates and clears the hash */
-struct hashtable_t *hash_new(int size)
+struct hashtable_t *hash_new(uint32_t size)
 {
         struct hashtable_t *hash;
 
diff --git a/net/batman-adv/hash.h b/net/batman-adv/hash.h
index d20aa71ba1e8..4768717f07f9 100644
--- a/net/batman-adv/hash.h
+++ b/net/batman-adv/hash.h
@@ -33,17 +33,17 @@ typedef int (*hashdata_compare_cb)(const struct hlist_node *, const void *);
 /* the hashfunction, should return an index
  * based on the key in the data of the first
  * argument and the size the second */
-typedef int (*hashdata_choose_cb)(const void *, int);
+typedef uint32_t (*hashdata_choose_cb)(const void *, uint32_t);
 typedef void (*hashdata_free_cb)(struct hlist_node *, void *);
 
 struct hashtable_t {
         struct hlist_head *table;   /* the hashtable itself with the buckets */
         spinlock_t *list_locks;     /* spinlock for each hash list entry */
-        int size;                   /* size of hashtable */
+        uint32_t size;              /* size of hashtable */
 };
 
 /* allocates and clears the hash */
-struct hashtable_t *hash_new(int size);
+struct hashtable_t *hash_new(uint32_t size);
 
 /* free only the hashtable and the hash itself. */
 void hash_destroy(struct hashtable_t *hash);
@@ -57,7 +57,7 @@ static inline void hash_delete(struct hashtable_t *hash,
         struct hlist_head *head;
         struct hlist_node *node, *node_tmp;
         spinlock_t *list_lock; /* spinlock to protect write access */
-        int i;
+        uint32_t i;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
@@ -93,7 +93,8 @@ static inline int hash_add(struct hashtable_t *hash,
                            hashdata_choose_cb choose,
                            const void *data, struct hlist_node *data_node)
 {
-        int index, ret = -1;
+        uint32_t index;
+        int ret = -1;
         struct hlist_head *head;
         struct hlist_node *node;
         spinlock_t *list_lock; /* spinlock to protect write access */
@@ -137,7 +138,7 @@ static inline void *hash_remove(struct hashtable_t *hash,
                                 hashdata_compare_cb compare,
                                 hashdata_choose_cb choose, void *data)
 {
-        size_t index;
+        uint32_t index;
         struct hlist_node *node;
         struct hlist_head *head;
         void *data_save = NULL;
diff --git a/net/batman-adv/icmp_socket.c b/net/batman-adv/icmp_socket.c
index ac3520e057c0..d9c1e7bb7fbf 100644
--- a/net/batman-adv/icmp_socket.c
+++ b/net/batman-adv/icmp_socket.c
@@ -136,10 +136,9 @@ static ssize_t bat_socket_read(struct file *file, char __user *buf,
 
         spin_unlock_bh(&socket_client->lock);
 
-        error = __copy_to_user(buf, &socket_packet->icmp_packet,
-                               socket_packet->icmp_len);
+        packet_len = min(count, socket_packet->icmp_len);
+        error = copy_to_user(buf, &socket_packet->icmp_packet, packet_len);
 
-        packet_len = socket_packet->icmp_len;
         kfree(socket_packet);
 
         if (error)
@@ -187,12 +186,7 @@ static ssize_t bat_socket_write(struct file *file, const char __user *buff,
         skb_reserve(skb, sizeof(struct ethhdr));
         icmp_packet = (struct icmp_packet_rr *)skb_put(skb, packet_len);
 
-        if (!access_ok(VERIFY_READ, buff, packet_len)) {
-                len = -EFAULT;
-                goto free_skb;
-        }
-
-        if (__copy_from_user(icmp_packet, buff, packet_len)) {
+        if (copy_from_user(icmp_packet, buff, packet_len)) {
                 len = -EFAULT;
                 goto free_skb;
         }
@@ -217,7 +211,7 @@ static ssize_t bat_socket_write(struct file *file, const char __user *buff,
 
         if (icmp_packet->version != COMPAT_VERSION) {
                 icmp_packet->msg_type = PARAMETER_PROBLEM;
-                icmp_packet->ttl = COMPAT_VERSION;
+                icmp_packet->version = COMPAT_VERSION;
                 bat_socket_add_packet(socket_client, icmp_packet, packet_len);
                 goto free_skb;
         }
diff --git a/net/batman-adv/main.h b/net/batman-adv/main.h
index 964ad4d8ba33..86354e06eb48 100644
--- a/net/batman-adv/main.h
+++ b/net/batman-adv/main.h
@@ -28,7 +28,7 @@
 #define DRIVER_DEVICE "batman-adv"
 
 #ifndef SOURCE_VERSION
-#define SOURCE_VERSION "2011.4.0"
+#define SOURCE_VERSION "2012.0.0"
 #endif
 
 /* B.A.T.M.A.N. parameters */
diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 0e5b77255d99..0bc2045a2f2e 100644
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -164,7 +164,7 @@ void originator_free(struct bat_priv *bat_priv)
         struct hlist_head *head;
         spinlock_t *list_lock; /* spinlock to protect write access */
         struct orig_node *orig_node;
-        int i;
+        uint32_t i;
 
         if (!hash)
                 return;
@@ -350,7 +350,7 @@ static void _purge_orig(struct bat_priv *bat_priv)
         struct hlist_head *head;
         spinlock_t *list_lock; /* spinlock to protect write access */
         struct orig_node *orig_node;
-        int i;
+        uint32_t i;
 
         if (!hash)
                 return;
@@ -413,7 +413,8 @@ int orig_seq_print_text(struct seq_file *seq, void *offset)
         int batman_count = 0;
         int last_seen_secs;
         int last_seen_msecs;
-        int i, ret = 0;
+        uint32_t i;
+        int ret = 0;
 
         primary_if = primary_if_get_selected(bat_priv);
 
@@ -519,7 +520,8 @@ int orig_hash_add_if(struct hard_iface *hard_iface, int max_if_num)
         struct hlist_node *node;
         struct hlist_head *head;
         struct orig_node *orig_node;
-        int i, ret;
+        uint32_t i;
+        int ret;
 
         /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
          * if_num */
@@ -601,7 +603,8 @@ int orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num)
         struct hlist_head *head;
         struct hard_iface *hard_iface_tmp;
         struct orig_node *orig_node;
-        int i, ret;
+        uint32_t i;
+        int ret;
 
         /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
          * if_num */
diff --git a/net/batman-adv/originator.h b/net/batman-adv/originator.h
index cfc1f60a96a1..67765ffef731 100644
--- a/net/batman-adv/originator.h
+++ b/net/batman-adv/originator.h
@@ -42,7 +42,7 @@ int orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num);
 
 /* hashfunction to choose an entry in a hash table of given size */
 /* hash algorithm from http://en.wikipedia.org/wiki/Hash_table */
-static inline int choose_orig(const void *data, int32_t size)
+static inline uint32_t choose_orig(const void *data, uint32_t size)
 {
         const unsigned char *key = data;
         uint32_t hash = 0;
diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c
index f961cc5eade5..773e606f9702 100644
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@ -39,7 +39,7 @@ void slide_own_bcast_window(struct hard_iface *hard_iface)
         struct hlist_head *head;
         struct orig_node *orig_node;
         unsigned long *word;
-        int i;
+        uint32_t i;
         size_t word_index;
 
         for (i = 0; i < hash->size; i++) {
@@ -578,6 +578,7 @@ int recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
 {
         struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface);
         struct tt_query_packet *tt_query;
+        uint16_t tt_len;
         struct ethhdr *ethhdr;
 
         /* drop packet if it has not necessary minimum size */
@@ -616,13 +617,21 @@ int recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if)
                 }
                 break;
         case TT_RESPONSE:
-                /* packet needs to be linearized to access the TT changes */
-                if (skb_linearize(skb) < 0)
-                        goto out;
+                if (is_my_mac(tt_query->dst)) {
+                        /* packet needs to be linearized to access the TT
+                         * changes */
+                        if (skb_linearize(skb) < 0)
+                                goto out;
+
+                        tt_len = tt_query->tt_data * sizeof(struct tt_change);
+
+                        /* Ensure we have all the claimed data */
+                        if (unlikely(skb_headlen(skb) <
+                                     sizeof(struct tt_query_packet) + tt_len))
+                                goto out;
 
-                if (is_my_mac(tt_query->dst))
                         handle_tt_response(bat_priv, tt_query);
-                else {
+                } else {
                         bat_dbg(DBG_TT, bat_priv,
                                 "Routing TT_RESPONSE to %pM [%c]\n",
                                 tt_query->dst,
diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c
index f9cc95728989..987c75a775f9 100644
--- a/net/batman-adv/soft-interface.c
+++ b/net/batman-adv/soft-interface.c
@@ -563,10 +563,10 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface)
         struct bcast_packet *bcast_packet;
         struct vlan_ethhdr *vhdr;
         struct softif_neigh *curr_softif_neigh = NULL;
-        struct orig_node *orig_node = NULL;
+        unsigned int header_len = 0;
         int data_len = skb->len, ret;
         short vid = -1;
-        bool do_bcast;
+        bool do_bcast = false;
 
         if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
                 goto dropped;
@@ -598,17 +598,28 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface)
         /* Register the client MAC in the transtable */
         tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
 
-        orig_node = transtable_search(bat_priv, ethhdr->h_source,
-                                      ethhdr->h_dest);
-        do_bcast = is_multicast_ether_addr(ethhdr->h_dest);
-        if (do_bcast || (orig_node && orig_node->gw_flags)) {
-                ret = gw_is_target(bat_priv, skb, orig_node);
+        if (is_multicast_ether_addr(ethhdr->h_dest)) {
+                do_bcast = true;
 
-                if (ret < 0)
-                        goto dropped;
-
-                if (ret)
-                        do_bcast = false;
+                switch (atomic_read(&bat_priv->gw_mode)) {
+                case GW_MODE_SERVER:
+                        /* gateway servers should not send dhcp
+                         * requests into the mesh */
+                        ret = gw_is_dhcp_target(skb, &header_len);
+                        if (ret)
+                                goto dropped;
+                        break;
+                case GW_MODE_CLIENT:
+                        /* gateway clients should send dhcp requests
+                         * via unicast to their gateway */
+                        ret = gw_is_dhcp_target(skb, &header_len);
+                        if (ret)
+                                do_bcast = false;
+                        break;
+                case GW_MODE_OFF:
+                default:
+                        break;
+                }
         }
 
         /* ethernet packet should be broadcasted */
@@ -644,6 +655,12 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface)
 
         /* unicast packet */
         } else {
+                if (atomic_read(&bat_priv->gw_mode) != GW_MODE_OFF) {
+                        ret = gw_out_of_range(bat_priv, skb, ethhdr);
+                        if (ret)
+                                goto dropped;
+                }
+
                 ret = unicast_send_skb(skb, bat_priv);
                 if (ret != 0)
                         goto dropped_freed;
@@ -662,8 +679,6 @@ end:
                 softif_neigh_free_ref(curr_softif_neigh);
         if (primary_if)
                 hardif_free_ref(primary_if);
-        if (orig_node)
-                orig_node_free_ref(orig_node);
         return NETDEV_TX_OK;
 }
 
@@ -859,7 +874,7 @@ unreg_debugfs:
 unreg_sysfs:
         sysfs_del_meshif(soft_iface);
 unreg_soft_iface:
-        unregister_netdev(soft_iface);
+        unregister_netdevice(soft_iface);
         return NULL;
 
 free_soft_iface:
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index 5f09a578d49d..ab8dea8b0b2e 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -36,18 +36,9 @@ static void _tt_global_del(struct bat_priv *bat_priv,
 static void tt_purge(struct work_struct *work);
 
 /* returns 1 if they are the same mac addr */
-static int compare_ltt(const struct hlist_node *node, const void *data2)
+static int compare_tt(const struct hlist_node *node, const void *data2)
 {
-        const void *data1 = container_of(node, struct tt_local_entry,
-                                         hash_entry);
-
-        return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
-}
-
-/* returns 1 if they are the same mac addr */
-static int compare_gtt(const struct hlist_node *node, const void *data2)
-{
-        const void *data1 = container_of(node, struct tt_global_entry,
+        const void *data1 = container_of(node, struct tt_common_entry,
                                          hash_entry);
 
         return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
@@ -60,14 +51,13 @@ static void tt_start_timer(struct bat_priv *bat_priv)
                            msecs_to_jiffies(5000));
 }
 
-static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
-                                                 const void *data)
+static struct tt_common_entry *tt_hash_find(struct hashtable_t *hash,
+                                            const void *data)
 {
-        struct hashtable_t *hash = bat_priv->tt_local_hash;
         struct hlist_head *head;
         struct hlist_node *node;
-        struct tt_local_entry *tt_local_entry, *tt_local_entry_tmp = NULL;
-        int index;
+        struct tt_common_entry *tt_common_entry, *tt_common_entry_tmp = NULL;
+        uint32_t index;
 
         if (!hash)
                 return NULL;
@@ -76,51 +66,46 @@ static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
         head = &hash->table[index];
 
         rcu_read_lock();
-        hlist_for_each_entry_rcu(tt_local_entry, node, head, hash_entry) {
-                if (!compare_eth(tt_local_entry, data))
+        hlist_for_each_entry_rcu(tt_common_entry, node, head, hash_entry) {
+                if (!compare_eth(tt_common_entry, data))
                         continue;
 
-                if (!atomic_inc_not_zero(&tt_local_entry->refcount))
+                if (!atomic_inc_not_zero(&tt_common_entry->refcount))
                         continue;
 
-                tt_local_entry_tmp = tt_local_entry;
+                tt_common_entry_tmp = tt_common_entry;
                 break;
         }
         rcu_read_unlock();
 
-        return tt_local_entry_tmp;
+        return tt_common_entry_tmp;
 }
 
-static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
-                                                   const void *data)
+static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
+                                                 const void *data)
 {
-        struct hashtable_t *hash = bat_priv->tt_global_hash;
-        struct hlist_head *head;
-        struct hlist_node *node;
-        struct tt_global_entry *tt_global_entry;
-        struct tt_global_entry *tt_global_entry_tmp = NULL;
-        int index;
-
-        if (!hash)
-                return NULL;
-
-        index = choose_orig(data, hash->size);
-        head = &hash->table[index];
+        struct tt_common_entry *tt_common_entry;
+        struct tt_local_entry *tt_local_entry = NULL;
 
-        rcu_read_lock();
-        hlist_for_each_entry_rcu(tt_global_entry, node, head, hash_entry) {
-                if (!compare_eth(tt_global_entry, data))
-                        continue;
+        tt_common_entry = tt_hash_find(bat_priv->tt_local_hash, data);
+        if (tt_common_entry)
+                tt_local_entry = container_of(tt_common_entry,
+                                              struct tt_local_entry, common);
+        return tt_local_entry;
+}
 
-                if (!atomic_inc_not_zero(&tt_global_entry->refcount))
-                        continue;
+static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
+                                                   const void *data)
+{
+        struct tt_common_entry *tt_common_entry;
+        struct tt_global_entry *tt_global_entry = NULL;
 
-                tt_global_entry_tmp = tt_global_entry;
-                break;
-        }
-        rcu_read_unlock();
+        tt_common_entry = tt_hash_find(bat_priv->tt_global_hash, data);
+        if (tt_common_entry)
+                tt_global_entry = container_of(tt_common_entry,
+                                               struct tt_global_entry, common);
+        return tt_global_entry;
 
-        return tt_global_entry_tmp;
 }
 
 static bool is_out_of_time(unsigned long starting_time, unsigned long timeout)
@@ -133,15 +118,18 @@ static bool is_out_of_time(unsigned long starting_time, unsigned long timeout)
 
 static void tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry)
 {
-        if (atomic_dec_and_test(&tt_local_entry->refcount))
-                kfree_rcu(tt_local_entry, rcu);
+        if (atomic_dec_and_test(&tt_local_entry->common.refcount))
+                kfree_rcu(tt_local_entry, common.rcu);
 }
 
 static void tt_global_entry_free_rcu(struct rcu_head *rcu)
 {
+        struct tt_common_entry *tt_common_entry;
         struct tt_global_entry *tt_global_entry;
 
-        tt_global_entry = container_of(rcu, struct tt_global_entry, rcu);
+        tt_common_entry = container_of(rcu, struct tt_common_entry, rcu);
+        tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
+                                       common);
 
         if (tt_global_entry->orig_node)
                 orig_node_free_ref(tt_global_entry->orig_node);
@@ -151,8 +139,9 @@ static void tt_global_entry_free_rcu(struct rcu_head *rcu)
 
 static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry)
 {
-        if (atomic_dec_and_test(&tt_global_entry->refcount))
-                call_rcu(&tt_global_entry->rcu, tt_global_entry_free_rcu);
+        if (atomic_dec_and_test(&tt_global_entry->common.refcount))
+                call_rcu(&tt_global_entry->common.rcu,
+                         tt_global_entry_free_rcu);
 }
 
 static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr,
@@ -201,6 +190,7 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
         struct bat_priv *bat_priv = netdev_priv(soft_iface);
         struct tt_local_entry *tt_local_entry = NULL;
         struct tt_global_entry *tt_global_entry = NULL;
+        int hash_added;
 
         tt_local_entry = tt_local_hash_find(bat_priv, addr);
 
@@ -217,26 +207,33 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
                 "Creating new local tt entry: %pM (ttvn: %d)\n", addr,
                 (uint8_t)atomic_read(&bat_priv->ttvn));
 
-        memcpy(tt_local_entry->addr, addr, ETH_ALEN);
-        tt_local_entry->last_seen = jiffies;
-        tt_local_entry->flags = NO_FLAGS;
+        memcpy(tt_local_entry->common.addr, addr, ETH_ALEN);
+        tt_local_entry->common.flags = NO_FLAGS;
         if (is_wifi_iface(ifindex))
-                tt_local_entry->flags |= TT_CLIENT_WIFI;
-        atomic_set(&tt_local_entry->refcount, 2);
+                tt_local_entry->common.flags |= TT_CLIENT_WIFI;
+        atomic_set(&tt_local_entry->common.refcount, 2);
+        tt_local_entry->last_seen = jiffies;
 
         /* the batman interface mac address should never be purged */
         if (compare_eth(addr, soft_iface->dev_addr))
-                tt_local_entry->flags |= TT_CLIENT_NOPURGE;
+                tt_local_entry->common.flags |= TT_CLIENT_NOPURGE;
+
+        hash_added = hash_add(bat_priv->tt_local_hash, compare_tt, choose_orig,
+                         &tt_local_entry->common,
+                         &tt_local_entry->common.hash_entry);
+
+        if (unlikely(hash_added != 0)) {
+                /* remove the reference for the hash */
+                tt_local_entry_free_ref(tt_local_entry);
+                goto out;
+        }
 
-        tt_local_event(bat_priv, addr, tt_local_entry->flags);
+        tt_local_event(bat_priv, addr, tt_local_entry->common.flags);
 
         /* The local entry has to be marked as NEW to avoid to send it in
          * a full table response going out before the next ttvn increment
          * (consistency check) */
-        tt_local_entry->flags |= TT_CLIENT_NEW;
-
-        hash_add(bat_priv->tt_local_hash, compare_ltt, choose_orig,
-                 tt_local_entry, &tt_local_entry->hash_entry);
+        tt_local_entry->common.flags |= TT_CLIENT_NEW;
 
         /* remove address from global hash if present */
         tt_global_entry = tt_global_hash_find(bat_priv, addr);
@@ -247,10 +244,9 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
                 tt_global_entry->orig_node->tt_poss_change = true;
                 /* The global entry has to be marked as ROAMING and has to be
                  * kept for consistency purpose */
-                tt_global_entry->flags |= TT_CLIENT_ROAM;
+                tt_global_entry->common.flags |= TT_CLIENT_ROAM;
                 tt_global_entry->roam_at = jiffies;
-
-                send_roam_adv(bat_priv, tt_global_entry->addr,
+                send_roam_adv(bat_priv, tt_global_entry->common.addr,
                               tt_global_entry->orig_node);
         }
 out:
@@ -312,13 +308,12 @@ int tt_local_seq_print_text(struct seq_file *seq, void *offset)
         struct net_device *net_dev = (struct net_device *)seq->private;
         struct bat_priv *bat_priv = netdev_priv(net_dev);
         struct hashtable_t *hash = bat_priv->tt_local_hash;
-        struct tt_local_entry *tt_local_entry;
+        struct tt_common_entry *tt_common_entry;
         struct hard_iface *primary_if;
         struct hlist_node *node;
         struct hlist_head *head;
-        size_t buf_size, pos;
-        char *buff;
-        int i, ret = 0;
+        uint32_t i;
+        int ret = 0;
 
         primary_if = primary_if_get_selected(bat_priv);
         if (!primary_if) {
@@ -339,51 +334,27 @@ int tt_local_seq_print_text(struct seq_file *seq, void *offset)
                    "announced via TT (TTVN: %u):\n",
                    net_dev->name, (uint8_t)atomic_read(&bat_priv->ttvn));
 
-        buf_size = 1;
-        /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                __hlist_for_each_rcu(node, head)
-                        buf_size += 29;
-                rcu_read_unlock();
-        }
-
-        buff = kmalloc(buf_size, GFP_ATOMIC);
-        if (!buff) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        buff[0] = '\0';
-        pos = 0;
-
-        for (i = 0; i < hash->size; i++) {
-                head = &hash->table[i];
-
-                rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_local_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry, node,
                                          head, hash_entry) {
-                        pos += snprintf(buff + pos, 30, " * %pM "
-                                        "[%c%c%c%c%c]\n",
-                                        tt_local_entry->addr,
-                                        (tt_local_entry->flags &
+                        seq_printf(seq, " * %pM [%c%c%c%c%c]\n",
+                                        tt_common_entry->addr,
+                                        (tt_common_entry->flags &
                                          TT_CLIENT_ROAM ? 'R' : '.'),
-                                        (tt_local_entry->flags &
+                                        (tt_common_entry->flags &
                                          TT_CLIENT_NOPURGE ? 'P' : '.'),
-                                        (tt_local_entry->flags &
+                                        (tt_common_entry->flags &
                                          TT_CLIENT_NEW ? 'N' : '.'),
-                                        (tt_local_entry->flags &
+                                        (tt_common_entry->flags &
                                          TT_CLIENT_PENDING ? 'X' : '.'),
-                                        (tt_local_entry->flags &
+                                        (tt_common_entry->flags &
                                          TT_CLIENT_WIFI ? 'W' : '.'));
                 }
                 rcu_read_unlock();
         }
-
-        seq_printf(seq, "%s", buff);
-        kfree(buff);
 out:
         if (primary_if)
                 hardif_free_ref(primary_if);
@@ -394,13 +365,13 @@ static void tt_local_set_pending(struct bat_priv *bat_priv,
                                  struct tt_local_entry *tt_local_entry,
                                  uint16_t flags)
 {
-        tt_local_event(bat_priv, tt_local_entry->addr,
-                       tt_local_entry->flags | flags);
+        tt_local_event(bat_priv, tt_local_entry->common.addr,
+                       tt_local_entry->common.flags | flags);
 
         /* The local client has to be marked as "pending to be removed" but has
          * to be kept in the table in order to send it in a full table
          * response issued before the net ttvn increment (consistency check) */
-        tt_local_entry->flags |= TT_CLIENT_PENDING;
+        tt_local_entry->common.flags |= TT_CLIENT_PENDING;
 }
 
 void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
@@ -416,7 +387,7 @@ void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
                              (roaming ? TT_CLIENT_ROAM : NO_FLAGS));
 
         bat_dbg(DBG_TT, bat_priv, "Local tt entry (%pM) pending to be removed: "
-                "%s\n", tt_local_entry->addr, message);
+                "%s\n", tt_local_entry->common.addr, message);
 out:
         if (tt_local_entry)
                 tt_local_entry_free_ref(tt_local_entry);
@@ -426,23 +397,27 @@ static void tt_local_purge(struct bat_priv *bat_priv)
 {
         struct hashtable_t *hash = bat_priv->tt_local_hash;
         struct tt_local_entry *tt_local_entry;
+        struct tt_common_entry *tt_common_entry;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
         spinlock_t *list_lock; /* protects write access to the hash lists */
-        int i;
+        uint32_t i;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
                                           head, hash_entry) {
-                        if (tt_local_entry->flags & TT_CLIENT_NOPURGE)
+                        tt_local_entry = container_of(tt_common_entry,
+                                                      struct tt_local_entry,
+                                                      common);
+                        if (tt_local_entry->common.flags & TT_CLIENT_NOPURGE)
                                 continue;
 
                         /* entry already marked for deletion */
-                        if (tt_local_entry->flags & TT_CLIENT_PENDING)
+                        if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
                                 continue;
 
                         if (!is_out_of_time(tt_local_entry->last_seen,
@@ -453,7 +428,7 @@ static void tt_local_purge(struct bat_priv *bat_priv)
                                              TT_CLIENT_DEL);
                         bat_dbg(DBG_TT, bat_priv, "Local tt entry (%pM) "
                                 "pending to be removed: timed out\n",
-                                tt_local_entry->addr);
+                                tt_local_entry->common.addr);
                 }
                 spin_unlock_bh(list_lock);
         }
@@ -464,10 +439,11 @@ static void tt_local_table_free(struct bat_priv *bat_priv)
 {
         struct hashtable_t *hash;
         spinlock_t *list_lock; /* protects write access to the hash lists */
+        struct tt_common_entry *tt_common_entry;
         struct tt_local_entry *tt_local_entry;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
-        int i;
+        uint32_t i;
 
         if (!bat_priv->tt_local_hash)
                 return;
@@ -479,9 +455,12 @@ static void tt_local_table_free(struct bat_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
                                           head, hash_entry) {
                         hlist_del_rcu(node);
+                        tt_local_entry = container_of(tt_common_entry,
+                                                      struct tt_local_entry,
+                                                      common);
                         tt_local_entry_free_ref(tt_local_entry);
                 }
                 spin_unlock_bh(list_lock);
@@ -529,6 +508,7 @@ int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
         struct tt_global_entry *tt_global_entry;
         struct orig_node *orig_node_tmp;
         int ret = 0;
+        int hash_added;
 
         tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
 
@@ -539,18 +519,24 @@ int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
                 if (!tt_global_entry)
                         goto out;
 
-                memcpy(tt_global_entry->addr, tt_addr, ETH_ALEN);
+                memcpy(tt_global_entry->common.addr, tt_addr, ETH_ALEN);
+                tt_global_entry->common.flags = NO_FLAGS;
+                atomic_set(&tt_global_entry->common.refcount, 2);
                 /* Assign the new orig_node */
                 atomic_inc(&orig_node->refcount);
                 tt_global_entry->orig_node = orig_node;
                 tt_global_entry->ttvn = ttvn;
-                tt_global_entry->flags = NO_FLAGS;
                 tt_global_entry->roam_at = 0;
-                atomic_set(&tt_global_entry->refcount, 2);
 
-                hash_add(bat_priv->tt_global_hash, compare_gtt,
-                         choose_orig, tt_global_entry,
-                         &tt_global_entry->hash_entry);
+                hash_added = hash_add(bat_priv->tt_global_hash, compare_tt,
+                                 choose_orig, &tt_global_entry->common,
+                                 &tt_global_entry->common.hash_entry);
+
+                if (unlikely(hash_added != 0)) {
+                        /* remove the reference for the hash */
+                        tt_global_entry_free_ref(tt_global_entry);
+                        goto out_remove;
+                }
                 atomic_inc(&orig_node->tt_size);
         } else {
                 if (tt_global_entry->orig_node != orig_node) {
@@ -561,20 +547,21 @@ int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
                         orig_node_free_ref(orig_node_tmp);
                         atomic_inc(&orig_node->tt_size);
                 }
+                tt_global_entry->common.flags = NO_FLAGS;
                 tt_global_entry->ttvn = ttvn;
-                tt_global_entry->flags = NO_FLAGS;
                 tt_global_entry->roam_at = 0;
         }
 
         if (wifi)
-                tt_global_entry->flags |= TT_CLIENT_WIFI;
+                tt_global_entry->common.flags |= TT_CLIENT_WIFI;
 
         bat_dbg(DBG_TT, bat_priv,
                 "Creating new global tt entry: %pM (via %pM)\n",
-                tt_global_entry->addr, orig_node->orig);
+                tt_global_entry->common.addr, orig_node->orig);
 
+out_remove:
         /* remove address from local hash if present */
-        tt_local_remove(bat_priv, tt_global_entry->addr,
+        tt_local_remove(bat_priv, tt_global_entry->common.addr,
                         "global tt received", roaming);
         ret = 1;
 out:
@@ -588,13 +575,13 @@ int tt_global_seq_print_text(struct seq_file *seq, void *offset)
         struct net_device *net_dev = (struct net_device *)seq->private;
         struct bat_priv *bat_priv = netdev_priv(net_dev);
         struct hashtable_t *hash = bat_priv->tt_global_hash;
+        struct tt_common_entry *tt_common_entry;
         struct tt_global_entry *tt_global_entry;
         struct hard_iface *primary_if;
         struct hlist_node *node;
         struct hlist_head *head;
-        size_t buf_size, pos;
-        char *buff;
-        int i, ret = 0;
+        uint32_t i;
+        int ret = 0;
 
         primary_if = primary_if_get_selected(bat_priv);
         if (!primary_if) {
@@ -617,53 +604,32 @@ int tt_global_seq_print_text(struct seq_file *seq, void *offset)
         seq_printf(seq, "       %-13s %s       %-15s %s %s\n",
                    "Client", "(TTVN)", "Originator", "(Curr TTVN)", "Flags");
 
-        buf_size = 1;
-        /* Estimate length for: " * xx:xx:xx:xx:xx:xx (ttvn) via
-         * xx:xx:xx:xx:xx:xx (cur_ttvn)\n"*/
-        for (i = 0; i < hash->size; i++) {
-                head = &hash->table[i];
-
-                rcu_read_lock();
-                __hlist_for_each_rcu(node, head)
-                        buf_size += 67;
-                rcu_read_unlock();
-        }
-
-        buff = kmalloc(buf_size, GFP_ATOMIC);
-        if (!buff) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        buff[0] = '\0';
-        pos = 0;
-
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_global_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry, node,
                                          head, hash_entry) {
-                        pos += snprintf(buff + pos, 69,
-                                        " * %pM  (%3u) via %pM     (%3u)   "
-                                        "[%c%c%c]\n", tt_global_entry->addr,
+                        tt_global_entry = container_of(tt_common_entry,
+                                                       struct tt_global_entry,
+                                                       common);
+                        seq_printf(seq, " * %pM  (%3u) via %pM     (%3u)   "
+                                        "[%c%c%c]\n",
+                                        tt_global_entry->common.addr,
                                         tt_global_entry->ttvn,
                                         tt_global_entry->orig_node->orig,
                                         (uint8_t) atomic_read(
                                                 &tt_global_entry->orig_node->
                                                 last_ttvn),
-                                        (tt_global_entry->flags &
+                                        (tt_global_entry->common.flags &
                                          TT_CLIENT_ROAM ? 'R' : '.'),
-                                        (tt_global_entry->flags &
+                                        (tt_global_entry->common.flags &
                                          TT_CLIENT_PENDING ? 'X' : '.'),
-                                        (tt_global_entry->flags &
+                                        (tt_global_entry->common.flags &
                                          TT_CLIENT_WIFI ? 'W' : '.'));
                 }
                 rcu_read_unlock();
         }
-
-        seq_printf(seq, "%s", buff);
-        kfree(buff);
 out:
         if (primary_if)
                 hardif_free_ref(primary_if);
@@ -679,13 +645,13 @@ static void _tt_global_del(struct bat_priv *bat_priv,
 
         bat_dbg(DBG_TT, bat_priv,
                 "Deleting global tt entry %pM (via %pM): %s\n",
-                tt_global_entry->addr, tt_global_entry->orig_node->orig,
+                tt_global_entry->common.addr, tt_global_entry->orig_node->orig,
                 message);
 
         atomic_dec(&tt_global_entry->orig_node->tt_size);
 
-        hash_remove(bat_priv->tt_global_hash, compare_gtt, choose_orig,
-                    tt_global_entry->addr);
+        hash_remove(bat_priv->tt_global_hash, compare_tt, choose_orig,
+                    tt_global_entry->common.addr);
 out:
         if (tt_global_entry)
                 tt_global_entry_free_ref(tt_global_entry);
@@ -713,9 +679,9 @@ void tt_global_del(struct bat_priv *bat_priv,
                          * 2) the client roamed to us => we can directly delete
                          *    the global entry, since it is useless now. */
                         tt_local_entry = tt_local_hash_find(bat_priv,
-                                                        tt_global_entry->addr);
+                                                            tt_global_entry->common.addr);
                         if (!tt_local_entry) {
-                                tt_global_entry->flags |= TT_CLIENT_ROAM;
+                                tt_global_entry->common.flags |= TT_CLIENT_ROAM;
                                 tt_global_entry->roam_at = jiffies;
                                 goto out;
                         }
@@ -733,7 +699,8 @@ void tt_global_del_orig(struct bat_priv *bat_priv,
                         struct orig_node *orig_node, const char *message)
 {
         struct tt_global_entry *tt_global_entry;
-        int i;
+        struct tt_common_entry *tt_common_entry;
+        uint32_t i;
         struct hashtable_t *hash = bat_priv->tt_global_hash;
         struct hlist_node *node, *safe;
         struct hlist_head *head;
@@ -747,14 +714,18 @@ void tt_global_del_orig(struct bat_priv *bat_priv,
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_global_entry, node, safe,
+                hlist_for_each_entry_safe(tt_common_entry, node, safe,
                                          head, hash_entry) {
+                        tt_global_entry = container_of(tt_common_entry,
+                                                       struct tt_global_entry,
+                                                       common);
                         if (tt_global_entry->orig_node == orig_node) {
                                 bat_dbg(DBG_TT, bat_priv,
                                         "Deleting global tt entry %pM "
-                                        "(via %pM): originator time out\n",
-                                        tt_global_entry->addr,
-                                        tt_global_entry->orig_node->orig);
+                                        "(via %pM): %s\n",
+                                        tt_global_entry->common.addr,
+                                        tt_global_entry->orig_node->orig,
+                                        message);
                                 hlist_del_rcu(node);
                                 tt_global_entry_free_ref(tt_global_entry);
                         }
@@ -767,20 +738,24 @@ void tt_global_del_orig(struct bat_priv *bat_priv,
 static void tt_global_roam_purge(struct bat_priv *bat_priv)
 {
         struct hashtable_t *hash = bat_priv->tt_global_hash;
+        struct tt_common_entry *tt_common_entry;
         struct tt_global_entry *tt_global_entry;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
         spinlock_t *list_lock; /* protects write access to the hash lists */
-        int i;
+        uint32_t i;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_global_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
                                           head, hash_entry) {
-                        if (!(tt_global_entry->flags & TT_CLIENT_ROAM))
+                        tt_global_entry = container_of(tt_common_entry,
+                                                       struct tt_global_entry,
+                                                       common);
+                        if (!(tt_global_entry->common.flags & TT_CLIENT_ROAM))
                                 continue;
                         if (!is_out_of_time(tt_global_entry->roam_at,
                                             TT_CLIENT_ROAM_TIMEOUT * 1000))
@@ -788,7 +763,7 @@ static void tt_global_roam_purge(struct bat_priv *bat_priv)
 
                         bat_dbg(DBG_TT, bat_priv, "Deleting global "
                                 "tt entry (%pM): Roaming timeout\n",
-                                tt_global_entry->addr);
+                                tt_global_entry->common.addr);
                         atomic_dec(&tt_global_entry->orig_node->tt_size);
                         hlist_del_rcu(node);
                         tt_global_entry_free_ref(tt_global_entry);
@@ -802,10 +777,11 @@ static void tt_global_table_free(struct bat_priv *bat_priv)
 {
         struct hashtable_t *hash;
         spinlock_t *list_lock; /* protects write access to the hash lists */
+        struct tt_common_entry *tt_common_entry;
         struct tt_global_entry *tt_global_entry;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
-        int i;
+        uint32_t i;
 
         if (!bat_priv->tt_global_hash)
                 return;
@@ -817,9 +793,12 @@ static void tt_global_table_free(struct bat_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_global_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
                                           head, hash_entry) {
                         hlist_del_rcu(node);
+                        tt_global_entry = container_of(tt_common_entry,
+                                                       struct tt_global_entry,
+                                                       common);
                         tt_global_entry_free_ref(tt_global_entry);
                 }
                 spin_unlock_bh(list_lock);
@@ -835,8 +814,8 @@ static bool _is_ap_isolated(struct tt_local_entry *tt_local_entry,
 {
         bool ret = false;
 
-        if (tt_local_entry->flags & TT_CLIENT_WIFI &&
-            tt_global_entry->flags & TT_CLIENT_WIFI)
+        if (tt_local_entry->common.flags & TT_CLIENT_WIFI &&
+            tt_global_entry->common.flags & TT_CLIENT_WIFI)
                 ret = true;
 
         return ret;
@@ -869,7 +848,7 @@ struct orig_node *transtable_search(struct bat_priv *bat_priv,
 
         /* A global client marked as PENDING has already moved from that
          * originator */
-        if (tt_global_entry->flags & TT_CLIENT_PENDING)
+        if (tt_global_entry->common.flags & TT_CLIENT_PENDING)
                 goto out;
 
         orig_node = tt_global_entry->orig_node;
@@ -888,29 +867,34 @@ uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node)
 {
         uint16_t total = 0, total_one;
         struct hashtable_t *hash = bat_priv->tt_global_hash;
+        struct tt_common_entry *tt_common_entry;
         struct tt_global_entry *tt_global_entry;
         struct hlist_node *node;
         struct hlist_head *head;
-        int i, j;
+        uint32_t i;
+        int j;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_global_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry, node,
                                          head, hash_entry) {
+                        tt_global_entry = container_of(tt_common_entry,
+                                                       struct tt_global_entry,
+                                                       common);
                         if (compare_eth(tt_global_entry->orig_node,
                                         orig_node)) {
                                 /* Roaming clients are in the global table for
                                  * consistency only. They don't have to be
                                  * taken into account while computing the
                                  * global crc */
-                                if (tt_global_entry->flags & TT_CLIENT_ROAM)
+                                if (tt_common_entry->flags & TT_CLIENT_ROAM)
                                         continue;
                                 total_one = 0;
                                 for (j = 0; j < ETH_ALEN; j++)
                                         total_one = crc16_byte(total_one,
-                                                tt_global_entry->addr[j]);
+                                                tt_common_entry->addr[j]);
                                 total ^= total_one;
                         }
                 }
@@ -925,25 +909,26 @@ uint16_t tt_local_crc(struct bat_priv *bat_priv)
 {
         uint16_t total = 0, total_one;
         struct hashtable_t *hash = bat_priv->tt_local_hash;
-        struct tt_local_entry *tt_local_entry;
+        struct tt_common_entry *tt_common_entry;
         struct hlist_node *node;
         struct hlist_head *head;
-        int i, j;
+        uint32_t i;
+        int j;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_local_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry, node,
                                          head, hash_entry) {
                         /* not yet committed clients have not to be taken into
                          * account while computing the CRC */
-                        if (tt_local_entry->flags & TT_CLIENT_NEW)
+                        if (tt_common_entry->flags & TT_CLIENT_NEW)
                                 continue;
                         total_one = 0;
                         for (j = 0; j < ETH_ALEN; j++)
                                 total_one = crc16_byte(total_one,
-                                                   tt_local_entry->addr[j]);
+                                                   tt_common_entry->addr[j]);
                         total ^= total_one;
                 }
                 rcu_read_unlock();
@@ -1032,21 +1017,25 @@ unlock:
 /* data_ptr is useless here, but has to be kept to respect the prototype */
 static int tt_local_valid_entry(const void *entry_ptr, const void *data_ptr)
 {
-        const struct tt_local_entry *tt_local_entry = entry_ptr;
+        const struct tt_common_entry *tt_common_entry = entry_ptr;
 
-        if (tt_local_entry->flags & TT_CLIENT_NEW)
+        if (tt_common_entry->flags & TT_CLIENT_NEW)
                 return 0;
         return 1;
 }
 
 static int tt_global_valid_entry(const void *entry_ptr, const void *data_ptr)
 {
-        const struct tt_global_entry *tt_global_entry = entry_ptr;
+        const struct tt_common_entry *tt_common_entry = entry_ptr;
+        const struct tt_global_entry *tt_global_entry;
         const struct orig_node *orig_node = data_ptr;
 
-        if (tt_global_entry->flags & TT_CLIENT_ROAM)
+        if (tt_common_entry->flags & TT_CLIENT_ROAM)
                 return 0;
 
+        tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
+                                       common);
+
         return (tt_global_entry->orig_node == orig_node);
 }
 
@@ -1057,7 +1046,7 @@ static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
                                                               const void *),
                                               void *cb_data)
 {
-        struct tt_local_entry *tt_local_entry;
+        struct tt_common_entry *tt_common_entry;
         struct tt_query_packet *tt_response;
         struct tt_change *tt_change;
         struct hlist_node *node;
@@ -1065,7 +1054,7 @@ static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
         struct sk_buff *skb = NULL;
         uint16_t tt_tot, tt_count;
         ssize_t tt_query_size = sizeof(struct tt_query_packet);
-        int i;
+        uint32_t i;
 
         if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
                 tt_len = primary_if->soft_iface->mtu - tt_query_size;
@@ -1089,15 +1078,16 @@ static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
-                hlist_for_each_entry_rcu(tt_local_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry, node,
                                          head, hash_entry) {
                         if (tt_count == tt_tot)
                                 break;
 
-                        if ((valid_cb) && (!valid_cb(tt_local_entry, cb_data)))
+                        if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
                                 continue;
 
-                        memcpy(tt_change->addr, tt_local_entry->addr, ETH_ALEN);
+                        memcpy(tt_change->addr, tt_common_entry->addr,
+                               ETH_ALEN);
                         tt_change->flags = NO_FLAGS;
 
                         tt_count++;
@@ -1204,11 +1194,11 @@ static bool send_other_tt_response(struct bat_priv *bat_priv,
                 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
 
         /* Let's get the orig node of the REAL destination */
-        req_dst_orig_node = get_orig_node(bat_priv, tt_request->dst);
+        req_dst_orig_node = orig_hash_find(bat_priv, tt_request->dst);
         if (!req_dst_orig_node)
                 goto out;
 
-        res_dst_orig_node = get_orig_node(bat_priv, tt_request->src);
+        res_dst_orig_node = orig_hash_find(bat_priv, tt_request->src);
         if (!res_dst_orig_node)
                 goto out;
 
@@ -1334,7 +1324,7 @@ static bool send_my_tt_response(struct bat_priv *bat_priv,
         my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
         req_ttvn = tt_request->ttvn;
 
-        orig_node = get_orig_node(bat_priv, tt_request->src);
+        orig_node = orig_hash_find(bat_priv, tt_request->src);
         if (!orig_node)
                 goto out;
 
@@ -1514,7 +1504,7 @@ bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr)
                 goto out;
         /* Check if the client has been logically deleted (but is kept for
          * consistency purpose) */
-        if (tt_local_entry->flags & TT_CLIENT_PENDING)
+        if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
                 goto out;
         ret = true;
 out:
@@ -1737,45 +1727,53 @@ void tt_free(struct bat_priv *bat_priv)
         kfree(bat_priv->tt_buff);
 }
 
-/* This function will reset the specified flags from all the entries in
- * the given hash table and will increment num_local_tt for each involved
- * entry */
-static void tt_local_reset_flags(struct bat_priv *bat_priv, uint16_t flags)
+/* This function will enable or disable the specified flags for all the entries
+ * in the given hash table and returns the number of modified entries */
+static uint16_t tt_set_flags(struct hashtable_t *hash, uint16_t flags,
+                             bool enable)
 {
-        int i;
-        struct hashtable_t *hash = bat_priv->tt_local_hash;
+        uint32_t i;
+        uint16_t changed_num = 0;
         struct hlist_head *head;
         struct hlist_node *node;
-        struct tt_local_entry *tt_local_entry;
+        struct tt_common_entry *tt_common_entry;
 
         if (!hash)
-                return;
+                goto out;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_local_entry, node,
+                hlist_for_each_entry_rcu(tt_common_entry, node,
                                          head, hash_entry) {
-                        if (!(tt_local_entry->flags & flags))
-                                continue;
-                        tt_local_entry->flags &= ~flags;
-                        atomic_inc(&bat_priv->num_local_tt);
+                        if (enable) {
+                                if ((tt_common_entry->flags & flags) == flags)
+                                        continue;
+                                tt_common_entry->flags |= flags;
+                        } else {
+                                if (!(tt_common_entry->flags & flags))
+                                        continue;
+                                tt_common_entry->flags &= ~flags;
+                        }
+                        changed_num++;
                 }
                 rcu_read_unlock();
         }
-
+out:
+        return changed_num;
 }
 
 /* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
 static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
 {
         struct hashtable_t *hash = bat_priv->tt_local_hash;
+        struct tt_common_entry *tt_common_entry;
         struct tt_local_entry *tt_local_entry;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
         spinlock_t *list_lock; /* protects write access to the hash lists */
-        int i;
+        uint32_t i;
 
         if (!hash)
                 return;
@@ -1785,16 +1783,19 @@ static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
                 list_lock = &hash->list_locks[i];
 
                 spin_lock_bh(list_lock);
-                hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
+                hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
                                           head, hash_entry) {
-                        if (!(tt_local_entry->flags & TT_CLIENT_PENDING))
+                        if (!(tt_common_entry->flags & TT_CLIENT_PENDING))
                                 continue;
 
                         bat_dbg(DBG_TT, bat_priv, "Deleting local tt entry "
-                                "(%pM): pending\n", tt_local_entry->addr);
+                                "(%pM): pending\n", tt_common_entry->addr);
 
                         atomic_dec(&bat_priv->num_local_tt);
                         hlist_del_rcu(node);
+                        tt_local_entry = container_of(tt_common_entry,
+                                                      struct tt_local_entry,
+                                                      common);
                         tt_local_entry_free_ref(tt_local_entry);
                 }
                 spin_unlock_bh(list_lock);
@@ -1804,7 +1805,11 @@ static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
 
 void tt_commit_changes(struct bat_priv *bat_priv)
 {
-        tt_local_reset_flags(bat_priv, TT_CLIENT_NEW);
+        uint16_t changed_num = tt_set_flags(bat_priv->tt_local_hash,
+                                            TT_CLIENT_NEW, false);
+        /* all the reset entries have now to be effectively counted as local
+         * entries */
+        atomic_add(changed_num, &bat_priv->num_local_tt);
         tt_local_purge_pending_clients(bat_priv);
 
         /* Increment the TTVN only once per OGM interval */
diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h
index ab8d0fe6df5a..e9eb043719ac 100644
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@ -222,24 +222,24 @@ struct socket_packet {
         struct icmp_packet_rr icmp_packet;
 };
 
-struct tt_local_entry {
+struct tt_common_entry {
         uint8_t addr[ETH_ALEN];
         struct hlist_node hash_entry;
-        unsigned long last_seen;
         uint16_t flags;
         atomic_t refcount;
         struct rcu_head rcu;
 };
 
+struct tt_local_entry {
+        struct tt_common_entry common;
+        unsigned long last_seen;
+};
+
 struct tt_global_entry {
-        uint8_t addr[ETH_ALEN];
-        struct hlist_node hash_entry; /* entry in the global table */
+        struct tt_common_entry common;
         struct orig_node *orig_node;
         uint8_t ttvn;
-        uint16_t flags; /* only TT_GLOBAL_ROAM is used */
         unsigned long roam_at; /* time at which TT_GLOBAL_ROAM was set */
-        atomic_t refcount;
-        struct rcu_head rcu;
 };
 
 struct tt_change_node {
diff --git a/net/batman-adv/vis.c b/net/batman-adv/vis.c
index f81a6b668b0c..cc3b9f2f3b5d 100644
--- a/net/batman-adv/vis.c
+++ b/net/batman-adv/vis.c
@@ -66,7 +66,7 @@ static int vis_info_cmp(const struct hlist_node *node, const void *data2)
 
 /* 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(const void *data, int size)
+static uint32_t vis_info_choose(const void *data, uint32_t size)
 {
         const struct vis_info *vis_info = data;
         const struct vis_packet *packet;
@@ -96,7 +96,7 @@ static struct vis_info *vis_hash_find(struct bat_priv *bat_priv,
         struct hlist_head *head;
         struct hlist_node *node;
         struct vis_info *vis_info, *vis_info_tmp = NULL;
-        int index;
+        uint32_t index;
 
         if (!hash)
                 return NULL;
@@ -202,7 +202,8 @@ int vis_seq_print_text(struct seq_file *seq, void *offset)
         HLIST_HEAD(vis_if_list);
         struct if_list_entry *entry;
         struct hlist_node *pos, *n;
-        int i, j, ret = 0;
+        uint32_t i;
+        int j, ret = 0;
         int vis_server = atomic_read(&bat_priv->vis_mode);
         size_t buff_pos, buf_size;
         char *buff;
@@ -556,7 +557,8 @@ static int find_best_vis_server(struct bat_priv *bat_priv,
         struct hlist_head *head;
         struct orig_node *orig_node;
         struct vis_packet *packet;
-        int best_tq = -1, i;
+        int best_tq = -1;
+        uint32_t i;
 
         packet = (struct vis_packet *)info->skb_packet->data;
 
@@ -607,8 +609,9 @@ static int generate_vis_packet(struct bat_priv *bat_priv)
         struct vis_info *info = bat_priv->my_vis_info;
         struct vis_packet *packet = (struct vis_packet *)info->skb_packet->data;
         struct vis_info_entry *entry;
-        struct tt_local_entry *tt_local_entry;
-        int best_tq = -1, i;
+        struct tt_common_entry *tt_common_entry;
+        int best_tq = -1;
+        uint32_t i;
 
         info->first_seen = jiffies;
         packet->vis_type = atomic_read(&bat_priv->vis_mode);
@@ -669,13 +672,13 @@ next:
                 head = &hash->table[i];
 
                 rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_local_entry, node, head,
+                hlist_for_each_entry_rcu(tt_common_entry, node, head,
                                          hash_entry) {
                         entry = (struct vis_info_entry *)
                                         skb_put(info->skb_packet,
                                                 sizeof(*entry));
                         memset(entry->src, 0, ETH_ALEN);
-                        memcpy(entry->dest, tt_local_entry->addr, ETH_ALEN);
+                        memcpy(entry->dest, tt_common_entry->addr, ETH_ALEN);
                         entry->quality = 0; /* 0 means TT */
                         packet->entries++;
 
@@ -696,7 +699,7 @@ unlock:
  * held */
 static void purge_vis_packets(struct bat_priv *bat_priv)
 {
-        int i;
+        uint32_t i;
         struct hashtable_t *hash = bat_priv->vis_hash;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
@@ -733,7 +736,7 @@ static void broadcast_vis_packet(struct bat_priv *bat_priv,
         struct sk_buff *skb;
         struct hard_iface *hard_iface;
         uint8_t dstaddr[ETH_ALEN];
-        int i;
+        uint32_t i;
 
 
         packet = (struct vis_packet *)info->skb_packet->data;