batman-adv: add sanity check when removing global tts
[linux-2.6.git] / net / batman-adv / translation-table.c
1 /*
2  * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
3  *
4  * Marek Lindner, Simon Wunderlich
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of version 2 of the GNU General Public
8  * License as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18  * 02110-1301, USA
19  *
20  */
21
22 #include "main.h"
23 #include "translation-table.h"
24 #include "soft-interface.h"
25 #include "hard-interface.h"
26 #include "send.h"
27 #include "hash.h"
28 #include "originator.h"
29 #include "routing.h"
30
31 #include <linux/crc16.h>
32
33 static void _tt_global_del(struct bat_priv *bat_priv,
34                            struct tt_global_entry *tt_global_entry,
35                            const char *message);
36 static void tt_purge(struct work_struct *work);
37
38 /* returns 1 if they are the same mac addr */
39 static int compare_ltt(const struct hlist_node *node, const void *data2)
40 {
41         const void *data1 = container_of(node, struct tt_local_entry,
42                                          hash_entry);
43
44         return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
45 }
46
47 /* returns 1 if they are the same mac addr */
48 static int compare_gtt(const struct hlist_node *node, const void *data2)
49 {
50         const void *data1 = container_of(node, struct tt_global_entry,
51                                          hash_entry);
52
53         return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
54 }
55
56 static void tt_start_timer(struct bat_priv *bat_priv)
57 {
58         INIT_DELAYED_WORK(&bat_priv->tt_work, tt_purge);
59         queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work,
60                            msecs_to_jiffies(5000));
61 }
62
63 static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
64                                                  const void *data)
65 {
66         struct hashtable_t *hash = bat_priv->tt_local_hash;
67         struct hlist_head *head;
68         struct hlist_node *node;
69         struct tt_local_entry *tt_local_entry, *tt_local_entry_tmp = NULL;
70         int index;
71
72         if (!hash)
73                 return NULL;
74
75         index = choose_orig(data, hash->size);
76         head = &hash->table[index];
77
78         rcu_read_lock();
79         hlist_for_each_entry_rcu(tt_local_entry, node, head, hash_entry) {
80                 if (!compare_eth(tt_local_entry, data))
81                         continue;
82
83                 if (!atomic_inc_not_zero(&tt_local_entry->refcount))
84                         continue;
85
86                 tt_local_entry_tmp = tt_local_entry;
87                 break;
88         }
89         rcu_read_unlock();
90
91         return tt_local_entry_tmp;
92 }
93
94 static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
95                                                    const void *data)
96 {
97         struct hashtable_t *hash = bat_priv->tt_global_hash;
98         struct hlist_head *head;
99         struct hlist_node *node;
100         struct tt_global_entry *tt_global_entry;
101         struct tt_global_entry *tt_global_entry_tmp = NULL;
102         int index;
103
104         if (!hash)
105                 return NULL;
106
107         index = choose_orig(data, hash->size);
108         head = &hash->table[index];
109
110         rcu_read_lock();
111         hlist_for_each_entry_rcu(tt_global_entry, node, head, hash_entry) {
112                 if (!compare_eth(tt_global_entry, data))
113                         continue;
114
115                 if (!atomic_inc_not_zero(&tt_global_entry->refcount))
116                         continue;
117
118                 tt_global_entry_tmp = tt_global_entry;
119                 break;
120         }
121         rcu_read_unlock();
122
123         return tt_global_entry_tmp;
124 }
125
126 static bool is_out_of_time(unsigned long starting_time, unsigned long timeout)
127 {
128         unsigned long deadline;
129         deadline = starting_time + msecs_to_jiffies(timeout);
130
131         return time_after(jiffies, deadline);
132 }
133
134 static void tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry)
135 {
136         if (atomic_dec_and_test(&tt_local_entry->refcount))
137                 kfree_rcu(tt_local_entry, rcu);
138 }
139
140 static void tt_global_entry_free_rcu(struct rcu_head *rcu)
141 {
142         struct tt_global_entry *tt_global_entry;
143
144         tt_global_entry = container_of(rcu, struct tt_global_entry, rcu);
145
146         if (tt_global_entry->orig_node)
147                 orig_node_free_ref(tt_global_entry->orig_node);
148
149         kfree(tt_global_entry);
150 }
151
152 static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry)
153 {
154         if (atomic_dec_and_test(&tt_global_entry->refcount))
155                 call_rcu(&tt_global_entry->rcu, tt_global_entry_free_rcu);
156 }
157
158 static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr,
159                            uint8_t flags)
160 {
161         struct tt_change_node *tt_change_node;
162
163         tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
164
165         if (!tt_change_node)
166                 return;
167
168         tt_change_node->change.flags = flags;
169         memcpy(tt_change_node->change.addr, addr, ETH_ALEN);
170
171         spin_lock_bh(&bat_priv->tt_changes_list_lock);
172         /* track the change in the OGMinterval list */
173         list_add_tail(&tt_change_node->list, &bat_priv->tt_changes_list);
174         atomic_inc(&bat_priv->tt_local_changes);
175         spin_unlock_bh(&bat_priv->tt_changes_list_lock);
176
177         atomic_set(&bat_priv->tt_ogm_append_cnt, 0);
178 }
179
180 int tt_len(int changes_num)
181 {
182         return changes_num * sizeof(struct tt_change);
183 }
184
185 static int tt_local_init(struct bat_priv *bat_priv)
186 {
187         if (bat_priv->tt_local_hash)
188                 return 1;
189
190         bat_priv->tt_local_hash = hash_new(1024);
191
192         if (!bat_priv->tt_local_hash)
193                 return 0;
194
195         return 1;
196 }
197
198 void tt_local_add(struct net_device *soft_iface, const uint8_t *addr)
199 {
200         struct bat_priv *bat_priv = netdev_priv(soft_iface);
201         struct tt_local_entry *tt_local_entry = NULL;
202         struct tt_global_entry *tt_global_entry = NULL;
203
204         tt_local_entry = tt_local_hash_find(bat_priv, addr);
205
206         if (tt_local_entry) {
207                 tt_local_entry->last_seen = jiffies;
208                 goto out;
209         }
210
211         tt_local_entry = kmalloc(sizeof(*tt_local_entry), GFP_ATOMIC);
212         if (!tt_local_entry)
213                 goto out;
214
215         bat_dbg(DBG_TT, bat_priv,
216                 "Creating new local tt entry: %pM (ttvn: %d)\n", addr,
217                 (uint8_t)atomic_read(&bat_priv->ttvn));
218
219         memcpy(tt_local_entry->addr, addr, ETH_ALEN);
220         tt_local_entry->last_seen = jiffies;
221         tt_local_entry->flags = NO_FLAGS;
222         atomic_set(&tt_local_entry->refcount, 2);
223
224         /* the batman interface mac address should never be purged */
225         if (compare_eth(addr, soft_iface->dev_addr))
226                 tt_local_entry->flags |= TT_CLIENT_NOPURGE;
227
228         tt_local_event(bat_priv, addr, tt_local_entry->flags);
229
230         /* The local entry has to be marked as NEW to avoid to send it in
231          * a full table response going out before the next ttvn increment
232          * (consistency check) */
233         tt_local_entry->flags |= TT_CLIENT_NEW;
234
235         hash_add(bat_priv->tt_local_hash, compare_ltt, choose_orig,
236                  tt_local_entry, &tt_local_entry->hash_entry);
237
238         /* remove address from global hash if present */
239         tt_global_entry = tt_global_hash_find(bat_priv, addr);
240
241         /* Check whether it is a roaming! */
242         if (tt_global_entry) {
243                 /* This node is probably going to update its tt table */
244                 tt_global_entry->orig_node->tt_poss_change = true;
245                 /* The global entry has to be marked as PENDING and has to be
246                  * kept for consistency purpose */
247                 tt_global_entry->flags |= TT_CLIENT_PENDING;
248                 send_roam_adv(bat_priv, tt_global_entry->addr,
249                               tt_global_entry->orig_node);
250         }
251 out:
252         if (tt_local_entry)
253                 tt_local_entry_free_ref(tt_local_entry);
254         if (tt_global_entry)
255                 tt_global_entry_free_ref(tt_global_entry);
256 }
257
258 int tt_changes_fill_buffer(struct bat_priv *bat_priv,
259                            unsigned char *buff, int buff_len)
260 {
261         int count = 0, tot_changes = 0;
262         struct tt_change_node *entry, *safe;
263
264         if (buff_len > 0)
265                 tot_changes = buff_len / tt_len(1);
266
267         spin_lock_bh(&bat_priv->tt_changes_list_lock);
268         atomic_set(&bat_priv->tt_local_changes, 0);
269
270         list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
271                         list) {
272                 if (count < tot_changes) {
273                         memcpy(buff + tt_len(count),
274                                &entry->change, sizeof(struct tt_change));
275                         count++;
276                 }
277                 list_del(&entry->list);
278                 kfree(entry);
279         }
280         spin_unlock_bh(&bat_priv->tt_changes_list_lock);
281
282         /* Keep the buffer for possible tt_request */
283         spin_lock_bh(&bat_priv->tt_buff_lock);
284         kfree(bat_priv->tt_buff);
285         bat_priv->tt_buff_len = 0;
286         bat_priv->tt_buff = NULL;
287         /* We check whether this new OGM has no changes due to size
288          * problems */
289         if (buff_len > 0) {
290                 /**
291                  * if kmalloc() fails we will reply with the full table
292                  * instead of providing the diff
293                  */
294                 bat_priv->tt_buff = kmalloc(buff_len, GFP_ATOMIC);
295                 if (bat_priv->tt_buff) {
296                         memcpy(bat_priv->tt_buff, buff, buff_len);
297                         bat_priv->tt_buff_len = buff_len;
298                 }
299         }
300         spin_unlock_bh(&bat_priv->tt_buff_lock);
301
302         return tot_changes;
303 }
304
305 int tt_local_seq_print_text(struct seq_file *seq, void *offset)
306 {
307         struct net_device *net_dev = (struct net_device *)seq->private;
308         struct bat_priv *bat_priv = netdev_priv(net_dev);
309         struct hashtable_t *hash = bat_priv->tt_local_hash;
310         struct tt_local_entry *tt_local_entry;
311         struct hard_iface *primary_if;
312         struct hlist_node *node;
313         struct hlist_head *head;
314         size_t buf_size, pos;
315         char *buff;
316         int i, ret = 0;
317
318         primary_if = primary_if_get_selected(bat_priv);
319         if (!primary_if) {
320                 ret = seq_printf(seq, "BATMAN mesh %s disabled - "
321                                  "please specify interfaces to enable it\n",
322                                  net_dev->name);
323                 goto out;
324         }
325
326         if (primary_if->if_status != IF_ACTIVE) {
327                 ret = seq_printf(seq, "BATMAN mesh %s disabled - "
328                                  "primary interface not active\n",
329                                  net_dev->name);
330                 goto out;
331         }
332
333         seq_printf(seq, "Locally retrieved addresses (from %s) "
334                    "announced via TT (TTVN: %u):\n",
335                    net_dev->name, (uint8_t)atomic_read(&bat_priv->ttvn));
336
337         buf_size = 1;
338         /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
339         for (i = 0; i < hash->size; i++) {
340                 head = &hash->table[i];
341
342                 rcu_read_lock();
343                 __hlist_for_each_rcu(node, head)
344                         buf_size += 21;
345                 rcu_read_unlock();
346         }
347
348         buff = kmalloc(buf_size, GFP_ATOMIC);
349         if (!buff) {
350                 ret = -ENOMEM;
351                 goto out;
352         }
353
354         buff[0] = '\0';
355         pos = 0;
356
357         for (i = 0; i < hash->size; i++) {
358                 head = &hash->table[i];
359
360                 rcu_read_lock();
361                 hlist_for_each_entry_rcu(tt_local_entry, node,
362                                          head, hash_entry) {
363                         pos += snprintf(buff + pos, 22, " * %pM\n",
364                                         tt_local_entry->addr);
365                 }
366                 rcu_read_unlock();
367         }
368
369         seq_printf(seq, "%s", buff);
370         kfree(buff);
371 out:
372         if (primary_if)
373                 hardif_free_ref(primary_if);
374         return ret;
375 }
376
377 static void tt_local_set_pending(struct bat_priv *bat_priv,
378                                  struct tt_local_entry *tt_local_entry,
379                                  uint16_t flags)
380 {
381         tt_local_event(bat_priv, tt_local_entry->addr,
382                        tt_local_entry->flags | flags);
383
384         /* The local client has to be merked as "pending to be removed" but has
385          * to be kept in the table in order to send it in an full tables
386          * response issued before the net ttvn increment (consistency check) */
387         tt_local_entry->flags |= TT_CLIENT_PENDING;
388 }
389
390 void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
391                      const char *message, bool roaming)
392 {
393         struct tt_local_entry *tt_local_entry = NULL;
394
395         tt_local_entry = tt_local_hash_find(bat_priv, addr);
396         if (!tt_local_entry)
397                 goto out;
398
399         tt_local_set_pending(bat_priv, tt_local_entry, TT_CLIENT_DEL |
400                              (roaming ? TT_CLIENT_ROAM : NO_FLAGS));
401
402         bat_dbg(DBG_TT, bat_priv, "Local tt entry (%pM) pending to be removed: "
403                 "%s\n", tt_local_entry->addr, message);
404 out:
405         if (tt_local_entry)
406                 tt_local_entry_free_ref(tt_local_entry);
407 }
408
409 static void tt_local_purge(struct bat_priv *bat_priv)
410 {
411         struct hashtable_t *hash = bat_priv->tt_local_hash;
412         struct tt_local_entry *tt_local_entry;
413         struct hlist_node *node, *node_tmp;
414         struct hlist_head *head;
415         spinlock_t *list_lock; /* protects write access to the hash lists */
416         int i;
417
418         for (i = 0; i < hash->size; i++) {
419                 head = &hash->table[i];
420                 list_lock = &hash->list_locks[i];
421
422                 spin_lock_bh(list_lock);
423                 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
424                                           head, hash_entry) {
425                         if (tt_local_entry->flags & TT_CLIENT_NOPURGE)
426                                 continue;
427
428                         /* entry already marked for deletion */
429                         if (tt_local_entry->flags & TT_CLIENT_PENDING)
430                                 continue;
431
432                         if (!is_out_of_time(tt_local_entry->last_seen,
433                                             TT_LOCAL_TIMEOUT * 1000))
434                                 continue;
435
436                         tt_local_set_pending(bat_priv, tt_local_entry,
437                                              TT_CLIENT_DEL);
438                         bat_dbg(DBG_TT, bat_priv, "Local tt entry (%pM) "
439                                 "pending to be removed: timed out\n",
440                                 tt_local_entry->addr);
441                 }
442                 spin_unlock_bh(list_lock);
443         }
444
445 }
446
447 static void tt_local_table_free(struct bat_priv *bat_priv)
448 {
449         struct hashtable_t *hash;
450         spinlock_t *list_lock; /* protects write access to the hash lists */
451         struct tt_local_entry *tt_local_entry;
452         struct hlist_node *node, *node_tmp;
453         struct hlist_head *head;
454         int i;
455
456         if (!bat_priv->tt_local_hash)
457                 return;
458
459         hash = bat_priv->tt_local_hash;
460
461         for (i = 0; i < hash->size; i++) {
462                 head = &hash->table[i];
463                 list_lock = &hash->list_locks[i];
464
465                 spin_lock_bh(list_lock);
466                 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
467                                           head, hash_entry) {
468                         hlist_del_rcu(node);
469                         tt_local_entry_free_ref(tt_local_entry);
470                 }
471                 spin_unlock_bh(list_lock);
472         }
473
474         hash_destroy(hash);
475
476         bat_priv->tt_local_hash = NULL;
477 }
478
479 static int tt_global_init(struct bat_priv *bat_priv)
480 {
481         if (bat_priv->tt_global_hash)
482                 return 1;
483
484         bat_priv->tt_global_hash = hash_new(1024);
485
486         if (!bat_priv->tt_global_hash)
487                 return 0;
488
489         return 1;
490 }
491
492 static void tt_changes_list_free(struct bat_priv *bat_priv)
493 {
494         struct tt_change_node *entry, *safe;
495
496         spin_lock_bh(&bat_priv->tt_changes_list_lock);
497
498         list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
499                                  list) {
500                 list_del(&entry->list);
501                 kfree(entry);
502         }
503
504         atomic_set(&bat_priv->tt_local_changes, 0);
505         spin_unlock_bh(&bat_priv->tt_changes_list_lock);
506 }
507
508 /* caller must hold orig_node refcount */
509 int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
510                   const unsigned char *tt_addr, uint8_t ttvn, bool roaming)
511 {
512         struct tt_global_entry *tt_global_entry;
513         struct orig_node *orig_node_tmp;
514         int ret = 0;
515
516         tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
517
518         if (!tt_global_entry) {
519                 tt_global_entry =
520                         kmalloc(sizeof(*tt_global_entry),
521                                 GFP_ATOMIC);
522                 if (!tt_global_entry)
523                         goto out;
524
525                 memcpy(tt_global_entry->addr, tt_addr, ETH_ALEN);
526                 /* Assign the new orig_node */
527                 atomic_inc(&orig_node->refcount);
528                 tt_global_entry->orig_node = orig_node;
529                 tt_global_entry->ttvn = ttvn;
530                 tt_global_entry->flags = NO_FLAGS;
531                 tt_global_entry->roam_at = 0;
532                 atomic_set(&tt_global_entry->refcount, 2);
533
534                 hash_add(bat_priv->tt_global_hash, compare_gtt,
535                          choose_orig, tt_global_entry,
536                          &tt_global_entry->hash_entry);
537                 atomic_inc(&orig_node->tt_size);
538         } else {
539                 if (tt_global_entry->orig_node != orig_node) {
540                         atomic_dec(&tt_global_entry->orig_node->tt_size);
541                         orig_node_tmp = tt_global_entry->orig_node;
542                         atomic_inc(&orig_node->refcount);
543                         tt_global_entry->orig_node = orig_node;
544                         orig_node_free_ref(orig_node_tmp);
545                         atomic_inc(&orig_node->tt_size);
546                 }
547                 tt_global_entry->ttvn = ttvn;
548                 tt_global_entry->flags = NO_FLAGS;
549                 tt_global_entry->roam_at = 0;
550         }
551
552         bat_dbg(DBG_TT, bat_priv,
553                 "Creating new global tt entry: %pM (via %pM)\n",
554                 tt_global_entry->addr, orig_node->orig);
555
556         /* remove address from local hash if present */
557         tt_local_remove(bat_priv, tt_global_entry->addr,
558                         "global tt received", roaming);
559         ret = 1;
560 out:
561         if (tt_global_entry)
562                 tt_global_entry_free_ref(tt_global_entry);
563         return ret;
564 }
565
566 int tt_global_seq_print_text(struct seq_file *seq, void *offset)
567 {
568         struct net_device *net_dev = (struct net_device *)seq->private;
569         struct bat_priv *bat_priv = netdev_priv(net_dev);
570         struct hashtable_t *hash = bat_priv->tt_global_hash;
571         struct tt_global_entry *tt_global_entry;
572         struct hard_iface *primary_if;
573         struct hlist_node *node;
574         struct hlist_head *head;
575         size_t buf_size, pos;
576         char *buff;
577         int i, ret = 0;
578
579         primary_if = primary_if_get_selected(bat_priv);
580         if (!primary_if) {
581                 ret = seq_printf(seq, "BATMAN mesh %s disabled - please "
582                                  "specify interfaces to enable it\n",
583                                  net_dev->name);
584                 goto out;
585         }
586
587         if (primary_if->if_status != IF_ACTIVE) {
588                 ret = seq_printf(seq, "BATMAN mesh %s disabled - "
589                                  "primary interface not active\n",
590                                  net_dev->name);
591                 goto out;
592         }
593
594         seq_printf(seq,
595                    "Globally announced TT entries received via the mesh %s\n",
596                    net_dev->name);
597         seq_printf(seq, "       %-13s %s       %-15s %s\n",
598                    "Client", "(TTVN)", "Originator", "(Curr TTVN)");
599
600         buf_size = 1;
601         /* Estimate length for: " * xx:xx:xx:xx:xx:xx (ttvn) via
602          * xx:xx:xx:xx:xx:xx (cur_ttvn)\n"*/
603         for (i = 0; i < hash->size; i++) {
604                 head = &hash->table[i];
605
606                 rcu_read_lock();
607                 __hlist_for_each_rcu(node, head)
608                         buf_size += 59;
609                 rcu_read_unlock();
610         }
611
612         buff = kmalloc(buf_size, GFP_ATOMIC);
613         if (!buff) {
614                 ret = -ENOMEM;
615                 goto out;
616         }
617
618         buff[0] = '\0';
619         pos = 0;
620
621         for (i = 0; i < hash->size; i++) {
622                 head = &hash->table[i];
623
624                 rcu_read_lock();
625                 hlist_for_each_entry_rcu(tt_global_entry, node,
626                                          head, hash_entry) {
627                         pos += snprintf(buff + pos, 61,
628                                         " * %pM  (%3u) via %pM     (%3u)\n",
629                                         tt_global_entry->addr,
630                                         tt_global_entry->ttvn,
631                                         tt_global_entry->orig_node->orig,
632                                         (uint8_t) atomic_read(
633                                                 &tt_global_entry->orig_node->
634                                                 last_ttvn));
635                 }
636                 rcu_read_unlock();
637         }
638
639         seq_printf(seq, "%s", buff);
640         kfree(buff);
641 out:
642         if (primary_if)
643                 hardif_free_ref(primary_if);
644         return ret;
645 }
646
647 static void _tt_global_del(struct bat_priv *bat_priv,
648                            struct tt_global_entry *tt_global_entry,
649                            const char *message)
650 {
651         if (!tt_global_entry)
652                 goto out;
653
654         bat_dbg(DBG_TT, bat_priv,
655                 "Deleting global tt entry %pM (via %pM): %s\n",
656                 tt_global_entry->addr, tt_global_entry->orig_node->orig,
657                 message);
658
659         atomic_dec(&tt_global_entry->orig_node->tt_size);
660
661         hash_remove(bat_priv->tt_global_hash, compare_gtt, choose_orig,
662                     tt_global_entry->addr);
663 out:
664         if (tt_global_entry)
665                 tt_global_entry_free_ref(tt_global_entry);
666 }
667
668 void tt_global_del(struct bat_priv *bat_priv,
669                    struct orig_node *orig_node, const unsigned char *addr,
670                    const char *message, bool roaming)
671 {
672         struct tt_global_entry *tt_global_entry = NULL;
673
674         tt_global_entry = tt_global_hash_find(bat_priv, addr);
675         if (!tt_global_entry)
676                 goto out;
677
678         if (tt_global_entry->orig_node == orig_node) {
679                 if (roaming) {
680                         tt_global_entry->flags |= TT_CLIENT_ROAM;
681                         tt_global_entry->roam_at = jiffies;
682                         goto out;
683                 }
684                 _tt_global_del(bat_priv, tt_global_entry, message);
685         }
686 out:
687         if (tt_global_entry)
688                 tt_global_entry_free_ref(tt_global_entry);
689 }
690
691 void tt_global_del_orig(struct bat_priv *bat_priv,
692                         struct orig_node *orig_node, const char *message)
693 {
694         struct tt_global_entry *tt_global_entry;
695         int i;
696         struct hashtable_t *hash = bat_priv->tt_global_hash;
697         struct hlist_node *node, *safe;
698         struct hlist_head *head;
699         spinlock_t *list_lock; /* protects write access to the hash lists */
700
701         if (!hash)
702                 return;
703
704         for (i = 0; i < hash->size; i++) {
705                 head = &hash->table[i];
706                 list_lock = &hash->list_locks[i];
707
708                 spin_lock_bh(list_lock);
709                 hlist_for_each_entry_safe(tt_global_entry, node, safe,
710                                          head, hash_entry) {
711                         if (tt_global_entry->orig_node == orig_node) {
712                                 bat_dbg(DBG_TT, bat_priv,
713                                         "Deleting global tt entry %pM "
714                                         "(via %pM): originator time out\n",
715                                         tt_global_entry->addr,
716                                         tt_global_entry->orig_node->orig);
717                                 hlist_del_rcu(node);
718                                 tt_global_entry_free_ref(tt_global_entry);
719                         }
720                 }
721                 spin_unlock_bh(list_lock);
722         }
723         atomic_set(&orig_node->tt_size, 0);
724 }
725
726 static void tt_global_roam_purge(struct bat_priv *bat_priv)
727 {
728         struct hashtable_t *hash = bat_priv->tt_global_hash;
729         struct tt_global_entry *tt_global_entry;
730         struct hlist_node *node, *node_tmp;
731         struct hlist_head *head;
732         spinlock_t *list_lock; /* protects write access to the hash lists */
733         int i;
734
735         for (i = 0; i < hash->size; i++) {
736                 head = &hash->table[i];
737                 list_lock = &hash->list_locks[i];
738
739                 spin_lock_bh(list_lock);
740                 hlist_for_each_entry_safe(tt_global_entry, node, node_tmp,
741                                           head, hash_entry) {
742                         if (!(tt_global_entry->flags & TT_CLIENT_ROAM))
743                                 continue;
744                         if (!is_out_of_time(tt_global_entry->roam_at,
745                                             TT_CLIENT_ROAM_TIMEOUT * 1000))
746                                 continue;
747
748                         bat_dbg(DBG_TT, bat_priv, "Deleting global "
749                                 "tt entry (%pM): Roaming timeout\n",
750                                 tt_global_entry->addr);
751                         atomic_dec(&tt_global_entry->orig_node->tt_size);
752                         hlist_del_rcu(node);
753                         tt_global_entry_free_ref(tt_global_entry);
754                 }
755                 spin_unlock_bh(list_lock);
756         }
757
758 }
759
760 static void tt_global_table_free(struct bat_priv *bat_priv)
761 {
762         struct hashtable_t *hash;
763         spinlock_t *list_lock; /* protects write access to the hash lists */
764         struct tt_global_entry *tt_global_entry;
765         struct hlist_node *node, *node_tmp;
766         struct hlist_head *head;
767         int i;
768
769         if (!bat_priv->tt_global_hash)
770                 return;
771
772         hash = bat_priv->tt_global_hash;
773
774         for (i = 0; i < hash->size; i++) {
775                 head = &hash->table[i];
776                 list_lock = &hash->list_locks[i];
777
778                 spin_lock_bh(list_lock);
779                 hlist_for_each_entry_safe(tt_global_entry, node, node_tmp,
780                                           head, hash_entry) {
781                         hlist_del_rcu(node);
782                         tt_global_entry_free_ref(tt_global_entry);
783                 }
784                 spin_unlock_bh(list_lock);
785         }
786
787         hash_destroy(hash);
788
789         bat_priv->tt_global_hash = NULL;
790 }
791
792 struct orig_node *transtable_search(struct bat_priv *bat_priv,
793                                     const uint8_t *addr)
794 {
795         struct tt_global_entry *tt_global_entry;
796         struct orig_node *orig_node = NULL;
797
798         tt_global_entry = tt_global_hash_find(bat_priv, addr);
799
800         if (!tt_global_entry)
801                 goto out;
802
803         if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount))
804                 goto free_tt;
805
806         /* A global client marked as PENDING has already moved from that
807          * originator */
808         if (tt_global_entry->flags & TT_CLIENT_PENDING)
809                 goto free_tt;
810
811         orig_node = tt_global_entry->orig_node;
812
813 free_tt:
814         tt_global_entry_free_ref(tt_global_entry);
815 out:
816         return orig_node;
817 }
818
819 /* Calculates the checksum of the local table of a given orig_node */
820 uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node)
821 {
822         uint16_t total = 0, total_one;
823         struct hashtable_t *hash = bat_priv->tt_global_hash;
824         struct tt_global_entry *tt_global_entry;
825         struct hlist_node *node;
826         struct hlist_head *head;
827         int i, j;
828
829         for (i = 0; i < hash->size; i++) {
830                 head = &hash->table[i];
831
832                 rcu_read_lock();
833                 hlist_for_each_entry_rcu(tt_global_entry, node,
834                                          head, hash_entry) {
835                         if (compare_eth(tt_global_entry->orig_node,
836                                         orig_node)) {
837                                 /* Roaming clients are in the global table for
838                                  * consistency only. They don't have to be
839                                  * taken into account while computing the
840                                  * global crc */
841                                 if (tt_global_entry->flags & TT_CLIENT_ROAM)
842                                         continue;
843                                 total_one = 0;
844                                 for (j = 0; j < ETH_ALEN; j++)
845                                         total_one = crc16_byte(total_one,
846                                                 tt_global_entry->addr[j]);
847                                 total ^= total_one;
848                         }
849                 }
850                 rcu_read_unlock();
851         }
852
853         return total;
854 }
855
856 /* Calculates the checksum of the local table */
857 uint16_t tt_local_crc(struct bat_priv *bat_priv)
858 {
859         uint16_t total = 0, total_one;
860         struct hashtable_t *hash = bat_priv->tt_local_hash;
861         struct tt_local_entry *tt_local_entry;
862         struct hlist_node *node;
863         struct hlist_head *head;
864         int i, j;
865
866         for (i = 0; i < hash->size; i++) {
867                 head = &hash->table[i];
868
869                 rcu_read_lock();
870                 hlist_for_each_entry_rcu(tt_local_entry, node,
871                                          head, hash_entry) {
872                         /* not yet committed clients have not to be taken into
873                          * account while computing the CRC */
874                         if (tt_local_entry->flags & TT_CLIENT_NEW)
875                                 continue;
876                         total_one = 0;
877                         for (j = 0; j < ETH_ALEN; j++)
878                                 total_one = crc16_byte(total_one,
879                                                    tt_local_entry->addr[j]);
880                         total ^= total_one;
881                 }
882                 rcu_read_unlock();
883         }
884
885         return total;
886 }
887
888 static void tt_req_list_free(struct bat_priv *bat_priv)
889 {
890         struct tt_req_node *node, *safe;
891
892         spin_lock_bh(&bat_priv->tt_req_list_lock);
893
894         list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
895                 list_del(&node->list);
896                 kfree(node);
897         }
898
899         spin_unlock_bh(&bat_priv->tt_req_list_lock);
900 }
901
902 void tt_save_orig_buffer(struct bat_priv *bat_priv, struct orig_node *orig_node,
903                          const unsigned char *tt_buff, uint8_t tt_num_changes)
904 {
905         uint16_t tt_buff_len = tt_len(tt_num_changes);
906
907         /* Replace the old buffer only if I received something in the
908          * last OGM (the OGM could carry no changes) */
909         spin_lock_bh(&orig_node->tt_buff_lock);
910         if (tt_buff_len > 0) {
911                 kfree(orig_node->tt_buff);
912                 orig_node->tt_buff_len = 0;
913                 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
914                 if (orig_node->tt_buff) {
915                         memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
916                         orig_node->tt_buff_len = tt_buff_len;
917                 }
918         }
919         spin_unlock_bh(&orig_node->tt_buff_lock);
920 }
921
922 static void tt_req_purge(struct bat_priv *bat_priv)
923 {
924         struct tt_req_node *node, *safe;
925
926         spin_lock_bh(&bat_priv->tt_req_list_lock);
927         list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
928                 if (is_out_of_time(node->issued_at,
929                     TT_REQUEST_TIMEOUT * 1000)) {
930                         list_del(&node->list);
931                         kfree(node);
932                 }
933         }
934         spin_unlock_bh(&bat_priv->tt_req_list_lock);
935 }
936
937 /* returns the pointer to the new tt_req_node struct if no request
938  * has already been issued for this orig_node, NULL otherwise */
939 static struct tt_req_node *new_tt_req_node(struct bat_priv *bat_priv,
940                                           struct orig_node *orig_node)
941 {
942         struct tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
943
944         spin_lock_bh(&bat_priv->tt_req_list_lock);
945         list_for_each_entry(tt_req_node_tmp, &bat_priv->tt_req_list, list) {
946                 if (compare_eth(tt_req_node_tmp, orig_node) &&
947                     !is_out_of_time(tt_req_node_tmp->issued_at,
948                                     TT_REQUEST_TIMEOUT * 1000))
949                         goto unlock;
950         }
951
952         tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
953         if (!tt_req_node)
954                 goto unlock;
955
956         memcpy(tt_req_node->addr, orig_node->orig, ETH_ALEN);
957         tt_req_node->issued_at = jiffies;
958
959         list_add(&tt_req_node->list, &bat_priv->tt_req_list);
960 unlock:
961         spin_unlock_bh(&bat_priv->tt_req_list_lock);
962         return tt_req_node;
963 }
964
965 /* data_ptr is useless here, but has to be kept to respect the prototype */
966 static int tt_local_valid_entry(const void *entry_ptr, const void *data_ptr)
967 {
968         const struct tt_local_entry *tt_local_entry = entry_ptr;
969
970         if (tt_local_entry->flags & TT_CLIENT_NEW)
971                 return 0;
972         return 1;
973 }
974
975 static int tt_global_valid_entry(const void *entry_ptr, const void *data_ptr)
976 {
977         const struct tt_global_entry *tt_global_entry = entry_ptr;
978         const struct orig_node *orig_node = data_ptr;
979
980         if (tt_global_entry->flags & TT_CLIENT_ROAM)
981                 return 0;
982
983         return (tt_global_entry->orig_node == orig_node);
984 }
985
986 static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
987                                               struct hashtable_t *hash,
988                                               struct hard_iface *primary_if,
989                                               int (*valid_cb)(const void *,
990                                                               const void *),
991                                               void *cb_data)
992 {
993         struct tt_local_entry *tt_local_entry;
994         struct tt_query_packet *tt_response;
995         struct tt_change *tt_change;
996         struct hlist_node *node;
997         struct hlist_head *head;
998         struct sk_buff *skb = NULL;
999         uint16_t tt_tot, tt_count;
1000         ssize_t tt_query_size = sizeof(struct tt_query_packet);
1001         int i;
1002
1003         if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
1004                 tt_len = primary_if->soft_iface->mtu - tt_query_size;
1005                 tt_len -= tt_len % sizeof(struct tt_change);
1006         }
1007         tt_tot = tt_len / sizeof(struct tt_change);
1008
1009         skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN);
1010         if (!skb)
1011                 goto out;
1012
1013         skb_reserve(skb, ETH_HLEN);
1014         tt_response = (struct tt_query_packet *)skb_put(skb,
1015                                                      tt_query_size + tt_len);
1016         tt_response->ttvn = ttvn;
1017
1018         tt_change = (struct tt_change *)(skb->data + tt_query_size);
1019         tt_count = 0;
1020
1021         rcu_read_lock();
1022         for (i = 0; i < hash->size; i++) {
1023                 head = &hash->table[i];
1024
1025                 hlist_for_each_entry_rcu(tt_local_entry, node,
1026                                          head, hash_entry) {
1027                         if (tt_count == tt_tot)
1028                                 break;
1029
1030                         if ((valid_cb) && (!valid_cb(tt_local_entry, cb_data)))
1031                                 continue;
1032
1033                         memcpy(tt_change->addr, tt_local_entry->addr, ETH_ALEN);
1034                         tt_change->flags = NO_FLAGS;
1035
1036                         tt_count++;
1037                         tt_change++;
1038                 }
1039         }
1040         rcu_read_unlock();
1041
1042         /* store in the message the number of entries we have successfully
1043          * copied */
1044         tt_response->tt_data = htons(tt_count);
1045
1046 out:
1047         return skb;
1048 }
1049
1050 int send_tt_request(struct bat_priv *bat_priv, struct orig_node *dst_orig_node,
1051                     uint8_t ttvn, uint16_t tt_crc, bool full_table)
1052 {
1053         struct sk_buff *skb = NULL;
1054         struct tt_query_packet *tt_request;
1055         struct neigh_node *neigh_node = NULL;
1056         struct hard_iface *primary_if;
1057         struct tt_req_node *tt_req_node = NULL;
1058         int ret = 1;
1059
1060         primary_if = primary_if_get_selected(bat_priv);
1061         if (!primary_if)
1062                 goto out;
1063
1064         /* The new tt_req will be issued only if I'm not waiting for a
1065          * reply from the same orig_node yet */
1066         tt_req_node = new_tt_req_node(bat_priv, dst_orig_node);
1067         if (!tt_req_node)
1068                 goto out;
1069
1070         skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN);
1071         if (!skb)
1072                 goto out;
1073
1074         skb_reserve(skb, ETH_HLEN);
1075
1076         tt_request = (struct tt_query_packet *)skb_put(skb,
1077                                 sizeof(struct tt_query_packet));
1078
1079         tt_request->packet_type = BAT_TT_QUERY;
1080         tt_request->version = COMPAT_VERSION;
1081         memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1082         memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN);
1083         tt_request->ttl = TTL;
1084         tt_request->ttvn = ttvn;
1085         tt_request->tt_data = tt_crc;
1086         tt_request->flags = TT_REQUEST;
1087
1088         if (full_table)
1089                 tt_request->flags |= TT_FULL_TABLE;
1090
1091         neigh_node = orig_node_get_router(dst_orig_node);
1092         if (!neigh_node)
1093                 goto out;
1094
1095         bat_dbg(DBG_TT, bat_priv, "Sending TT_REQUEST to %pM via %pM "
1096                 "[%c]\n", dst_orig_node->orig, neigh_node->addr,
1097                 (full_table ? 'F' : '.'));
1098
1099         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1100         ret = 0;
1101
1102 out:
1103         if (neigh_node)
1104                 neigh_node_free_ref(neigh_node);
1105         if (primary_if)
1106                 hardif_free_ref(primary_if);
1107         if (ret)
1108                 kfree_skb(skb);
1109         if (ret && tt_req_node) {
1110                 spin_lock_bh(&bat_priv->tt_req_list_lock);
1111                 list_del(&tt_req_node->list);
1112                 spin_unlock_bh(&bat_priv->tt_req_list_lock);
1113                 kfree(tt_req_node);
1114         }
1115         return ret;
1116 }
1117
1118 static bool send_other_tt_response(struct bat_priv *bat_priv,
1119                                    struct tt_query_packet *tt_request)
1120 {
1121         struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
1122         struct neigh_node *neigh_node = NULL;
1123         struct hard_iface *primary_if = NULL;
1124         uint8_t orig_ttvn, req_ttvn, ttvn;
1125         int ret = false;
1126         unsigned char *tt_buff;
1127         bool full_table;
1128         uint16_t tt_len, tt_tot;
1129         struct sk_buff *skb = NULL;
1130         struct tt_query_packet *tt_response;
1131
1132         bat_dbg(DBG_TT, bat_priv,
1133                 "Received TT_REQUEST from %pM for "
1134                 "ttvn: %u (%pM) [%c]\n", tt_request->src,
1135                 tt_request->ttvn, tt_request->dst,
1136                 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
1137
1138         /* Let's get the orig node of the REAL destination */
1139         req_dst_orig_node = get_orig_node(bat_priv, tt_request->dst);
1140         if (!req_dst_orig_node)
1141                 goto out;
1142
1143         res_dst_orig_node = get_orig_node(bat_priv, tt_request->src);
1144         if (!res_dst_orig_node)
1145                 goto out;
1146
1147         neigh_node = orig_node_get_router(res_dst_orig_node);
1148         if (!neigh_node)
1149                 goto out;
1150
1151         primary_if = primary_if_get_selected(bat_priv);
1152         if (!primary_if)
1153                 goto out;
1154
1155         orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
1156         req_ttvn = tt_request->ttvn;
1157
1158         /* I have not the requested data */
1159         if (orig_ttvn != req_ttvn ||
1160             tt_request->tt_data != req_dst_orig_node->tt_crc)
1161                 goto out;
1162
1163         /* If it has explicitly been requested the full table */
1164         if (tt_request->flags & TT_FULL_TABLE ||
1165             !req_dst_orig_node->tt_buff)
1166                 full_table = true;
1167         else
1168                 full_table = false;
1169
1170         /* In this version, fragmentation is not implemented, then
1171          * I'll send only one packet with as much TT entries as I can */
1172         if (!full_table) {
1173                 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
1174                 tt_len = req_dst_orig_node->tt_buff_len;
1175                 tt_tot = tt_len / sizeof(struct tt_change);
1176
1177                 skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
1178                                     tt_len + ETH_HLEN);
1179                 if (!skb)
1180                         goto unlock;
1181
1182                 skb_reserve(skb, ETH_HLEN);
1183                 tt_response = (struct tt_query_packet *)skb_put(skb,
1184                                 sizeof(struct tt_query_packet) + tt_len);
1185                 tt_response->ttvn = req_ttvn;
1186                 tt_response->tt_data = htons(tt_tot);
1187
1188                 tt_buff = skb->data + sizeof(struct tt_query_packet);
1189                 /* Copy the last orig_node's OGM buffer */
1190                 memcpy(tt_buff, req_dst_orig_node->tt_buff,
1191                        req_dst_orig_node->tt_buff_len);
1192
1193                 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
1194         } else {
1195                 tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) *
1196                                                 sizeof(struct tt_change);
1197                 ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
1198
1199                 skb = tt_response_fill_table(tt_len, ttvn,
1200                                              bat_priv->tt_global_hash,
1201                                              primary_if, tt_global_valid_entry,
1202                                              req_dst_orig_node);
1203                 if (!skb)
1204                         goto out;
1205
1206                 tt_response = (struct tt_query_packet *)skb->data;
1207         }
1208
1209         tt_response->packet_type = BAT_TT_QUERY;
1210         tt_response->version = COMPAT_VERSION;
1211         tt_response->ttl = TTL;
1212         memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN);
1213         memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
1214         tt_response->flags = TT_RESPONSE;
1215
1216         if (full_table)
1217                 tt_response->flags |= TT_FULL_TABLE;
1218
1219         bat_dbg(DBG_TT, bat_priv,
1220                 "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
1221                 res_dst_orig_node->orig, neigh_node->addr,
1222                 req_dst_orig_node->orig, req_ttvn);
1223
1224         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1225         ret = true;
1226         goto out;
1227
1228 unlock:
1229         spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
1230
1231 out:
1232         if (res_dst_orig_node)
1233                 orig_node_free_ref(res_dst_orig_node);
1234         if (req_dst_orig_node)
1235                 orig_node_free_ref(req_dst_orig_node);
1236         if (neigh_node)
1237                 neigh_node_free_ref(neigh_node);
1238         if (primary_if)
1239                 hardif_free_ref(primary_if);
1240         if (!ret)
1241                 kfree_skb(skb);
1242         return ret;
1243
1244 }
1245 static bool send_my_tt_response(struct bat_priv *bat_priv,
1246                                 struct tt_query_packet *tt_request)
1247 {
1248         struct orig_node *orig_node = NULL;
1249         struct neigh_node *neigh_node = NULL;
1250         struct hard_iface *primary_if = NULL;
1251         uint8_t my_ttvn, req_ttvn, ttvn;
1252         int ret = false;
1253         unsigned char *tt_buff;
1254         bool full_table;
1255         uint16_t tt_len, tt_tot;
1256         struct sk_buff *skb = NULL;
1257         struct tt_query_packet *tt_response;
1258
1259         bat_dbg(DBG_TT, bat_priv,
1260                 "Received TT_REQUEST from %pM for "
1261                 "ttvn: %u (me) [%c]\n", tt_request->src,
1262                 tt_request->ttvn,
1263                 (tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
1264
1265
1266         my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
1267         req_ttvn = tt_request->ttvn;
1268
1269         orig_node = get_orig_node(bat_priv, tt_request->src);
1270         if (!orig_node)
1271                 goto out;
1272
1273         neigh_node = orig_node_get_router(orig_node);
1274         if (!neigh_node)
1275                 goto out;
1276
1277         primary_if = primary_if_get_selected(bat_priv);
1278         if (!primary_if)
1279                 goto out;
1280
1281         /* If the full table has been explicitly requested or the gap
1282          * is too big send the whole local translation table */
1283         if (tt_request->flags & TT_FULL_TABLE || my_ttvn != req_ttvn ||
1284             !bat_priv->tt_buff)
1285                 full_table = true;
1286         else
1287                 full_table = false;
1288
1289         /* In this version, fragmentation is not implemented, then
1290          * I'll send only one packet with as much TT entries as I can */
1291         if (!full_table) {
1292                 spin_lock_bh(&bat_priv->tt_buff_lock);
1293                 tt_len = bat_priv->tt_buff_len;
1294                 tt_tot = tt_len / sizeof(struct tt_change);
1295
1296                 skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
1297                                     tt_len + ETH_HLEN);
1298                 if (!skb)
1299                         goto unlock;
1300
1301                 skb_reserve(skb, ETH_HLEN);
1302                 tt_response = (struct tt_query_packet *)skb_put(skb,
1303                                 sizeof(struct tt_query_packet) + tt_len);
1304                 tt_response->ttvn = req_ttvn;
1305                 tt_response->tt_data = htons(tt_tot);
1306
1307                 tt_buff = skb->data + sizeof(struct tt_query_packet);
1308                 memcpy(tt_buff, bat_priv->tt_buff,
1309                        bat_priv->tt_buff_len);
1310                 spin_unlock_bh(&bat_priv->tt_buff_lock);
1311         } else {
1312                 tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) *
1313                                                 sizeof(struct tt_change);
1314                 ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
1315
1316                 skb = tt_response_fill_table(tt_len, ttvn,
1317                                              bat_priv->tt_local_hash,
1318                                              primary_if, tt_local_valid_entry,
1319                                              NULL);
1320                 if (!skb)
1321                         goto out;
1322
1323                 tt_response = (struct tt_query_packet *)skb->data;
1324         }
1325
1326         tt_response->packet_type = BAT_TT_QUERY;
1327         tt_response->version = COMPAT_VERSION;
1328         tt_response->ttl = TTL;
1329         memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1330         memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
1331         tt_response->flags = TT_RESPONSE;
1332
1333         if (full_table)
1334                 tt_response->flags |= TT_FULL_TABLE;
1335
1336         bat_dbg(DBG_TT, bat_priv,
1337                 "Sending TT_RESPONSE to %pM via %pM [%c]\n",
1338                 orig_node->orig, neigh_node->addr,
1339                 (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
1340
1341         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1342         ret = true;
1343         goto out;
1344
1345 unlock:
1346         spin_unlock_bh(&bat_priv->tt_buff_lock);
1347 out:
1348         if (orig_node)
1349                 orig_node_free_ref(orig_node);
1350         if (neigh_node)
1351                 neigh_node_free_ref(neigh_node);
1352         if (primary_if)
1353                 hardif_free_ref(primary_if);
1354         if (!ret)
1355                 kfree_skb(skb);
1356         /* This packet was for me, so it doesn't need to be re-routed */
1357         return true;
1358 }
1359
1360 bool send_tt_response(struct bat_priv *bat_priv,
1361                       struct tt_query_packet *tt_request)
1362 {
1363         if (is_my_mac(tt_request->dst))
1364                 return send_my_tt_response(bat_priv, tt_request);
1365         else
1366                 return send_other_tt_response(bat_priv, tt_request);
1367 }
1368
1369 static void _tt_update_changes(struct bat_priv *bat_priv,
1370                                struct orig_node *orig_node,
1371                                struct tt_change *tt_change,
1372                                uint16_t tt_num_changes, uint8_t ttvn)
1373 {
1374         int i;
1375
1376         for (i = 0; i < tt_num_changes; i++) {
1377                 if ((tt_change + i)->flags & TT_CLIENT_DEL)
1378                         tt_global_del(bat_priv, orig_node,
1379                                       (tt_change + i)->addr,
1380                                       "tt removed by changes",
1381                                       (tt_change + i)->flags & TT_CLIENT_ROAM);
1382                 else
1383                         if (!tt_global_add(bat_priv, orig_node,
1384                                            (tt_change + i)->addr, ttvn, false))
1385                                 /* In case of problem while storing a
1386                                  * global_entry, we stop the updating
1387                                  * procedure without committing the
1388                                  * ttvn change. This will avoid to send
1389                                  * corrupted data on tt_request
1390                                  */
1391                                 return;
1392         }
1393 }
1394
1395 static void tt_fill_gtable(struct bat_priv *bat_priv,
1396                            struct tt_query_packet *tt_response)
1397 {
1398         struct orig_node *orig_node = NULL;
1399
1400         orig_node = orig_hash_find(bat_priv, tt_response->src);
1401         if (!orig_node)
1402                 goto out;
1403
1404         /* Purge the old table first.. */
1405         tt_global_del_orig(bat_priv, orig_node, "Received full table");
1406
1407         _tt_update_changes(bat_priv, orig_node,
1408                            (struct tt_change *)(tt_response + 1),
1409                            tt_response->tt_data, tt_response->ttvn);
1410
1411         spin_lock_bh(&orig_node->tt_buff_lock);
1412         kfree(orig_node->tt_buff);
1413         orig_node->tt_buff_len = 0;
1414         orig_node->tt_buff = NULL;
1415         spin_unlock_bh(&orig_node->tt_buff_lock);
1416
1417         atomic_set(&orig_node->last_ttvn, tt_response->ttvn);
1418
1419 out:
1420         if (orig_node)
1421                 orig_node_free_ref(orig_node);
1422 }
1423
1424 void tt_update_changes(struct bat_priv *bat_priv, struct orig_node *orig_node,
1425                        uint16_t tt_num_changes, uint8_t ttvn,
1426                        struct tt_change *tt_change)
1427 {
1428         _tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes,
1429                            ttvn);
1430
1431         tt_save_orig_buffer(bat_priv, orig_node, (unsigned char *)tt_change,
1432                             tt_num_changes);
1433         atomic_set(&orig_node->last_ttvn, ttvn);
1434 }
1435
1436 bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr)
1437 {
1438         struct tt_local_entry *tt_local_entry = NULL;
1439         bool ret = false;
1440
1441         tt_local_entry = tt_local_hash_find(bat_priv, addr);
1442         if (!tt_local_entry)
1443                 goto out;
1444         /* Check if the client has been logically deleted (but is kept for
1445          * consistency purpose) */
1446         if (tt_local_entry->flags & TT_CLIENT_PENDING)
1447                 goto out;
1448         ret = true;
1449 out:
1450         if (tt_local_entry)
1451                 tt_local_entry_free_ref(tt_local_entry);
1452         return ret;
1453 }
1454
1455 void handle_tt_response(struct bat_priv *bat_priv,
1456                         struct tt_query_packet *tt_response)
1457 {
1458         struct tt_req_node *node, *safe;
1459         struct orig_node *orig_node = NULL;
1460
1461         bat_dbg(DBG_TT, bat_priv, "Received TT_RESPONSE from %pM for "
1462                 "ttvn %d t_size: %d [%c]\n",
1463                 tt_response->src, tt_response->ttvn,
1464                 tt_response->tt_data,
1465                 (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
1466
1467         orig_node = orig_hash_find(bat_priv, tt_response->src);
1468         if (!orig_node)
1469                 goto out;
1470
1471         if (tt_response->flags & TT_FULL_TABLE)
1472                 tt_fill_gtable(bat_priv, tt_response);
1473         else
1474                 tt_update_changes(bat_priv, orig_node, tt_response->tt_data,
1475                                   tt_response->ttvn,
1476                                   (struct tt_change *)(tt_response + 1));
1477
1478         /* Delete the tt_req_node from pending tt_requests list */
1479         spin_lock_bh(&bat_priv->tt_req_list_lock);
1480         list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
1481                 if (!compare_eth(node->addr, tt_response->src))
1482                         continue;
1483                 list_del(&node->list);
1484                 kfree(node);
1485         }
1486         spin_unlock_bh(&bat_priv->tt_req_list_lock);
1487
1488         /* Recalculate the CRC for this orig_node and store it */
1489         orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
1490         /* Roaming phase is over: tables are in sync again. I can
1491          * unset the flag */
1492         orig_node->tt_poss_change = false;
1493 out:
1494         if (orig_node)
1495                 orig_node_free_ref(orig_node);
1496 }
1497
1498 int tt_init(struct bat_priv *bat_priv)
1499 {
1500         if (!tt_local_init(bat_priv))
1501                 return 0;
1502
1503         if (!tt_global_init(bat_priv))
1504                 return 0;
1505
1506         tt_start_timer(bat_priv);
1507
1508         return 1;
1509 }
1510
1511 static void tt_roam_list_free(struct bat_priv *bat_priv)
1512 {
1513         struct tt_roam_node *node, *safe;
1514
1515         spin_lock_bh(&bat_priv->tt_roam_list_lock);
1516
1517         list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
1518                 list_del(&node->list);
1519                 kfree(node);
1520         }
1521
1522         spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1523 }
1524
1525 static void tt_roam_purge(struct bat_priv *bat_priv)
1526 {
1527         struct tt_roam_node *node, *safe;
1528
1529         spin_lock_bh(&bat_priv->tt_roam_list_lock);
1530         list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
1531                 if (!is_out_of_time(node->first_time,
1532                                     ROAMING_MAX_TIME * 1000))
1533                         continue;
1534
1535                 list_del(&node->list);
1536                 kfree(node);
1537         }
1538         spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1539 }
1540
1541 /* This function checks whether the client already reached the
1542  * maximum number of possible roaming phases. In this case the ROAMING_ADV
1543  * will not be sent.
1544  *
1545  * returns true if the ROAMING_ADV can be sent, false otherwise */
1546 static bool tt_check_roam_count(struct bat_priv *bat_priv,
1547                                 uint8_t *client)
1548 {
1549         struct tt_roam_node *tt_roam_node;
1550         bool ret = false;
1551
1552         spin_lock_bh(&bat_priv->tt_roam_list_lock);
1553         /* The new tt_req will be issued only if I'm not waiting for a
1554          * reply from the same orig_node yet */
1555         list_for_each_entry(tt_roam_node, &bat_priv->tt_roam_list, list) {
1556                 if (!compare_eth(tt_roam_node->addr, client))
1557                         continue;
1558
1559                 if (is_out_of_time(tt_roam_node->first_time,
1560                                    ROAMING_MAX_TIME * 1000))
1561                         continue;
1562
1563                 if (!atomic_dec_not_zero(&tt_roam_node->counter))
1564                         /* Sorry, you roamed too many times! */
1565                         goto unlock;
1566                 ret = true;
1567                 break;
1568         }
1569
1570         if (!ret) {
1571                 tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
1572                 if (!tt_roam_node)
1573                         goto unlock;
1574
1575                 tt_roam_node->first_time = jiffies;
1576                 atomic_set(&tt_roam_node->counter, ROAMING_MAX_COUNT - 1);
1577                 memcpy(tt_roam_node->addr, client, ETH_ALEN);
1578
1579                 list_add(&tt_roam_node->list, &bat_priv->tt_roam_list);
1580                 ret = true;
1581         }
1582
1583 unlock:
1584         spin_unlock_bh(&bat_priv->tt_roam_list_lock);
1585         return ret;
1586 }
1587
1588 void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
1589                    struct orig_node *orig_node)
1590 {
1591         struct neigh_node *neigh_node = NULL;
1592         struct sk_buff *skb = NULL;
1593         struct roam_adv_packet *roam_adv_packet;
1594         int ret = 1;
1595         struct hard_iface *primary_if;
1596
1597         /* before going on we have to check whether the client has
1598          * already roamed to us too many times */
1599         if (!tt_check_roam_count(bat_priv, client))
1600                 goto out;
1601
1602         skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN);
1603         if (!skb)
1604                 goto out;
1605
1606         skb_reserve(skb, ETH_HLEN);
1607
1608         roam_adv_packet = (struct roam_adv_packet *)skb_put(skb,
1609                                         sizeof(struct roam_adv_packet));
1610
1611         roam_adv_packet->packet_type = BAT_ROAM_ADV;
1612         roam_adv_packet->version = COMPAT_VERSION;
1613         roam_adv_packet->ttl = TTL;
1614         primary_if = primary_if_get_selected(bat_priv);
1615         if (!primary_if)
1616                 goto out;
1617         memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
1618         hardif_free_ref(primary_if);
1619         memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN);
1620         memcpy(roam_adv_packet->client, client, ETH_ALEN);
1621
1622         neigh_node = orig_node_get_router(orig_node);
1623         if (!neigh_node)
1624                 goto out;
1625
1626         bat_dbg(DBG_TT, bat_priv,
1627                 "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
1628                 orig_node->orig, client, neigh_node->addr);
1629
1630         send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
1631         ret = 0;
1632
1633 out:
1634         if (neigh_node)
1635                 neigh_node_free_ref(neigh_node);
1636         if (ret)
1637                 kfree_skb(skb);
1638         return;
1639 }
1640
1641 static void tt_purge(struct work_struct *work)
1642 {
1643         struct delayed_work *delayed_work =
1644                 container_of(work, struct delayed_work, work);
1645         struct bat_priv *bat_priv =
1646                 container_of(delayed_work, struct bat_priv, tt_work);
1647
1648         tt_local_purge(bat_priv);
1649         tt_global_roam_purge(bat_priv);
1650         tt_req_purge(bat_priv);
1651         tt_roam_purge(bat_priv);
1652
1653         tt_start_timer(bat_priv);
1654 }
1655
1656 void tt_free(struct bat_priv *bat_priv)
1657 {
1658         cancel_delayed_work_sync(&bat_priv->tt_work);
1659
1660         tt_local_table_free(bat_priv);
1661         tt_global_table_free(bat_priv);
1662         tt_req_list_free(bat_priv);
1663         tt_changes_list_free(bat_priv);
1664         tt_roam_list_free(bat_priv);
1665
1666         kfree(bat_priv->tt_buff);
1667 }
1668
1669 /* This function will reset the specified flags from all the entries in
1670  * the given hash table and will increment num_local_tt for each involved
1671  * entry */
1672 static void tt_local_reset_flags(struct bat_priv *bat_priv, uint16_t flags)
1673 {
1674         int i;
1675         struct hashtable_t *hash = bat_priv->tt_local_hash;
1676         struct hlist_head *head;
1677         struct hlist_node *node;
1678         struct tt_local_entry *tt_local_entry;
1679
1680         if (!hash)
1681                 return;
1682
1683         for (i = 0; i < hash->size; i++) {
1684                 head = &hash->table[i];
1685
1686                 rcu_read_lock();
1687                 hlist_for_each_entry_rcu(tt_local_entry, node,
1688                                          head, hash_entry) {
1689                         if (!(tt_local_entry->flags & flags))
1690                                 continue;
1691                         tt_local_entry->flags &= ~flags;
1692                         atomic_inc(&bat_priv->num_local_tt);
1693                 }
1694                 rcu_read_unlock();
1695         }
1696
1697 }
1698
1699 /* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
1700 static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
1701 {
1702         struct hashtable_t *hash = bat_priv->tt_local_hash;
1703         struct tt_local_entry *tt_local_entry;
1704         struct hlist_node *node, *node_tmp;
1705         struct hlist_head *head;
1706         spinlock_t *list_lock; /* protects write access to the hash lists */
1707         int i;
1708
1709         if (!hash)
1710                 return;
1711
1712         for (i = 0; i < hash->size; i++) {
1713                 head = &hash->table[i];
1714                 list_lock = &hash->list_locks[i];
1715
1716                 spin_lock_bh(list_lock);
1717                 hlist_for_each_entry_safe(tt_local_entry, node, node_tmp,
1718                                           head, hash_entry) {
1719                         if (!(tt_local_entry->flags & TT_CLIENT_PENDING))
1720                                 continue;
1721
1722                         bat_dbg(DBG_TT, bat_priv, "Deleting local tt entry "
1723                                 "(%pM): pending\n", tt_local_entry->addr);
1724
1725                         atomic_dec(&bat_priv->num_local_tt);
1726                         hlist_del_rcu(node);
1727                         tt_local_entry_free_ref(tt_local_entry);
1728                 }
1729                 spin_unlock_bh(list_lock);
1730         }
1731
1732 }
1733
1734 void tt_commit_changes(struct bat_priv *bat_priv)
1735 {
1736         tt_local_reset_flags(bat_priv, TT_CLIENT_NEW);
1737         tt_local_purge_pending_clients(bat_priv);
1738
1739         /* Increment the TTVN only once per OGM interval */
1740         atomic_inc(&bat_priv->ttvn);
1741         bat_priv->tt_poss_change = false;
1742 }