batman-adv: improved client announcement mechanism

The client announcement mechanism informs every mesh node in the network
of any connected non-mesh client, in order to find the path towards that
client from any given point in the mesh.

The old implementation was based on the simple idea of appending a data
buffer to each OGM containing all the client MAC addresses the node is
serving. All other nodes can populate their global translation tables
(table which links client MAC addresses to node addresses) using this
MAC address buffer and linking it to the node's address contained in the
OGM. A node that wants to contact a client has to lookup the node the
client is connected to and its address in the global translation table.

It is easy to understand that this implementation suffers from several
issues:
 - big overhead (each and every OGM contains the entire list of
   connected clients)
 - high latencies for client route updates due to long OGM trip time and
   OGM losses

The new implementation addresses these issues by appending client
changes (new client joined or a client left) to the OGM instead of
filling it with all the client addresses each time. In this way nodes
can modify their global tables by means of "updates", thus reducing the
overhead within the OGMs.

To keep the entire network in sync each node maintains a translation
table version number (ttvn) and a translation table checksum. These
values are spread with the OGM to allow all the network participants to
determine whether or not they need to update their translation table
information.

When a translation table lookup is performed in order to send a packet
to a client attached to another node, the destination's ttvn is added to
the payload packet. Forwarding nodes can compare the packet's ttvn with
their destination's ttvn (this node could have a fresher information
than the source) and re-route the packet if necessary. This greatly
reduces the packet loss of clients roaming from one AP to the next.

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

1 files changed, 943 insertions, 183 deletions

diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index 561f76968d5e..597cd1a43058 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -23,13 +23,17 @@
 #include "translation-table.h"
 #include "soft-interface.h"
 #include "hard-interface.h"
+#include "send.h"
 #include "hash.h"
 #include "originator.h"
+#include "routing.h"
 
-static void tt_local_purge(struct work_struct *work);
-static void _tt_global_del_orig(struct bat_priv *bat_priv,
-                                 struct tt_global_entry *tt_global_entry,
-                                 const char *message);
+#include <linux/crc16.h>
+
+static void _tt_global_del(struct bat_priv *bat_priv,
+                           struct tt_global_entry *tt_global_entry,
+                           const char *message);
+static void 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)
@@ -49,10 +53,11 @@ static int compare_gtt(const struct hlist_node *node, const void *data2)
         return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
 }
 
-static void tt_local_start_timer(struct bat_priv *bat_priv)
+static void tt_start_timer(struct bat_priv *bat_priv)
 {
-        INIT_DELAYED_WORK(&bat_priv->tt_work, tt_local_purge);
-        queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work, 10 * HZ);
+        INIT_DELAYED_WORK(&bat_priv->tt_work, tt_purge);
+        queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work,
+                           msecs_to_jiffies(5000));
 }
 
 static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
@@ -112,7 +117,42 @@ static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
         return tt_global_entry_tmp;
 }
 
-int tt_local_init(struct bat_priv *bat_priv)
+static bool is_out_of_time(unsigned long starting_time, unsigned long timeout)
+{
+        unsigned long deadline;
+        deadline = starting_time + msecs_to_jiffies(timeout);
+
+        return time_after(jiffies, deadline);
+}
+
+static void tt_local_event(struct bat_priv *bat_priv, uint8_t op,
+                           const uint8_t *addr)
+{
+        struct tt_change_node *tt_change_node;
+
+        tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
+
+        if (!tt_change_node)
+                return;
+
+        tt_change_node->change.flags = op;
+        memcpy(tt_change_node->change.addr, addr, ETH_ALEN);
+
+        spin_lock_bh(&bat_priv->tt_changes_list_lock);
+        /* track the change in the OGMinterval list */
+        list_add_tail(&tt_change_node->list, &bat_priv->tt_changes_list);
+        atomic_inc(&bat_priv->tt_local_changes);
+        spin_unlock_bh(&bat_priv->tt_changes_list_lock);
+
+        atomic_set(&bat_priv->tt_ogm_append_cnt, 0);
+}
+
+int tt_len(int changes_num)
+{
+        return changes_num * sizeof(struct tt_change);
+}
+
+static int tt_local_init(struct bat_priv *bat_priv)
 {
         if (bat_priv->tt_local_hash)
                 return 1;
@@ -122,9 +162,6 @@ int tt_local_init(struct bat_priv *bat_priv)
         if (!bat_priv->tt_local_hash)
                 return 0;
 
-        atomic_set(&bat_priv->tt_local_changed, 0);
-        tt_local_start_timer(bat_priv);
-
         return 1;
 }
 
@@ -133,40 +170,24 @@ 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;
         struct tt_global_entry *tt_global_entry;
-        int required_bytes;
 
         spin_lock_bh(&bat_priv->tt_lhash_lock);
         tt_local_entry = tt_local_hash_find(bat_priv, addr);
-        spin_unlock_bh(&bat_priv->tt_lhash_lock);
 
         if (tt_local_entry) {
                 tt_local_entry->last_seen = jiffies;
-                return;
-        }
-
-        /* only announce as many hosts as possible in the batman-packet and
-           space in batman_packet->num_tt That also should give a limit to
-           MAC-flooding. */
-        required_bytes = (bat_priv->num_local_tt + 1) * ETH_ALEN;
-        required_bytes += BAT_PACKET_LEN;
-
-        if ((required_bytes > ETH_DATA_LEN) ||
-            (atomic_read(&bat_priv->aggregated_ogms) &&
-             required_bytes > MAX_AGGREGATION_BYTES) ||
-            (bat_priv->num_local_tt + 1 > 255)) {
-                bat_dbg(DBG_ROUTES, bat_priv,
-                        "Can't add new local tt entry (%pM): "
-                        "number of local tt entries exceeds packet size\n",
-                        addr);
-                return;
+                goto unlock;
         }
 
-        bat_dbg(DBG_ROUTES, bat_priv,
-                "Creating new local tt entry: %pM\n", addr);
-
         tt_local_entry = kmalloc(sizeof(*tt_local_entry), GFP_ATOMIC);
         if (!tt_local_entry)
-                return;
+                goto unlock;
+
+        tt_local_event(bat_priv, NO_FLAGS, addr);
+
+        bat_dbg(DBG_TT, bat_priv,
+                "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;
@@ -177,13 +198,9 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr)
         else
                 tt_local_entry->never_purge = 0;
 
-        spin_lock_bh(&bat_priv->tt_lhash_lock);
-
         hash_add(bat_priv->tt_local_hash, compare_ltt, choose_orig,
                  tt_local_entry, &tt_local_entry->hash_entry);
-        bat_priv->num_local_tt++;
-        atomic_set(&bat_priv->tt_local_changed, 1);
-
+        atomic_inc(&bat_priv->num_local_tt);
         spin_unlock_bh(&bat_priv->tt_lhash_lock);
 
         /* remove address from global hash if present */
@@ -192,46 +209,60 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr)
         tt_global_entry = tt_global_hash_find(bat_priv, addr);
 
         if (tt_global_entry)
-                _tt_global_del_orig(bat_priv, tt_global_entry,
-                                     "local tt received");
+                _tt_global_del(bat_priv, tt_global_entry,
+                               "local tt received");
 
         spin_unlock_bh(&bat_priv->tt_ghash_lock);
+        return;
+unlock:
+        spin_unlock_bh(&bat_priv->tt_lhash_lock);
 }
 
-int tt_local_fill_buffer(struct bat_priv *bat_priv,
-                          unsigned char *buff, int buff_len)
+int tt_changes_fill_buffer(struct bat_priv *bat_priv,
+                           unsigned char *buff, int buff_len)
 {
-        struct hashtable_t *hash = bat_priv->tt_local_hash;
-        struct tt_local_entry *tt_local_entry;
-        struct hlist_node *node;
-        struct hlist_head *head;
-        int i, count = 0;
+        int count = 0, tot_changes = 0;
+        struct tt_change_node *entry, *safe;
 
-        spin_lock_bh(&bat_priv->tt_lhash_lock);
+        if (buff_len > 0)
+                tot_changes = buff_len / tt_len(1);
 
-        for (i = 0; i < hash->size; i++) {
-                head = &hash->table[i];
-
-                rcu_read_lock();
-                hlist_for_each_entry_rcu(tt_local_entry, node,
-                                         head, hash_entry) {
-                        if (buff_len < (count + 1) * ETH_ALEN)
-                                break;
-
-                        memcpy(buff + (count * ETH_ALEN), tt_local_entry->addr,
-                               ETH_ALEN);
+        spin_lock_bh(&bat_priv->tt_changes_list_lock);
+        atomic_set(&bat_priv->tt_local_changes, 0);
 
+        list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
+                        list) {
+                if (count < tot_changes) {
+                        memcpy(buff + tt_len(count),
+                               &entry->change, sizeof(struct tt_change));
                         count++;
                 }
-                rcu_read_unlock();
+                list_del(&entry->list);
+                kfree(entry);
         }
+        spin_unlock_bh(&bat_priv->tt_changes_list_lock);
+
+        /* Keep the buffer for possible tt_request */
+        spin_lock_bh(&bat_priv->tt_buff_lock);
+        kfree(bat_priv->tt_buff);
+        bat_priv->tt_buff_len = 0;
+        bat_priv->tt_buff = NULL;
+        /* We check whether this new OGM has no changes due to size
+         * problems */
+        if (buff_len > 0) {
+                /**
+                 * if kmalloc() fails we will reply with the full table
+                 * instead of providing the diff
+                 */
+                bat_priv->tt_buff = kmalloc(buff_len, GFP_ATOMIC);
+                if (bat_priv->tt_buff) {
+                        memcpy(bat_priv->tt_buff, buff, buff_len);
+                        bat_priv->tt_buff_len = buff_len;
+                }
+        }
+        spin_unlock_bh(&bat_priv->tt_buff_lock);
 
-        /* if we did not get all new local tts see you next time  ;-) */
-        if (count == bat_priv->num_local_tt)
-                atomic_set(&bat_priv->tt_local_changed, 0);
-
-        spin_unlock_bh(&bat_priv->tt_lhash_lock);
-        return count;
+        return tot_changes;
 }
 
 int tt_local_seq_print_text(struct seq_file *seq, void *offset)
@@ -263,8 +294,8 @@ int tt_local_seq_print_text(struct seq_file *seq, void *offset)
         }
 
         seq_printf(seq, "Locally retrieved addresses (from %s) "
-                   "announced via TT:\n",
-                   net_dev->name);
+                   "announced via TT (TTVN: %u):\n",
+                   net_dev->name, (uint8_t)atomic_read(&bat_priv->ttvn));
 
         spin_lock_bh(&bat_priv->tt_lhash_lock);
 
@@ -311,54 +342,51 @@ out:
         return ret;
 }
 
-static void _tt_local_del(struct hlist_node *node, void *arg)
+static void tt_local_entry_free(struct hlist_node *node, void *arg)
 {
         struct bat_priv *bat_priv = arg;
         void *data = container_of(node, struct tt_local_entry, hash_entry);
 
         kfree(data);
-        bat_priv->num_local_tt--;
-        atomic_set(&bat_priv->tt_local_changed, 1);
+        atomic_dec(&bat_priv->num_local_tt);
 }
 
 static void tt_local_del(struct bat_priv *bat_priv,
                          struct tt_local_entry *tt_local_entry,
                          const char *message)
 {
-        bat_dbg(DBG_ROUTES, bat_priv, "Deleting local tt entry (%pM): %s\n",
+        bat_dbg(DBG_TT, bat_priv, "Deleting local tt entry (%pM): %s\n",
                 tt_local_entry->addr, message);
 
+        atomic_dec(&bat_priv->num_local_tt);
+
         hash_remove(bat_priv->tt_local_hash, compare_ltt, choose_orig,
                     tt_local_entry->addr);
-        _tt_local_del(&tt_local_entry->hash_entry, bat_priv);
+
+        tt_local_entry_free(&tt_local_entry->hash_entry, bat_priv);
 }
 
-void tt_local_remove(struct bat_priv *bat_priv,
-                     const uint8_t *addr, const char *message)
+void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
+                     const char *message)
 {
         struct tt_local_entry *tt_local_entry;
 
         spin_lock_bh(&bat_priv->tt_lhash_lock);
-
         tt_local_entry = tt_local_hash_find(bat_priv, addr);
 
-        if (tt_local_entry)
+        if (tt_local_entry) {
+                tt_local_event(bat_priv, TT_CHANGE_DEL, tt_local_entry->addr);
                 tt_local_del(bat_priv, tt_local_entry, message);
-
+        }
         spin_unlock_bh(&bat_priv->tt_lhash_lock);
 }
 
-static void tt_local_purge(struct work_struct *work)
+static void tt_local_purge(struct bat_priv *bat_priv)
 {
-        struct delayed_work *delayed_work =
-                container_of(work, struct delayed_work, work);
-        struct bat_priv *bat_priv =
-                container_of(delayed_work, struct bat_priv, tt_work);
         struct hashtable_t *hash = bat_priv->tt_local_hash;
         struct tt_local_entry *tt_local_entry;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
-        unsigned long timeout;
         int i;
 
         spin_lock_bh(&bat_priv->tt_lhash_lock);
@@ -371,32 +399,53 @@ static void tt_local_purge(struct work_struct *work)
                         if (tt_local_entry->never_purge)
                                 continue;
 
-                        timeout = tt_local_entry->last_seen;
-                        timeout += TT_LOCAL_TIMEOUT * HZ;
-
-                        if (time_before(jiffies, timeout))
+                        if (!is_out_of_time(tt_local_entry->last_seen,
+                                           TT_LOCAL_TIMEOUT * 1000))
                                 continue;
 
+                        tt_local_event(bat_priv, TT_CHANGE_DEL,
+                                       tt_local_entry->addr);
                         tt_local_del(bat_priv, tt_local_entry,
-                                      "address timed out");
+                                     "address timed out");
                 }
         }
 
         spin_unlock_bh(&bat_priv->tt_lhash_lock);
-        tt_local_start_timer(bat_priv);
 }
 
-void tt_local_free(struct bat_priv *bat_priv)
+static void tt_local_table_free(struct bat_priv *bat_priv)
 {
+        struct hashtable_t *hash;
+        int i;
+        spinlock_t *list_lock; /* protects write access to the hash lists */
+        struct hlist_head *head;
+        struct hlist_node *node, *node_tmp;
+        struct tt_local_entry *tt_local_entry;
+
         if (!bat_priv->tt_local_hash)
                 return;
 
-        cancel_delayed_work_sync(&bat_priv->tt_work);
-        hash_delete(bat_priv->tt_local_hash, _tt_local_del, bat_priv);
+        hash = bat_priv->tt_local_hash;
+
+        for (i = 0; i < hash->size; i++) {
+                head = &hash->table[i];
+                list_lock = &hash->list_locks[i];
+
+                spin_lock_bh(list_lock);
+                hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
+                                          head, hash_entry) {
+                        hlist_del_rcu(node);
+                        kfree(tt_local_entry);
+                }
+                spin_unlock_bh(list_lock);
+        }
+
+        hash_destroy(hash);
+
         bat_priv->tt_local_hash = NULL;
 }
 
-int tt_global_init(struct bat_priv *bat_priv)
+static int tt_global_init(struct bat_priv *bat_priv)
 {
         if (bat_priv->tt_global_hash)
                 return 1;
@@ -409,73 +458,78 @@ int tt_global_init(struct bat_priv *bat_priv)
         return 1;
 }
 
-void tt_global_add_orig(struct bat_priv *bat_priv,
-                         struct orig_node *orig_node,
-                         const unsigned char *tt_buff, int tt_buff_len)
+static void tt_changes_list_free(struct bat_priv *bat_priv)
 {
-        struct tt_global_entry *tt_global_entry;
-        struct tt_local_entry *tt_local_entry;
-        int tt_buff_count = 0;
-        const unsigned char *tt_ptr;
-
-        while ((tt_buff_count + 1) * ETH_ALEN <= tt_buff_len) {
-                spin_lock_bh(&bat_priv->tt_ghash_lock);
-
-                tt_ptr = tt_buff + (tt_buff_count * ETH_ALEN);
-                tt_global_entry = tt_global_hash_find(bat_priv, tt_ptr);
+        struct tt_change_node *entry, *safe;
 
-                if (!tt_global_entry) {
-                        spin_unlock_bh(&bat_priv->tt_ghash_lock);
+        spin_lock_bh(&bat_priv->tt_changes_list_lock);
 
-                        tt_global_entry = kmalloc(sizeof(*tt_global_entry),
-                                                  GFP_ATOMIC);
-
-                        if (!tt_global_entry)
-                                break;
-
-                        memcpy(tt_global_entry->addr, tt_ptr, ETH_ALEN);
-
-                        bat_dbg(DBG_ROUTES, bat_priv,
-                                "Creating new global tt entry: "
-                                "%pM (via %pM)\n",
-                                tt_global_entry->addr, orig_node->orig);
+        list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
+                                 list) {
+                list_del(&entry->list);
+                kfree(entry);
+        }
 
-                        spin_lock_bh(&bat_priv->tt_ghash_lock);
-                        hash_add(bat_priv->tt_global_hash, compare_gtt,
-                                 choose_orig, tt_global_entry,
-                                 &tt_global_entry->hash_entry);
+        atomic_set(&bat_priv->tt_local_changes, 0);
+        spin_unlock_bh(&bat_priv->tt_changes_list_lock);
+}
 
-                }
+/* caller must hold orig_node refcount */
+int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
+                  const unsigned char *tt_addr, uint8_t ttvn)
+{
+        struct tt_global_entry *tt_global_entry;
+        struct tt_local_entry *tt_local_entry;
+        struct orig_node *orig_node_tmp;
 
+        spin_lock_bh(&bat_priv->tt_ghash_lock);
+        tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
+
+        if (!tt_global_entry) {
+                tt_global_entry =
+                        kmalloc(sizeof(*tt_global_entry),
+                                GFP_ATOMIC);
+                if (!tt_global_entry)
+                        goto unlock;
+                memcpy(tt_global_entry->addr, tt_addr, ETH_ALEN);
+                /* Assign the new orig_node */
+                atomic_inc(&orig_node->refcount);
                 tt_global_entry->orig_node = orig_node;
-                spin_unlock_bh(&bat_priv->tt_ghash_lock);
-
-                /* remove address from local hash if present */
-                spin_lock_bh(&bat_priv->tt_lhash_lock);
-
-                tt_ptr = tt_buff + (tt_buff_count * ETH_ALEN);
-                tt_local_entry = tt_local_hash_find(bat_priv, tt_ptr);
-
-                if (tt_local_entry)
-                        tt_local_del(bat_priv, tt_local_entry,
-                                      "global tt received");
+                tt_global_entry->ttvn = ttvn;
+                atomic_inc(&orig_node->tt_size);
+                hash_add(bat_priv->tt_global_hash, compare_gtt,
+                         choose_orig, tt_global_entry,
+                         &tt_global_entry->hash_entry);
+        } else {
+                if (tt_global_entry->orig_node != orig_node) {
+                        atomic_dec(&tt_global_entry->orig_node->tt_size);
+                        orig_node_tmp = tt_global_entry->orig_node;
+                        atomic_inc(&orig_node->refcount);
+                        tt_global_entry->orig_node = orig_node;
+                        tt_global_entry->ttvn = ttvn;
+                        orig_node_free_ref(orig_node_tmp);
+                        atomic_inc(&orig_node->tt_size);
+                }
+        }
 
-                spin_unlock_bh(&bat_priv->tt_lhash_lock);
+        spin_unlock_bh(&bat_priv->tt_ghash_lock);
 
-                tt_buff_count++;
-        }
+        bat_dbg(DBG_TT, bat_priv,
+                "Creating new global tt entry: %pM (via %pM)\n",
+                tt_global_entry->addr, orig_node->orig);
 
-        /* initialize, and overwrite if malloc succeeds */
-        orig_node->tt_buff = NULL;
-        orig_node->tt_buff_len = 0;
+        /* remove address from local hash if present */
+        spin_lock_bh(&bat_priv->tt_lhash_lock);
+        tt_local_entry = tt_local_hash_find(bat_priv, tt_addr);
 
-        if (tt_buff_len > 0) {
-                orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
-                if (orig_node->tt_buff) {
-                        memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
-                        orig_node->tt_buff_len = tt_buff_len;
-                }
-        }
+        if (tt_local_entry)
+                tt_local_del(bat_priv, tt_local_entry,
+                             "global tt received");
+        spin_unlock_bh(&bat_priv->tt_lhash_lock);
+        return 1;
+unlock:
+        spin_unlock_bh(&bat_priv->tt_ghash_lock);
+        return 0;
 }
 
 int tt_global_seq_print_text(struct seq_file *seq, void *offset)
@@ -509,17 +563,20 @@ int tt_global_seq_print_text(struct seq_file *seq, void *offset)
         seq_printf(seq,
                    "Globally announced TT entries received via the mesh %s\n",
                    net_dev->name);
+        seq_printf(seq, "       %-13s %s       %-15s %s\n",
+                   "Client", "(TTVN)", "Originator", "(Curr TTVN)");
 
         spin_lock_bh(&bat_priv->tt_ghash_lock);
 
         buf_size = 1;
-        /* Estimate length for: " * xx:xx:xx:xx:xx:xx via xx:xx:xx:xx:xx:xx\n"*/
+        /* 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 += 43;
+                        buf_size += 59;
                 rcu_read_unlock();
         }
 
@@ -538,10 +595,14 @@ int tt_global_seq_print_text(struct seq_file *seq, void *offset)
                 rcu_read_lock();
                 hlist_for_each_entry_rcu(tt_global_entry, node,
                                          head, hash_entry) {
-                        pos += snprintf(buff + pos, 44,
-                                        " * %pM via %pM\n",
+                        pos += snprintf(buff + pos, 61,
+                                        " * %pM  (%3u) via %pM     (%3u)\n",
                                         tt_global_entry->addr,
-                                        tt_global_entry->orig_node->orig);
+                                        tt_global_entry->ttvn,
+                                        tt_global_entry->orig_node->orig,
+                                        (uint8_t) atomic_read(
+                                                &tt_global_entry->orig_node->
+                                                last_ttvn));
                 }
                 rcu_read_unlock();
         }
@@ -556,64 +617,80 @@ out:
         return ret;
 }
 
-static void _tt_global_del_orig(struct bat_priv *bat_priv,
-                                 struct tt_global_entry *tt_global_entry,
-                                 const char *message)
+static void _tt_global_del(struct bat_priv *bat_priv,
+                           struct tt_global_entry *tt_global_entry,
+                           const char *message)
 {
-        bat_dbg(DBG_ROUTES, bat_priv,
+        if (!tt_global_entry)
+                return;
+
+        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,
                 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);
         kfree(tt_global_entry);
 }
 
+void tt_global_del(struct bat_priv *bat_priv,
+                   struct orig_node *orig_node, const unsigned char *addr,
+                   const char *message)
+{
+        struct tt_global_entry *tt_global_entry;
+
+        spin_lock_bh(&bat_priv->tt_ghash_lock);
+        tt_global_entry = tt_global_hash_find(bat_priv, addr);
+
+        if (tt_global_entry && tt_global_entry->orig_node == orig_node) {
+                atomic_dec(&orig_node->tt_size);
+                _tt_global_del(bat_priv, tt_global_entry, message);
+        }
+        spin_unlock_bh(&bat_priv->tt_ghash_lock);
+}
+
 void tt_global_del_orig(struct bat_priv *bat_priv,
-                         struct orig_node *orig_node, const char *message)
+                        struct orig_node *orig_node, const char *message)
 {
         struct tt_global_entry *tt_global_entry;
-        int tt_buff_count = 0;
-        unsigned char *tt_ptr;
+        int i;
+        struct hashtable_t *hash = bat_priv->tt_global_hash;
+        struct hlist_node *node, *safe;
+        struct hlist_head *head;
 
-        if (orig_node->tt_buff_len == 0)
+        if (!bat_priv->tt_global_hash)
                 return;
 
         spin_lock_bh(&bat_priv->tt_ghash_lock);
+        for (i = 0; i < hash->size; i++) {
+                head = &hash->table[i];
 
-        while ((tt_buff_count + 1) * ETH_ALEN <= orig_node->tt_buff_len) {
-                tt_ptr = orig_node->tt_buff + (tt_buff_count * ETH_ALEN);
-                tt_global_entry = tt_global_hash_find(bat_priv, tt_ptr);
-
-                if ((tt_global_entry) &&
-                    (tt_global_entry->orig_node == orig_node))
-                        _tt_global_del_orig(bat_priv, tt_global_entry,
-                                             message);
-
-                tt_buff_count++;
+                hlist_for_each_entry_safe(tt_global_entry, node, safe,
+                                         head, hash_entry) {
+                        if (tt_global_entry->orig_node == orig_node)
+                                _tt_global_del(bat_priv, tt_global_entry,
+                                               message);
+                }
         }
+        atomic_set(&orig_node->tt_size, 0);
 
         spin_unlock_bh(&bat_priv->tt_ghash_lock);
-
-        orig_node->tt_buff_len = 0;
-        kfree(orig_node->tt_buff);
-        orig_node->tt_buff = NULL;
 }
 
-static void tt_global_del(struct hlist_node *node, void *arg)
+static void tt_global_entry_free(struct hlist_node *node, void *arg)
 {
         void *data = container_of(node, struct tt_global_entry, hash_entry);
-
         kfree(data);
 }
 
-void tt_global_free(struct bat_priv *bat_priv)
+static void tt_global_table_free(struct bat_priv *bat_priv)
 {
         if (!bat_priv->tt_global_hash)
                 return;
 
-        hash_delete(bat_priv->tt_global_hash, tt_global_del, NULL);
+        hash_delete(bat_priv->tt_global_hash, tt_global_entry_free, NULL);
         bat_priv->tt_global_hash = NULL;
 }
 
@@ -638,3 +715,686 @@ out:
         spin_unlock_bh(&bat_priv->tt_ghash_lock);
         return orig_node;
 }
+
+/* Calculates the checksum of the local table of a given orig_node */
+uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node)
+{
+        uint16_t total = 0, total_one;
+        struct hashtable_t *hash = bat_priv->tt_global_hash;
+        struct tt_global_entry *tt_global_entry;
+        struct hlist_node *node;
+        struct hlist_head *head;
+        int i, j;
+
+        for (i = 0; i < hash->size; i++) {
+                head = &hash->table[i];
+
+                rcu_read_lock();
+                hlist_for_each_entry_rcu(tt_global_entry, node,
+                                         head, hash_entry) {
+                        if (compare_eth(tt_global_entry->orig_node,
+                                        orig_node)) {
+                                total_one = 0;
+                                for (j = 0; j < ETH_ALEN; j++)
+                                        total_one = crc16_byte(total_one,
+                                                tt_global_entry->addr[j]);
+                                total ^= total_one;
+                        }
+                }
+                rcu_read_unlock();
+        }
+
+        return total;
+}
+
+/* Calculates the checksum of the local table */
+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 hlist_node *node;
+        struct hlist_head *head;
+        int i, j;
+
+        for (i = 0; i < hash->size; i++) {
+                head = &hash->table[i];
+
+                rcu_read_lock();
+                hlist_for_each_entry_rcu(tt_local_entry, node,
+                                         head, hash_entry) {
+                        total_one = 0;
+                        for (j = 0; j < ETH_ALEN; j++)
+                                total_one = crc16_byte(total_one,
+                                                   tt_local_entry->addr[j]);
+                        total ^= total_one;
+                }
+
+                rcu_read_unlock();
+        }
+
+        return total;
+}
+
+static void tt_req_list_free(struct bat_priv *bat_priv)
+{
+        struct tt_req_node *node, *safe;
+
+        spin_lock_bh(&bat_priv->tt_req_list_lock);
+
+        list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
+                list_del(&node->list);
+                kfree(node);
+        }
+
+        spin_unlock_bh(&bat_priv->tt_req_list_lock);
+}
+
+void tt_save_orig_buffer(struct bat_priv *bat_priv, struct orig_node *orig_node,
+                         const unsigned char *tt_buff, uint8_t tt_num_changes)
+{
+        uint16_t tt_buff_len = tt_len(tt_num_changes);
+
+        /* Replace the old buffer only if I received something in the
+         * last OGM (the OGM could carry no changes) */
+        spin_lock_bh(&orig_node->tt_buff_lock);
+        if (tt_buff_len > 0) {
+                kfree(orig_node->tt_buff);
+                orig_node->tt_buff_len = 0;
+                orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
+                if (orig_node->tt_buff) {
+                        memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
+                        orig_node->tt_buff_len = tt_buff_len;
+                }
+        }
+        spin_unlock_bh(&orig_node->tt_buff_lock);
+}
+
+static void tt_req_purge(struct bat_priv *bat_priv)
+{
+        struct tt_req_node *node, *safe;
+
+        spin_lock_bh(&bat_priv->tt_req_list_lock);
+        list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
+                if (is_out_of_time(node->issued_at,
+                    TT_REQUEST_TIMEOUT * 1000)) {
+                        list_del(&node->list);
+                        kfree(node);
+                }
+        }
+        spin_unlock_bh(&bat_priv->tt_req_list_lock);
+}
+
+/* returns the pointer to the new tt_req_node struct if no request
+ * has already been issued for this orig_node, NULL otherwise */
+static struct tt_req_node *new_tt_req_node(struct bat_priv *bat_priv,
+                                          struct orig_node *orig_node)
+{
+        struct tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
+
+        spin_lock_bh(&bat_priv->tt_req_list_lock);
+        list_for_each_entry(tt_req_node_tmp, &bat_priv->tt_req_list, list) {
+                if (compare_eth(tt_req_node_tmp, orig_node) &&
+                    !is_out_of_time(tt_req_node_tmp->issued_at,
+                                    TT_REQUEST_TIMEOUT * 1000))
+                        goto unlock;
+        }
+
+        tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
+        if (!tt_req_node)
+                goto unlock;
+
+        memcpy(tt_req_node->addr, orig_node->orig, ETH_ALEN);
+        tt_req_node->issued_at = jiffies;
+
+        list_add(&tt_req_node->list, &bat_priv->tt_req_list);
+unlock:
+        spin_unlock_bh(&bat_priv->tt_req_list_lock);
+        return tt_req_node;
+}
+
+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 orig_node *orig_node = data_ptr;
+
+        return (tt_global_entry->orig_node == orig_node);
+}
+
+static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
+                                              struct hashtable_t *hash,
+                                              struct hard_iface *primary_if,
+                                              int (*valid_cb)(const void *,
+                                                              const void *),
+                                              void *cb_data)
+{
+        struct tt_local_entry *tt_local_entry;
+        struct tt_query_packet *tt_response;
+        struct tt_change *tt_change;
+        struct hlist_node *node;
+        struct hlist_head *head;
+        struct sk_buff *skb = NULL;
+        uint16_t tt_tot, tt_count;
+        ssize_t tt_query_size = sizeof(struct tt_query_packet);
+        int i;
+
+        if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
+                tt_len = primary_if->soft_iface->mtu - tt_query_size;
+                tt_len -= tt_len % sizeof(struct tt_change);
+        }
+        tt_tot = tt_len / sizeof(struct tt_change);
+
+        skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN);
+        if (!skb)
+                goto out;
+
+        skb_reserve(skb, ETH_HLEN);
+        tt_response = (struct tt_query_packet *)skb_put(skb,
+                                                     tt_query_size + tt_len);
+        tt_response->ttvn = ttvn;
+        tt_response->tt_data = htons(tt_tot);
+
+        tt_change = (struct tt_change *)(skb->data + tt_query_size);
+        tt_count = 0;
+
+        rcu_read_lock();
+        for (i = 0; i < hash->size; i++) {
+                head = &hash->table[i];
+
+                hlist_for_each_entry_rcu(tt_local_entry, node,
+                                         head, hash_entry) {
+                        if (tt_count == tt_tot)
+                                break;
+
+                        if ((valid_cb) && (!valid_cb(tt_local_entry, cb_data)))
+                                continue;
+
+                        memcpy(tt_change->addr, tt_local_entry->addr, ETH_ALEN);
+                        tt_change->flags = NO_FLAGS;
+
+                        tt_count++;
+                        tt_change++;
+                }
+        }
+        rcu_read_unlock();
+
+out:
+        return skb;
+}
+
+int send_tt_request(struct bat_priv *bat_priv, struct orig_node *dst_orig_node,
+                    uint8_t ttvn, uint16_t tt_crc, bool full_table)
+{
+        struct sk_buff *skb = NULL;
+        struct tt_query_packet *tt_request;
+        struct neigh_node *neigh_node = NULL;
+        struct hard_iface *primary_if;
+        struct tt_req_node *tt_req_node = NULL;
+        int ret = 1;
+
+        primary_if = primary_if_get_selected(bat_priv);
+        if (!primary_if)
+                goto out;
+
+        /* The new tt_req will be issued only if I'm not waiting for a
+         * reply from the same orig_node yet */
+        tt_req_node = new_tt_req_node(bat_priv, dst_orig_node);
+        if (!tt_req_node)
+                goto out;
+
+        skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN);
+        if (!skb)
+                goto out;
+
+        skb_reserve(skb, ETH_HLEN);
+
+        tt_request = (struct tt_query_packet *)skb_put(skb,
+                                sizeof(struct tt_query_packet));
+
+        tt_request->packet_type = BAT_TT_QUERY;
+        tt_request->version = COMPAT_VERSION;
+        memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN);
+        memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN);
+        tt_request->ttl = TTL;
+        tt_request->ttvn = ttvn;
+        tt_request->tt_data = tt_crc;
+        tt_request->flags = TT_REQUEST;
+
+        if (full_table)
+                tt_request->flags |= TT_FULL_TABLE;
+
+        neigh_node = orig_node_get_router(dst_orig_node);
+        if (!neigh_node)
+                goto out;
+
+        bat_dbg(DBG_TT, bat_priv, "Sending TT_REQUEST to %pM via %pM "
+                "[%c]\n", dst_orig_node->orig, neigh_node->addr,
+                (full_table ? 'F' : '.'));
+
+        send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
+        ret = 0;
+
+out:
+        if (neigh_node)
+                neigh_node_free_ref(neigh_node);
+        if (primary_if)
+                hardif_free_ref(primary_if);
+        if (ret)
+                kfree_skb(skb);
+        if (ret && tt_req_node) {
+                spin_lock_bh(&bat_priv->tt_req_list_lock);
+                list_del(&tt_req_node->list);
+                spin_unlock_bh(&bat_priv->tt_req_list_lock);
+                kfree(tt_req_node);
+        }
+        return ret;
+}
+
+static bool send_other_tt_response(struct bat_priv *bat_priv,
+                                   struct tt_query_packet *tt_request)
+{
+        struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
+        struct neigh_node *neigh_node = NULL;
+        struct hard_iface *primary_if = NULL;
+        uint8_t orig_ttvn, req_ttvn, ttvn;
+        int ret = false;
+        unsigned char *tt_buff;
+        bool full_table;
+        uint16_t tt_len, tt_tot;
+        struct sk_buff *skb = NULL;
+        struct tt_query_packet *tt_response;
+
+        bat_dbg(DBG_TT, bat_priv,
+                "Received TT_REQUEST from %pM for "
+                "ttvn: %u (%pM) [%c]\n", tt_request->src,
+                tt_request->ttvn, tt_request->dst,
+                (tt_request->flags & 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);
+        if (!req_dst_orig_node)
+                goto out;
+
+        res_dst_orig_node = get_orig_node(bat_priv, tt_request->src);
+        if (!res_dst_orig_node)
+                goto out;
+
+        neigh_node = orig_node_get_router(res_dst_orig_node);
+        if (!neigh_node)
+                goto out;
+
+        primary_if = primary_if_get_selected(bat_priv);
+        if (!primary_if)
+                goto out;
+
+        orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
+        req_ttvn = tt_request->ttvn;
+
+        /* I have not the requested data */
+        if (orig_ttvn != req_ttvn ||
+            tt_request->tt_data != req_dst_orig_node->tt_crc)
+                goto out;
+
+        /* If it has explicitly been requested the full table */
+        if (tt_request->flags & TT_FULL_TABLE ||
+            !req_dst_orig_node->tt_buff)
+                full_table = true;
+        else
+                full_table = false;
+
+        /* In this version, fragmentation is not implemented, then
+         * I'll send only one packet with as much TT entries as I can */
+        if (!full_table) {
+                spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
+                tt_len = req_dst_orig_node->tt_buff_len;
+                tt_tot = tt_len / sizeof(struct tt_change);
+
+                skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
+                                    tt_len + ETH_HLEN);
+                if (!skb)
+                        goto unlock;
+
+                skb_reserve(skb, ETH_HLEN);
+                tt_response = (struct tt_query_packet *)skb_put(skb,
+                                sizeof(struct tt_query_packet) + tt_len);
+                tt_response->ttvn = req_ttvn;
+                tt_response->tt_data = htons(tt_tot);
+
+                tt_buff = skb->data + sizeof(struct tt_query_packet);
+                /* Copy the last orig_node's OGM buffer */
+                memcpy(tt_buff, req_dst_orig_node->tt_buff,
+                       req_dst_orig_node->tt_buff_len);
+
+                spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
+        } else {
+                tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) *
+                                                sizeof(struct tt_change);
+                ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
+
+                skb = tt_response_fill_table(tt_len, ttvn,
+                                             bat_priv->tt_global_hash,
+                                             primary_if, tt_global_valid_entry,
+                                             req_dst_orig_node);
+                if (!skb)
+                        goto out;
+
+                tt_response = (struct tt_query_packet *)skb->data;
+        }
+
+        tt_response->packet_type = BAT_TT_QUERY;
+        tt_response->version = COMPAT_VERSION;
+        tt_response->ttl = TTL;
+        memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN);
+        memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
+        tt_response->flags = TT_RESPONSE;
+
+        if (full_table)
+                tt_response->flags |= TT_FULL_TABLE;
+
+        bat_dbg(DBG_TT, bat_priv,
+                "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
+                res_dst_orig_node->orig, neigh_node->addr,
+                req_dst_orig_node->orig, req_ttvn);
+
+        send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
+        ret = true;
+        goto out;
+
+unlock:
+        spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
+
+out:
+        if (res_dst_orig_node)
+                orig_node_free_ref(res_dst_orig_node);
+        if (req_dst_orig_node)
+                orig_node_free_ref(req_dst_orig_node);
+        if (neigh_node)
+                neigh_node_free_ref(neigh_node);
+        if (primary_if)
+                hardif_free_ref(primary_if);
+        if (!ret)
+                kfree_skb(skb);
+        return ret;
+
+}
+static bool send_my_tt_response(struct bat_priv *bat_priv,
+                                struct tt_query_packet *tt_request)
+{
+        struct orig_node *orig_node = NULL;
+        struct neigh_node *neigh_node = NULL;
+        struct hard_iface *primary_if = NULL;
+        uint8_t my_ttvn, req_ttvn, ttvn;
+        int ret = false;
+        unsigned char *tt_buff;
+        bool full_table;
+        uint16_t tt_len, tt_tot;
+        struct sk_buff *skb = NULL;
+        struct tt_query_packet *tt_response;
+
+        bat_dbg(DBG_TT, bat_priv,
+                "Received TT_REQUEST from %pM for "
+                "ttvn: %u (me) [%c]\n", tt_request->src,
+                tt_request->ttvn,
+                (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
+
+
+        my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
+        req_ttvn = tt_request->ttvn;
+
+        orig_node = get_orig_node(bat_priv, tt_request->src);
+        if (!orig_node)
+                goto out;
+
+        neigh_node = orig_node_get_router(orig_node);
+        if (!neigh_node)
+                goto out;
+
+        primary_if = primary_if_get_selected(bat_priv);
+        if (!primary_if)
+                goto out;
+
+        /* If the full table has been explicitly requested or the gap
+         * is too big send the whole local translation table */
+        if (tt_request->flags & TT_FULL_TABLE || my_ttvn != req_ttvn ||
+            !bat_priv->tt_buff)
+                full_table = true;
+        else
+                full_table = false;
+
+        /* In this version, fragmentation is not implemented, then
+         * I'll send only one packet with as much TT entries as I can */
+        if (!full_table) {
+                spin_lock_bh(&bat_priv->tt_buff_lock);
+                tt_len = bat_priv->tt_buff_len;
+                tt_tot = tt_len / sizeof(struct tt_change);
+
+                skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
+                                    tt_len + ETH_HLEN);
+                if (!skb)
+                        goto unlock;
+
+                skb_reserve(skb, ETH_HLEN);
+                tt_response = (struct tt_query_packet *)skb_put(skb,
+                                sizeof(struct tt_query_packet) + tt_len);
+                tt_response->ttvn = req_ttvn;
+                tt_response->tt_data = htons(tt_tot);
+
+                tt_buff = skb->data + sizeof(struct tt_query_packet);
+                memcpy(tt_buff, bat_priv->tt_buff,
+                       bat_priv->tt_buff_len);
+                spin_unlock_bh(&bat_priv->tt_buff_lock);
+        } else {
+                tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) *
+                                                sizeof(struct tt_change);
+                ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
+
+                skb = tt_response_fill_table(tt_len, ttvn,
+                                             bat_priv->tt_local_hash,
+                                             primary_if, NULL, NULL);
+                if (!skb)
+                        goto out;
+
+                tt_response = (struct tt_query_packet *)skb->data;
+        }
+
+        tt_response->packet_type = BAT_TT_QUERY;
+        tt_response->version = COMPAT_VERSION;
+        tt_response->ttl = TTL;
+        memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN);
+        memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
+        tt_response->flags = TT_RESPONSE;
+
+        if (full_table)
+                tt_response->flags |= TT_FULL_TABLE;
+
+        bat_dbg(DBG_TT, bat_priv,
+                "Sending TT_RESPONSE to %pM via %pM [%c]\n",
+                orig_node->orig, neigh_node->addr,
+                (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
+
+        send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
+        ret = true;
+        goto out;
+
+unlock:
+        spin_unlock_bh(&bat_priv->tt_buff_lock);
+out:
+        if (orig_node)
+                orig_node_free_ref(orig_node);
+        if (neigh_node)
+                neigh_node_free_ref(neigh_node);
+        if (primary_if)
+                hardif_free_ref(primary_if);
+        if (!ret)
+                kfree_skb(skb);
+        /* This packet was for me, so it doesn't need to be re-routed */
+        return true;
+}
+
+bool send_tt_response(struct bat_priv *bat_priv,
+                      struct tt_query_packet *tt_request)
+{
+        if (is_my_mac(tt_request->dst))
+                return send_my_tt_response(bat_priv, tt_request);
+        else
+                return send_other_tt_response(bat_priv, tt_request);
+}
+
+static void _tt_update_changes(struct bat_priv *bat_priv,
+                               struct orig_node *orig_node,
+                               struct tt_change *tt_change,
+                               uint16_t tt_num_changes, uint8_t ttvn)
+{
+        int i;
+
+        for (i = 0; i < tt_num_changes; i++) {
+                if ((tt_change + i)->flags & TT_CHANGE_DEL)
+                        tt_global_del(bat_priv, orig_node,
+                                      (tt_change + i)->addr,
+                                      "tt removed by changes");
+                else
+                        if (!tt_global_add(bat_priv, orig_node,
+                                           (tt_change + i)->addr, ttvn))
+                                /* In case of problem while storing a
+                                 * global_entry, we stop the updating
+                                 * procedure without committing the
+                                 * ttvn change. This will avoid to send
+                                 * corrupted data on tt_request
+                                 */
+                                return;
+        }
+}
+
+static void tt_fill_gtable(struct bat_priv *bat_priv,
+                           struct tt_query_packet *tt_response)
+{
+        struct orig_node *orig_node = NULL;
+
+        orig_node = orig_hash_find(bat_priv, tt_response->src);
+        if (!orig_node)
+                goto out;
+
+        /* Purge the old table first.. */
+        tt_global_del_orig(bat_priv, orig_node, "Received full table");
+
+        _tt_update_changes(bat_priv, orig_node,
+                           (struct tt_change *)(tt_response + 1),
+                           tt_response->tt_data, tt_response->ttvn);
+
+        spin_lock_bh(&orig_node->tt_buff_lock);
+        kfree(orig_node->tt_buff);
+        orig_node->tt_buff_len = 0;
+        orig_node->tt_buff = NULL;
+        spin_unlock_bh(&orig_node->tt_buff_lock);
+
+        atomic_set(&orig_node->last_ttvn, tt_response->ttvn);
+
+out:
+        if (orig_node)
+                orig_node_free_ref(orig_node);
+}
+
+void tt_update_changes(struct bat_priv *bat_priv, struct orig_node *orig_node,
+                       uint16_t tt_num_changes, uint8_t ttvn,
+                       struct tt_change *tt_change)
+{
+        _tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes,
+                           ttvn);
+
+        tt_save_orig_buffer(bat_priv, orig_node, (unsigned char *)tt_change,
+                            tt_num_changes);
+        atomic_set(&orig_node->last_ttvn, ttvn);
+}
+
+bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr)
+{
+        struct tt_local_entry *tt_local_entry;
+
+        spin_lock_bh(&bat_priv->tt_lhash_lock);
+        tt_local_entry = tt_local_hash_find(bat_priv, addr);
+        spin_unlock_bh(&bat_priv->tt_lhash_lock);
+
+        if (tt_local_entry)
+                return true;
+        return false;
+}
+
+void handle_tt_response(struct bat_priv *bat_priv,
+                        struct tt_query_packet *tt_response)
+{
+        struct tt_req_node *node, *safe;
+        struct orig_node *orig_node = NULL;
+
+        bat_dbg(DBG_TT, bat_priv, "Received TT_RESPONSE from %pM for "
+                "ttvn %d t_size: %d [%c]\n",
+                tt_response->src, tt_response->ttvn,
+                tt_response->tt_data,
+                (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
+
+        orig_node = orig_hash_find(bat_priv, tt_response->src);
+        if (!orig_node)
+                goto out;
+
+        if (tt_response->flags & TT_FULL_TABLE)
+                tt_fill_gtable(bat_priv, tt_response);
+        else
+                tt_update_changes(bat_priv, orig_node, tt_response->tt_data,
+                                  tt_response->ttvn,
+                                  (struct tt_change *)(tt_response + 1));
+
+        /* Delete the tt_req_node from pending tt_requests list */
+        spin_lock_bh(&bat_priv->tt_req_list_lock);
+        list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
+                if (!compare_eth(node->addr, tt_response->src))
+                        continue;
+                list_del(&node->list);
+                kfree(node);
+        }
+        spin_unlock_bh(&bat_priv->tt_req_list_lock);
+
+        /* Recalculate the CRC for this orig_node and store it */
+        spin_lock_bh(&bat_priv->tt_ghash_lock);
+        orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
+        spin_unlock_bh(&bat_priv->tt_ghash_lock);
+out:
+        if (orig_node)
+                orig_node_free_ref(orig_node);
+}
+
+int tt_init(struct bat_priv *bat_priv)
+{
+        if (!tt_local_init(bat_priv))
+                return 0;
+
+        if (!tt_global_init(bat_priv))
+                return 0;
+
+        tt_start_timer(bat_priv);
+
+        return 1;
+}
+
+void tt_free(struct bat_priv *bat_priv)
+{
+        cancel_delayed_work_sync(&bat_priv->tt_work);
+
+        tt_local_table_free(bat_priv);
+        tt_global_table_free(bat_priv);
+        tt_req_list_free(bat_priv);
+        tt_changes_list_free(bat_priv);
+
+        kfree(bat_priv->tt_buff);
+}
+
+static void tt_purge(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, tt_work);
+
+        tt_local_purge(bat_priv);
+        tt_req_purge(bat_priv);
+
+        tt_start_timer(bat_priv);
+}