1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "main.h"
19#include "translation-table.h"
20#include "soft-interface.h"
21#include "hard-interface.h"
22#include "send.h"
23#include "hash.h"
24#include "originator.h"
25#include "routing.h"
26#include "bridge_loop_avoidance.h"
27#include "multicast.h"
28
29#include <linux/crc32c.h>
30
31
32static struct lock_class_key batadv_tt_local_hash_lock_class_key;
33static struct lock_class_key batadv_tt_global_hash_lock_class_key;
34
35static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client,
36 unsigned short vid,
37 struct batadv_orig_node *orig_node);
38static void batadv_tt_purge(struct work_struct *work);
39static void
40batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);
41static void batadv_tt_global_del(struct batadv_priv *bat_priv,
42 struct batadv_orig_node *orig_node,
43 const unsigned char *addr,
44 unsigned short vid, const char *message,
45 bool roaming);
46
47
48static int batadv_compare_tt(const struct hlist_node *node, const void *data2)
49{
50 const void *data1 = container_of(node, struct batadv_tt_common_entry,
51 hash_entry);
52
53 return batadv_compare_eth(data1, data2);
54}
55
56
57
58
59
60
61
62
63
64static inline uint32_t batadv_choose_tt(const void *data, uint32_t size)
65{
66 struct batadv_tt_common_entry *tt;
67 uint32_t hash = 0;
68
69 tt = (struct batadv_tt_common_entry *)data;
70 hash = batadv_hash_bytes(hash, &tt->addr, ETH_ALEN);
71 hash = batadv_hash_bytes(hash, &tt->vid, sizeof(tt->vid));
72
73 hash += (hash << 3);
74 hash ^= (hash >> 11);
75 hash += (hash << 15);
76
77 return hash % size;
78}
79
80
81
82
83
84
85
86
87
88
89static struct batadv_tt_common_entry *
90batadv_tt_hash_find(struct batadv_hashtable *hash, const uint8_t *addr,
91 unsigned short vid)
92{
93 struct hlist_head *head;
94 struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;
95 uint32_t index;
96
97 if (!hash)
98 return NULL;
99
100 ether_addr_copy(to_search.addr, addr);
101 to_search.vid = vid;
102
103 index = batadv_choose_tt(&to_search, hash->size);
104 head = &hash->table[index];
105
106 rcu_read_lock();
107 hlist_for_each_entry_rcu(tt, head, hash_entry) {
108 if (!batadv_compare_eth(tt, addr))
109 continue;
110
111 if (tt->vid != vid)
112 continue;
113
114 if (!atomic_inc_not_zero(&tt->refcount))
115 continue;
116
117 tt_tmp = tt;
118 break;
119 }
120 rcu_read_unlock();
121
122 return tt_tmp;
123}
124
125
126
127
128
129
130
131
132
133
134static struct batadv_tt_local_entry *
135batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const uint8_t *addr,
136 unsigned short vid)
137{
138 struct batadv_tt_common_entry *tt_common_entry;
139 struct batadv_tt_local_entry *tt_local_entry = NULL;
140
141 tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
142 vid);
143 if (tt_common_entry)
144 tt_local_entry = container_of(tt_common_entry,
145 struct batadv_tt_local_entry,
146 common);
147 return tt_local_entry;
148}
149
150
151
152
153
154
155
156
157
158
159static struct batadv_tt_global_entry *
160batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const uint8_t *addr,
161 unsigned short vid)
162{
163 struct batadv_tt_common_entry *tt_common_entry;
164 struct batadv_tt_global_entry *tt_global_entry = NULL;
165
166 tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
167 vid);
168 if (tt_common_entry)
169 tt_global_entry = container_of(tt_common_entry,
170 struct batadv_tt_global_entry,
171 common);
172 return tt_global_entry;
173}
174
175static void
176batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)
177{
178 if (atomic_dec_and_test(&tt_local_entry->common.refcount))
179 kfree_rcu(tt_local_entry, common.rcu);
180}
181
182
183
184
185
186
187static void
188batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)
189{
190 if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {
191 batadv_tt_global_del_orig_list(tt_global_entry);
192 kfree_rcu(tt_global_entry, common.rcu);
193 }
194}
195
196
197
198
199
200
201
202
203
204
205int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
206 const uint8_t *addr, unsigned short vid)
207{
208 struct batadv_tt_global_entry *tt_global_entry;
209 int count;
210
211 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
212 if (!tt_global_entry)
213 return 0;
214
215 count = atomic_read(&tt_global_entry->orig_list_count);
216 batadv_tt_global_entry_free_ref(tt_global_entry);
217
218 return count;
219}
220
221static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
222{
223 struct batadv_tt_orig_list_entry *orig_entry;
224
225 orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);
226
227
228
229
230
231 batadv_orig_node_free_ref_now(orig_entry->orig_node);
232 kfree(orig_entry);
233}
234
235
236
237
238
239
240
241
242static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,
243 unsigned short vid, int v)
244{
245 struct batadv_softif_vlan *vlan;
246
247 vlan = batadv_softif_vlan_get(bat_priv, vid);
248 if (!vlan)
249 return;
250
251 atomic_add(v, &vlan->tt.num_entries);
252
253 batadv_softif_vlan_free_ref(vlan);
254}
255
256
257
258
259
260
261
262static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,
263 unsigned short vid)
264{
265 batadv_tt_local_size_mod(bat_priv, vid, 1);
266}
267
268
269
270
271
272
273
274static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,
275 unsigned short vid)
276{
277 batadv_tt_local_size_mod(bat_priv, vid, -1);
278}
279
280
281
282
283
284
285
286
287static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,
288 unsigned short vid, int v)
289{
290 struct batadv_orig_node_vlan *vlan;
291
292 vlan = batadv_orig_node_vlan_new(orig_node, vid);
293 if (!vlan)
294 return;
295
296 if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {
297 spin_lock_bh(&orig_node->vlan_list_lock);
298 list_del_rcu(&vlan->list);
299 spin_unlock_bh(&orig_node->vlan_list_lock);
300 batadv_orig_node_vlan_free_ref(vlan);
301 }
302
303 batadv_orig_node_vlan_free_ref(vlan);
304}
305
306
307
308
309
310
311
312static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,
313 unsigned short vid)
314{
315 batadv_tt_global_size_mod(orig_node, vid, 1);
316}
317
318
319
320
321
322
323
324static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,
325 unsigned short vid)
326{
327 batadv_tt_global_size_mod(orig_node, vid, -1);
328}
329
330static void
331batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)
332{
333 if (!atomic_dec_and_test(&orig_entry->refcount))
334 return;
335
336 call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);
337}
338
339
340
341
342
343
344
345static void batadv_tt_local_event(struct batadv_priv *bat_priv,
346 struct batadv_tt_local_entry *tt_local_entry,
347 uint8_t event_flags)
348{
349 struct batadv_tt_change_node *tt_change_node, *entry, *safe;
350 struct batadv_tt_common_entry *common = &tt_local_entry->common;
351 uint8_t flags = common->flags | event_flags;
352 bool event_removed = false;
353 bool del_op_requested, del_op_entry;
354
355 tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
356 if (!tt_change_node)
357 return;
358
359 tt_change_node->change.flags = flags;
360 memset(tt_change_node->change.reserved, 0,
361 sizeof(tt_change_node->change.reserved));
362 ether_addr_copy(tt_change_node->change.addr, common->addr);
363 tt_change_node->change.vid = htons(common->vid);
364
365 del_op_requested = flags & BATADV_TT_CLIENT_DEL;
366
367
368 spin_lock_bh(&bat_priv->tt.changes_list_lock);
369 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
370 list) {
371 if (!batadv_compare_eth(entry->change.addr, common->addr))
372 continue;
373
374
375
376
377
378
379
380
381 del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
382 if (!del_op_requested && del_op_entry)
383 goto del;
384 if (del_op_requested && !del_op_entry)
385 goto del;
386
387
388
389
390 if (!del_op_requested && !del_op_entry)
391 entry->change.flags = flags;
392
393 continue;
394del:
395 list_del(&entry->list);
396 kfree(entry);
397 kfree(tt_change_node);
398 event_removed = true;
399 goto unlock;
400 }
401
402
403 list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);
404
405unlock:
406 spin_unlock_bh(&bat_priv->tt.changes_list_lock);
407
408 if (event_removed)
409 atomic_dec(&bat_priv->tt.local_changes);
410 else
411 atomic_inc(&bat_priv->tt.local_changes);
412}
413
414
415
416
417
418
419
420static int batadv_tt_len(int changes_num)
421{
422 return changes_num * sizeof(struct batadv_tvlv_tt_change);
423}
424
425
426
427
428
429
430
431static uint16_t batadv_tt_entries(uint16_t tt_len)
432{
433 return tt_len / batadv_tt_len(1);
434}
435
436
437
438
439
440
441
442
443static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
444{
445 uint16_t num_vlan = 0, tt_local_entries = 0;
446 struct batadv_softif_vlan *vlan;
447 int hdr_size;
448
449 rcu_read_lock();
450 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
451 num_vlan++;
452 tt_local_entries += atomic_read(&vlan->tt.num_entries);
453 }
454 rcu_read_unlock();
455
456
457 hdr_size = sizeof(struct batadv_unicast_tvlv_packet);
458 hdr_size += sizeof(struct batadv_tvlv_hdr);
459 hdr_size += sizeof(struct batadv_tvlv_tt_data);
460 hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);
461
462 return hdr_size + batadv_tt_len(tt_local_entries);
463}
464
465static int batadv_tt_local_init(struct batadv_priv *bat_priv)
466{
467 if (bat_priv->tt.local_hash)
468 return 0;
469
470 bat_priv->tt.local_hash = batadv_hash_new(1024);
471
472 if (!bat_priv->tt.local_hash)
473 return -ENOMEM;
474
475 batadv_hash_set_lock_class(bat_priv->tt.local_hash,
476 &batadv_tt_local_hash_lock_class_key);
477
478 return 0;
479}
480
481static void batadv_tt_global_free(struct batadv_priv *bat_priv,
482 struct batadv_tt_global_entry *tt_global,
483 const char *message)
484{
485 batadv_dbg(BATADV_DBG_TT, bat_priv,
486 "Deleting global tt entry %pM (vid: %d): %s\n",
487 tt_global->common.addr,
488 BATADV_PRINT_VID(tt_global->common.vid), message);
489
490 batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
491 batadv_choose_tt, &tt_global->common);
492 batadv_tt_global_entry_free_ref(tt_global);
493}
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508bool batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
509 unsigned short vid, int ifindex, uint32_t mark)
510{
511 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
512 struct batadv_tt_local_entry *tt_local;
513 struct batadv_tt_global_entry *tt_global = NULL;
514 struct batadv_softif_vlan *vlan;
515 struct net_device *in_dev = NULL;
516 struct hlist_head *head;
517 struct batadv_tt_orig_list_entry *orig_entry;
518 int hash_added, table_size, packet_size_max;
519 bool ret = false, roamed_back = false;
520 uint8_t remote_flags;
521 uint32_t match_mark;
522
523 if (ifindex != BATADV_NULL_IFINDEX)
524 in_dev = dev_get_by_index(&init_net, ifindex);
525
526 tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);
527
528 if (!is_multicast_ether_addr(addr))
529 tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);
530
531 if (tt_local) {
532 tt_local->last_seen = jiffies;
533 if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
534 batadv_dbg(BATADV_DBG_TT, bat_priv,
535 "Re-adding pending client %pM (vid: %d)\n",
536 addr, BATADV_PRINT_VID(vid));
537
538
539
540
541
542 tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;
543 goto add_event;
544 }
545
546 if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {
547 batadv_dbg(BATADV_DBG_TT, bat_priv,
548 "Roaming client %pM (vid: %d) came back to its original location\n",
549 addr, BATADV_PRINT_VID(vid));
550
551
552
553
554
555 tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;
556 roamed_back = true;
557 }
558 goto check_roaming;
559 }
560
561
562 table_size = batadv_tt_local_table_transmit_size(bat_priv);
563 table_size += batadv_tt_len(1);
564 packet_size_max = atomic_read(&bat_priv->packet_size_max);
565 if (table_size > packet_size_max) {
566 net_ratelimited_function(batadv_info, soft_iface,
567 "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",
568 table_size, packet_size_max, addr);
569 goto out;
570 }
571
572 tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);
573 if (!tt_local)
574 goto out;
575
576
577 vlan = batadv_softif_vlan_get(bat_priv, vid);
578
579 batadv_dbg(BATADV_DBG_TT, bat_priv,
580 "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",
581 addr, BATADV_PRINT_VID(vid),
582 (uint8_t)atomic_read(&bat_priv->tt.vn));
583
584 ether_addr_copy(tt_local->common.addr, addr);
585
586
587
588
589 tt_local->common.flags = BATADV_TT_CLIENT_NEW;
590 tt_local->common.vid = vid;
591 if (batadv_is_wifi_netdev(in_dev))
592 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
593 atomic_set(&tt_local->common.refcount, 2);
594 tt_local->last_seen = jiffies;
595 tt_local->common.added_at = tt_local->last_seen;
596
597
598
599
600 if (batadv_compare_eth(addr, soft_iface->dev_addr) ||
601 is_multicast_ether_addr(addr))
602 tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;
603
604 hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
605 batadv_choose_tt, &tt_local->common,
606 &tt_local->common.hash_entry);
607
608 if (unlikely(hash_added != 0)) {
609
610 batadv_tt_local_entry_free_ref(tt_local);
611 batadv_softif_vlan_free_ref(vlan);
612 goto out;
613 }
614
615add_event:
616 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
617
618check_roaming:
619
620
621
622 if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {
623
624 head = &tt_global->orig_list;
625 rcu_read_lock();
626 hlist_for_each_entry_rcu(orig_entry, head, list) {
627 batadv_send_roam_adv(bat_priv, tt_global->common.addr,
628 tt_global->common.vid,
629 orig_entry->orig_node);
630 }
631 rcu_read_unlock();
632 if (roamed_back) {
633 batadv_tt_global_free(bat_priv, tt_global,
634 "Roaming canceled");
635 tt_global = NULL;
636 } else {
637
638
639
640 tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;
641 tt_global->roam_at = jiffies;
642 }
643 }
644
645
646
647
648 remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;
649
650 if (batadv_is_wifi_netdev(in_dev))
651 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
652 else
653 tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;
654
655
656
657
658
659 match_mark = (mark & bat_priv->isolation_mark_mask);
660 if (bat_priv->isolation_mark_mask &&
661 match_mark == bat_priv->isolation_mark)
662 tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;
663 else
664 tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;
665
666
667
668
669 if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))
670 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
671
672 ret = true;
673out:
674 if (in_dev)
675 dev_put(in_dev);
676 if (tt_local)
677 batadv_tt_local_entry_free_ref(tt_local);
678 if (tt_global)
679 batadv_tt_global_entry_free_ref(tt_global);
680 return ret;
681}
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701static uint16_t
702batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,
703 struct batadv_tvlv_tt_data **tt_data,
704 struct batadv_tvlv_tt_change **tt_change,
705 int32_t *tt_len)
706{
707 uint16_t num_vlan = 0, num_entries = 0, change_offset, tvlv_len;
708 struct batadv_tvlv_tt_vlan_data *tt_vlan;
709 struct batadv_orig_node_vlan *vlan;
710 uint8_t *tt_change_ptr;
711
712 rcu_read_lock();
713 list_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
714 num_vlan++;
715 num_entries += atomic_read(&vlan->tt.num_entries);
716 }
717
718 change_offset = sizeof(**tt_data);
719 change_offset += num_vlan * sizeof(*tt_vlan);
720
721
722 if (*tt_len < 0)
723 *tt_len = batadv_tt_len(num_entries);
724
725 tvlv_len = *tt_len;
726 tvlv_len += change_offset;
727
728 *tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
729 if (!*tt_data) {
730 *tt_len = 0;
731 goto out;
732 }
733
734 (*tt_data)->flags = BATADV_NO_FLAGS;
735 (*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);
736 (*tt_data)->num_vlan = htons(num_vlan);
737
738 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
739 list_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
740 tt_vlan->vid = htons(vlan->vid);
741 tt_vlan->crc = htonl(vlan->tt.crc);
742
743 tt_vlan++;
744 }
745
746 tt_change_ptr = (uint8_t *)*tt_data + change_offset;
747 *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
748
749out:
750 rcu_read_unlock();
751 return tvlv_len;
752}
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772static uint16_t
773batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,
774 struct batadv_tvlv_tt_data **tt_data,
775 struct batadv_tvlv_tt_change **tt_change,
776 int32_t *tt_len)
777{
778 struct batadv_tvlv_tt_vlan_data *tt_vlan;
779 struct batadv_softif_vlan *vlan;
780 uint16_t num_vlan = 0, num_entries = 0, tvlv_len;
781 uint8_t *tt_change_ptr;
782 int change_offset;
783
784 rcu_read_lock();
785 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
786 num_vlan++;
787 num_entries += atomic_read(&vlan->tt.num_entries);
788 }
789
790 change_offset = sizeof(**tt_data);
791 change_offset += num_vlan * sizeof(*tt_vlan);
792
793
794 if (*tt_len < 0)
795 *tt_len = batadv_tt_len(num_entries);
796
797 tvlv_len = *tt_len;
798 tvlv_len += change_offset;
799
800 *tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
801 if (!*tt_data) {
802 tvlv_len = 0;
803 goto out;
804 }
805
806 (*tt_data)->flags = BATADV_NO_FLAGS;
807 (*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);
808 (*tt_data)->num_vlan = htons(num_vlan);
809
810 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
811 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
812 tt_vlan->vid = htons(vlan->vid);
813 tt_vlan->crc = htonl(vlan->tt.crc);
814
815 tt_vlan++;
816 }
817
818 tt_change_ptr = (uint8_t *)*tt_data + change_offset;
819 *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
820
821out:
822 rcu_read_unlock();
823 return tvlv_len;
824}
825
826
827
828
829
830
831static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)
832{
833 struct batadv_tt_change_node *entry, *safe;
834 struct batadv_tvlv_tt_data *tt_data;
835 struct batadv_tvlv_tt_change *tt_change;
836 int tt_diff_len, tt_change_len = 0;
837 int tt_diff_entries_num = 0, tt_diff_entries_count = 0;
838 uint16_t tvlv_len;
839
840 tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
841 tt_diff_len = batadv_tt_len(tt_diff_entries_num);
842
843
844
845
846 if (tt_diff_len > bat_priv->soft_iface->mtu)
847 tt_diff_len = 0;
848
849 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
850 &tt_change, &tt_diff_len);
851 if (!tvlv_len)
852 return;
853
854 tt_data->flags = BATADV_TT_OGM_DIFF;
855
856 if (tt_diff_len == 0)
857 goto container_register;
858
859 spin_lock_bh(&bat_priv->tt.changes_list_lock);
860 atomic_set(&bat_priv->tt.local_changes, 0);
861
862 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
863 list) {
864 if (tt_diff_entries_count < tt_diff_entries_num) {
865 memcpy(tt_change + tt_diff_entries_count,
866 &entry->change,
867 sizeof(struct batadv_tvlv_tt_change));
868 tt_diff_entries_count++;
869 }
870 list_del(&entry->list);
871 kfree(entry);
872 }
873 spin_unlock_bh(&bat_priv->tt.changes_list_lock);
874
875
876 spin_lock_bh(&bat_priv->tt.last_changeset_lock);
877 kfree(bat_priv->tt.last_changeset);
878 bat_priv->tt.last_changeset_len = 0;
879 bat_priv->tt.last_changeset = NULL;
880 tt_change_len = batadv_tt_len(tt_diff_entries_count);
881
882 if (tt_diff_entries_count > 0) {
883
884
885
886 bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);
887 if (bat_priv->tt.last_changeset) {
888 memcpy(bat_priv->tt.last_changeset,
889 tt_change, tt_change_len);
890 bat_priv->tt.last_changeset_len = tt_diff_len;
891 }
892 }
893 spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
894
895container_register:
896 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,
897 tvlv_len);
898 kfree(tt_data);
899}
900
901int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
902{
903 struct net_device *net_dev = (struct net_device *)seq->private;
904 struct batadv_priv *bat_priv = netdev_priv(net_dev);
905 struct batadv_hashtable *hash = bat_priv->tt.local_hash;
906 struct batadv_tt_common_entry *tt_common_entry;
907 struct batadv_tt_local_entry *tt_local;
908 struct batadv_hard_iface *primary_if;
909 struct batadv_softif_vlan *vlan;
910 struct hlist_head *head;
911 unsigned short vid;
912 uint32_t i;
913 int last_seen_secs;
914 int last_seen_msecs;
915 unsigned long last_seen_jiffies;
916 bool no_purge;
917 uint16_t np_flag = BATADV_TT_CLIENT_NOPURGE;
918
919 primary_if = batadv_seq_print_text_primary_if_get(seq);
920 if (!primary_if)
921 goto out;
922
923 seq_printf(seq,
924 "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
925 net_dev->name, (uint8_t)atomic_read(&bat_priv->tt.vn));
926 seq_printf(seq, " %-13s %s %-8s %-9s (%-10s)\n", "Client", "VID",
927 "Flags", "Last seen", "CRC");
928
929 for (i = 0; i < hash->size; i++) {
930 head = &hash->table[i];
931
932 rcu_read_lock();
933 hlist_for_each_entry_rcu(tt_common_entry,
934 head, hash_entry) {
935 tt_local = container_of(tt_common_entry,
936 struct batadv_tt_local_entry,
937 common);
938 vid = tt_common_entry->vid;
939 last_seen_jiffies = jiffies - tt_local->last_seen;
940 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
941 last_seen_secs = last_seen_msecs / 1000;
942 last_seen_msecs = last_seen_msecs % 1000;
943
944 no_purge = tt_common_entry->flags & np_flag;
945
946 vlan = batadv_softif_vlan_get(bat_priv, vid);
947 if (!vlan) {
948 seq_printf(seq, "Cannot retrieve VLAN %d\n",
949 BATADV_PRINT_VID(vid));
950 continue;
951 }
952
953 seq_printf(seq,
954 " * %pM %4i [%c%c%c%c%c%c] %3u.%03u (%#.8x)\n",
955 tt_common_entry->addr,
956 BATADV_PRINT_VID(tt_common_entry->vid),
957 (tt_common_entry->flags &
958 BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
959 no_purge ? 'P' : '.',
960 (tt_common_entry->flags &
961 BATADV_TT_CLIENT_NEW ? 'N' : '.'),
962 (tt_common_entry->flags &
963 BATADV_TT_CLIENT_PENDING ? 'X' : '.'),
964 (tt_common_entry->flags &
965 BATADV_TT_CLIENT_WIFI ? 'W' : '.'),
966 (tt_common_entry->flags &
967 BATADV_TT_CLIENT_ISOLA ? 'I' : '.'),
968 no_purge ? 0 : last_seen_secs,
969 no_purge ? 0 : last_seen_msecs,
970 vlan->tt.crc);
971
972 batadv_softif_vlan_free_ref(vlan);
973 }
974 rcu_read_unlock();
975 }
976out:
977 if (primary_if)
978 batadv_hardif_free_ref(primary_if);
979 return 0;
980}
981
982static void
983batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
984 struct batadv_tt_local_entry *tt_local_entry,
985 uint16_t flags, const char *message)
986{
987 batadv_tt_local_event(bat_priv, tt_local_entry, flags);
988
989
990
991
992
993 tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
994
995 batadv_dbg(BATADV_DBG_TT, bat_priv,
996 "Local tt entry (%pM, vid: %d) pending to be removed: %s\n",
997 tt_local_entry->common.addr,
998 BATADV_PRINT_VID(tt_local_entry->common.vid), message);
999}
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011uint16_t batadv_tt_local_remove(struct batadv_priv *bat_priv,
1012 const uint8_t *addr, unsigned short vid,
1013 const char *message, bool roaming)
1014{
1015 struct batadv_tt_local_entry *tt_local_entry;
1016 uint16_t flags, curr_flags = BATADV_NO_FLAGS;
1017 struct batadv_softif_vlan *vlan;
1018
1019 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
1020 if (!tt_local_entry)
1021 goto out;
1022
1023 curr_flags = tt_local_entry->common.flags;
1024
1025 flags = BATADV_TT_CLIENT_DEL;
1026
1027
1028
1029
1030 if (roaming) {
1031 flags |= BATADV_TT_CLIENT_ROAM;
1032
1033 tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1034 }
1035
1036 if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {
1037 batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,
1038 message);
1039 goto out;
1040 }
1041
1042
1043
1044 batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
1045 hlist_del_rcu(&tt_local_entry->common.hash_entry);
1046 batadv_tt_local_entry_free_ref(tt_local_entry);
1047
1048
1049 vlan = batadv_softif_vlan_get(bat_priv, vid);
1050 batadv_softif_vlan_free_ref(vlan);
1051 batadv_softif_vlan_free_ref(vlan);
1052
1053out:
1054 if (tt_local_entry)
1055 batadv_tt_local_entry_free_ref(tt_local_entry);
1056
1057 return curr_flags;
1058}
1059
1060
1061
1062
1063
1064
1065
1066
1067static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
1068 struct hlist_head *head,
1069 int timeout)
1070{
1071 struct batadv_tt_local_entry *tt_local_entry;
1072 struct batadv_tt_common_entry *tt_common_entry;
1073 struct hlist_node *node_tmp;
1074
1075 hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
1076 hash_entry) {
1077 tt_local_entry = container_of(tt_common_entry,
1078 struct batadv_tt_local_entry,
1079 common);
1080 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
1081 continue;
1082
1083
1084 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
1085 continue;
1086
1087 if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))
1088 continue;
1089
1090 batadv_tt_local_set_pending(bat_priv, tt_local_entry,
1091 BATADV_TT_CLIENT_DEL, "timed out");
1092 }
1093}
1094
1095
1096
1097
1098
1099
1100
1101static void batadv_tt_local_purge(struct batadv_priv *bat_priv,
1102 int timeout)
1103{
1104 struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1105 struct hlist_head *head;
1106 spinlock_t *list_lock;
1107 uint32_t i;
1108
1109 for (i = 0; i < hash->size; i++) {
1110 head = &hash->table[i];
1111 list_lock = &hash->list_locks[i];
1112
1113 spin_lock_bh(list_lock);
1114 batadv_tt_local_purge_list(bat_priv, head, timeout);
1115 spin_unlock_bh(list_lock);
1116 }
1117}
1118
1119static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
1120{
1121 struct batadv_hashtable *hash;
1122 spinlock_t *list_lock;
1123 struct batadv_tt_common_entry *tt_common_entry;
1124 struct batadv_tt_local_entry *tt_local;
1125 struct batadv_softif_vlan *vlan;
1126 struct hlist_node *node_tmp;
1127 struct hlist_head *head;
1128 uint32_t i;
1129
1130 if (!bat_priv->tt.local_hash)
1131 return;
1132
1133 hash = bat_priv->tt.local_hash;
1134
1135 for (i = 0; i < hash->size; i++) {
1136 head = &hash->table[i];
1137 list_lock = &hash->list_locks[i];
1138
1139 spin_lock_bh(list_lock);
1140 hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1141 head, hash_entry) {
1142 hlist_del_rcu(&tt_common_entry->hash_entry);
1143 tt_local = container_of(tt_common_entry,
1144 struct batadv_tt_local_entry,
1145 common);
1146
1147
1148 vlan = batadv_softif_vlan_get(bat_priv,
1149 tt_common_entry->vid);
1150 batadv_softif_vlan_free_ref(vlan);
1151 batadv_softif_vlan_free_ref(vlan);
1152
1153 batadv_tt_local_entry_free_ref(tt_local);
1154 }
1155 spin_unlock_bh(list_lock);
1156 }
1157
1158 batadv_hash_destroy(hash);
1159
1160 bat_priv->tt.local_hash = NULL;
1161}
1162
1163static int batadv_tt_global_init(struct batadv_priv *bat_priv)
1164{
1165 if (bat_priv->tt.global_hash)
1166 return 0;
1167
1168 bat_priv->tt.global_hash = batadv_hash_new(1024);
1169
1170 if (!bat_priv->tt.global_hash)
1171 return -ENOMEM;
1172
1173 batadv_hash_set_lock_class(bat_priv->tt.global_hash,
1174 &batadv_tt_global_hash_lock_class_key);
1175
1176 return 0;
1177}
1178
1179static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
1180{
1181 struct batadv_tt_change_node *entry, *safe;
1182
1183 spin_lock_bh(&bat_priv->tt.changes_list_lock);
1184
1185 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1186 list) {
1187 list_del(&entry->list);
1188 kfree(entry);
1189 }
1190
1191 atomic_set(&bat_priv->tt.local_changes, 0);
1192 spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1193}
1194
1195
1196
1197
1198
1199
1200static struct batadv_tt_orig_list_entry *
1201batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
1202 const struct batadv_orig_node *orig_node)
1203{
1204 struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
1205 const struct hlist_head *head;
1206
1207 rcu_read_lock();
1208 head = &entry->orig_list;
1209 hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
1210 if (tmp_orig_entry->orig_node != orig_node)
1211 continue;
1212 if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))
1213 continue;
1214
1215 orig_entry = tmp_orig_entry;
1216 break;
1217 }
1218 rcu_read_unlock();
1219
1220 return orig_entry;
1221}
1222
1223
1224
1225
1226static bool
1227batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
1228 const struct batadv_orig_node *orig_node)
1229{
1230 struct batadv_tt_orig_list_entry *orig_entry;
1231 bool found = false;
1232
1233 orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);
1234 if (orig_entry) {
1235 found = true;
1236 batadv_tt_orig_list_entry_free_ref(orig_entry);
1237 }
1238
1239 return found;
1240}
1241
1242static void
1243batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
1244 struct batadv_orig_node *orig_node, int ttvn)
1245{
1246 struct batadv_tt_orig_list_entry *orig_entry;
1247
1248 orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);
1249 if (orig_entry) {
1250
1251
1252
1253 orig_entry->ttvn = ttvn;
1254 goto out;
1255 }
1256
1257 orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
1258 if (!orig_entry)
1259 goto out;
1260
1261 INIT_HLIST_NODE(&orig_entry->list);
1262 atomic_inc(&orig_node->refcount);
1263 batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
1264 orig_entry->orig_node = orig_node;
1265 orig_entry->ttvn = ttvn;
1266 atomic_set(&orig_entry->refcount, 2);
1267
1268 spin_lock_bh(&tt_global->list_lock);
1269 hlist_add_head_rcu(&orig_entry->list,
1270 &tt_global->orig_list);
1271 spin_unlock_bh(&tt_global->list_lock);
1272 atomic_inc(&tt_global->orig_list_count);
1273
1274out:
1275 if (orig_entry)
1276 batadv_tt_orig_list_entry_free_ref(orig_entry);
1277}
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
1299 struct batadv_orig_node *orig_node,
1300 const unsigned char *tt_addr,
1301 unsigned short vid, uint16_t flags,
1302 uint8_t ttvn)
1303{
1304 struct batadv_tt_global_entry *tt_global_entry;
1305 struct batadv_tt_local_entry *tt_local_entry;
1306 bool ret = false;
1307 int hash_added;
1308 struct batadv_tt_common_entry *common;
1309 uint16_t local_flags;
1310
1311
1312 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
1313 return true;
1314
1315 tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);
1316 tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);
1317
1318
1319
1320
1321
1322 if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&
1323 !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))
1324 goto out;
1325
1326 if (!tt_global_entry) {
1327 tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);
1328 if (!tt_global_entry)
1329 goto out;
1330
1331 common = &tt_global_entry->common;
1332 ether_addr_copy(common->addr, tt_addr);
1333 common->vid = vid;
1334
1335 common->flags = flags;
1336 tt_global_entry->roam_at = 0;
1337
1338
1339
1340
1341 if (flags & BATADV_TT_CLIENT_ROAM)
1342 tt_global_entry->roam_at = jiffies;
1343 atomic_set(&common->refcount, 2);
1344 common->added_at = jiffies;
1345
1346 INIT_HLIST_HEAD(&tt_global_entry->orig_list);
1347 atomic_set(&tt_global_entry->orig_list_count, 0);
1348 spin_lock_init(&tt_global_entry->list_lock);
1349
1350 hash_added = batadv_hash_add(bat_priv->tt.global_hash,
1351 batadv_compare_tt,
1352 batadv_choose_tt, common,
1353 &common->hash_entry);
1354
1355 if (unlikely(hash_added != 0)) {
1356
1357 batadv_tt_global_entry_free_ref(tt_global_entry);
1358 goto out_remove;
1359 }
1360 } else {
1361 common = &tt_global_entry->common;
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372 if (flags & BATADV_TT_CLIENT_TEMP) {
1373 if (!(common->flags & BATADV_TT_CLIENT_TEMP))
1374 goto out;
1375 if (batadv_tt_global_entry_has_orig(tt_global_entry,
1376 orig_node))
1377 goto out_remove;
1378 batadv_tt_global_del_orig_list(tt_global_entry);
1379 goto add_orig_entry;
1380 }
1381
1382
1383
1384
1385 common->flags &= ~BATADV_TT_CLIENT_TEMP;
1386
1387
1388
1389
1390
1391 tt_global_entry->common.flags |= flags;
1392
1393
1394
1395
1396
1397
1398
1399
1400 if (common->flags & BATADV_TT_CLIENT_ROAM) {
1401 batadv_tt_global_del_orig_list(tt_global_entry);
1402 common->flags &= ~BATADV_TT_CLIENT_ROAM;
1403 tt_global_entry->roam_at = 0;
1404 }
1405 }
1406add_orig_entry:
1407
1408 batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);
1409
1410 batadv_dbg(BATADV_DBG_TT, bat_priv,
1411 "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
1412 common->addr, BATADV_PRINT_VID(common->vid),
1413 orig_node->orig);
1414 ret = true;
1415
1416out_remove:
1417
1418
1419
1420 if (is_multicast_ether_addr(tt_addr))
1421 goto out;
1422
1423
1424 local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,
1425 "global tt received",
1426 flags & BATADV_TT_CLIENT_ROAM);
1427 tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;
1428
1429 if (!(flags & BATADV_TT_CLIENT_ROAM))
1430
1431
1432
1433 tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
1434
1435out:
1436 if (tt_global_entry)
1437 batadv_tt_global_entry_free_ref(tt_global_entry);
1438 if (tt_local_entry)
1439 batadv_tt_local_entry_free_ref(tt_local_entry);
1440 return ret;
1441}
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451static struct batadv_tt_orig_list_entry *
1452batadv_transtable_best_orig(struct batadv_priv *bat_priv,
1453 struct batadv_tt_global_entry *tt_global_entry)
1454{
1455 struct batadv_neigh_node *router, *best_router = NULL;
1456 struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
1457 struct hlist_head *head;
1458 struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;
1459
1460 head = &tt_global_entry->orig_list;
1461 hlist_for_each_entry_rcu(orig_entry, head, list) {
1462 router = batadv_orig_router_get(orig_entry->orig_node,
1463 BATADV_IF_DEFAULT);
1464 if (!router)
1465 continue;
1466
1467 if (best_router &&
1468 bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT,
1469 best_router, BATADV_IF_DEFAULT) <= 0) {
1470 batadv_neigh_node_free_ref(router);
1471 continue;
1472 }
1473
1474
1475 if (best_router)
1476 batadv_neigh_node_free_ref(best_router);
1477
1478 best_entry = orig_entry;
1479 best_router = router;
1480 }
1481
1482 if (best_router)
1483 batadv_neigh_node_free_ref(best_router);
1484
1485 return best_entry;
1486}
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497static void
1498batadv_tt_global_print_entry(struct batadv_priv *bat_priv,
1499 struct batadv_tt_global_entry *tt_global_entry,
1500 struct seq_file *seq)
1501{
1502 struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
1503 struct batadv_tt_common_entry *tt_common_entry;
1504 struct batadv_orig_node_vlan *vlan;
1505 struct hlist_head *head;
1506 uint8_t last_ttvn;
1507 uint16_t flags;
1508
1509 tt_common_entry = &tt_global_entry->common;
1510 flags = tt_common_entry->flags;
1511
1512 best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
1513 if (best_entry) {
1514 vlan = batadv_orig_node_vlan_get(best_entry->orig_node,
1515 tt_common_entry->vid);
1516 if (!vlan) {
1517 seq_printf(seq,
1518 " * Cannot retrieve VLAN %d for originator %pM\n",
1519 BATADV_PRINT_VID(tt_common_entry->vid),
1520 best_entry->orig_node->orig);
1521 goto print_list;
1522 }
1523
1524 last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);
1525 seq_printf(seq,
1526 " %c %pM %4i (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n",
1527 '*', tt_global_entry->common.addr,
1528 BATADV_PRINT_VID(tt_global_entry->common.vid),
1529 best_entry->ttvn, best_entry->orig_node->orig,
1530 last_ttvn, vlan->tt.crc,
1531 (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
1532 (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'),
1533 (flags & BATADV_TT_CLIENT_ISOLA ? 'I' : '.'),
1534 (flags & BATADV_TT_CLIENT_TEMP ? 'T' : '.'));
1535
1536 batadv_orig_node_vlan_free_ref(vlan);
1537 }
1538
1539print_list:
1540 head = &tt_global_entry->orig_list;
1541
1542 hlist_for_each_entry_rcu(orig_entry, head, list) {
1543 if (best_entry == orig_entry)
1544 continue;
1545
1546 vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,
1547 tt_common_entry->vid);
1548 if (!vlan) {
1549 seq_printf(seq,
1550 " + Cannot retrieve VLAN %d for originator %pM\n",
1551 BATADV_PRINT_VID(tt_common_entry->vid),
1552 orig_entry->orig_node->orig);
1553 continue;
1554 }
1555
1556 last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);
1557 seq_printf(seq,
1558 " %c %pM %4d (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n",
1559 '+', tt_global_entry->common.addr,
1560 BATADV_PRINT_VID(tt_global_entry->common.vid),
1561 orig_entry->ttvn, orig_entry->orig_node->orig,
1562 last_ttvn, vlan->tt.crc,
1563 (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
1564 (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'),
1565 (flags & BATADV_TT_CLIENT_ISOLA ? 'I' : '.'),
1566 (flags & BATADV_TT_CLIENT_TEMP ? 'T' : '.'));
1567
1568 batadv_orig_node_vlan_free_ref(vlan);
1569 }
1570}
1571
1572int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
1573{
1574 struct net_device *net_dev = (struct net_device *)seq->private;
1575 struct batadv_priv *bat_priv = netdev_priv(net_dev);
1576 struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1577 struct batadv_tt_common_entry *tt_common_entry;
1578 struct batadv_tt_global_entry *tt_global;
1579 struct batadv_hard_iface *primary_if;
1580 struct hlist_head *head;
1581 uint32_t i;
1582
1583 primary_if = batadv_seq_print_text_primary_if_get(seq);
1584 if (!primary_if)
1585 goto out;
1586
1587 seq_printf(seq,
1588 "Globally announced TT entries received via the mesh %s\n",
1589 net_dev->name);
1590 seq_printf(seq, " %-13s %s %s %-15s %s (%-10s) %s\n",
1591 "Client", "VID", "(TTVN)", "Originator", "(Curr TTVN)",
1592 "CRC", "Flags");
1593
1594 for (i = 0; i < hash->size; i++) {
1595 head = &hash->table[i];
1596
1597 rcu_read_lock();
1598 hlist_for_each_entry_rcu(tt_common_entry,
1599 head, hash_entry) {
1600 tt_global = container_of(tt_common_entry,
1601 struct batadv_tt_global_entry,
1602 common);
1603 batadv_tt_global_print_entry(bat_priv, tt_global, seq);
1604 }
1605 rcu_read_unlock();
1606 }
1607out:
1608 if (primary_if)
1609 batadv_hardif_free_ref(primary_if);
1610 return 0;
1611}
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621static void
1622batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
1623 struct batadv_tt_orig_list_entry *orig_entry)
1624{
1625 batadv_tt_global_size_dec(orig_entry->orig_node,
1626 tt_global_entry->common.vid);
1627 atomic_dec(&tt_global_entry->orig_list_count);
1628 hlist_del_rcu(&orig_entry->list);
1629 batadv_tt_orig_list_entry_free_ref(orig_entry);
1630}
1631
1632
1633static void
1634batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
1635{
1636 struct hlist_head *head;
1637 struct hlist_node *safe;
1638 struct batadv_tt_orig_list_entry *orig_entry;
1639
1640 spin_lock_bh(&tt_global_entry->list_lock);
1641 head = &tt_global_entry->orig_list;
1642 hlist_for_each_entry_safe(orig_entry, safe, head, list)
1643 batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);
1644 spin_unlock_bh(&tt_global_entry->list_lock);
1645}
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657static void
1658batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,
1659 struct batadv_tt_global_entry *tt_global_entry,
1660 struct batadv_orig_node *orig_node,
1661 const char *message)
1662{
1663 struct hlist_head *head;
1664 struct hlist_node *safe;
1665 struct batadv_tt_orig_list_entry *orig_entry;
1666 unsigned short vid;
1667
1668 spin_lock_bh(&tt_global_entry->list_lock);
1669 head = &tt_global_entry->orig_list;
1670 hlist_for_each_entry_safe(orig_entry, safe, head, list) {
1671 if (orig_entry->orig_node == orig_node) {
1672 vid = tt_global_entry->common.vid;
1673 batadv_dbg(BATADV_DBG_TT, bat_priv,
1674 "Deleting %pM from global tt entry %pM (vid: %d): %s\n",
1675 orig_node->orig,
1676 tt_global_entry->common.addr,
1677 BATADV_PRINT_VID(vid), message);
1678 batadv_tt_global_del_orig_entry(tt_global_entry,
1679 orig_entry);
1680 }
1681 }
1682 spin_unlock_bh(&tt_global_entry->list_lock);
1683}
1684
1685
1686
1687
1688
1689static void
1690batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
1691 struct batadv_tt_global_entry *tt_global_entry,
1692 struct batadv_orig_node *orig_node,
1693 const char *message)
1694{
1695 bool last_entry = true;
1696 struct hlist_head *head;
1697 struct batadv_tt_orig_list_entry *orig_entry;
1698
1699
1700
1701
1702
1703 rcu_read_lock();
1704 head = &tt_global_entry->orig_list;
1705 hlist_for_each_entry_rcu(orig_entry, head, list) {
1706 if (orig_entry->orig_node != orig_node) {
1707 last_entry = false;
1708 break;
1709 }
1710 }
1711 rcu_read_unlock();
1712
1713 if (last_entry) {
1714
1715 tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1716 tt_global_entry->roam_at = jiffies;
1717 } else
1718
1719
1720
1721 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
1722 orig_node, message);
1723}
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735static void batadv_tt_global_del(struct batadv_priv *bat_priv,
1736 struct batadv_orig_node *orig_node,
1737 const unsigned char *addr, unsigned short vid,
1738 const char *message, bool roaming)
1739{
1740 struct batadv_tt_global_entry *tt_global_entry;
1741 struct batadv_tt_local_entry *local_entry = NULL;
1742
1743 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
1744 if (!tt_global_entry)
1745 goto out;
1746
1747 if (!roaming) {
1748 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
1749 orig_node, message);
1750
1751 if (hlist_empty(&tt_global_entry->orig_list))
1752 batadv_tt_global_free(bat_priv, tt_global_entry,
1753 message);
1754
1755 goto out;
1756 }
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771 local_entry = batadv_tt_local_hash_find(bat_priv,
1772 tt_global_entry->common.addr,
1773 vid);
1774 if (local_entry) {
1775
1776 batadv_tt_global_del_orig_list(tt_global_entry);
1777 batadv_tt_global_free(bat_priv, tt_global_entry, message);
1778 } else
1779
1780 batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
1781 orig_node, message);
1782
1783out:
1784 if (tt_global_entry)
1785 batadv_tt_global_entry_free_ref(tt_global_entry);
1786 if (local_entry)
1787 batadv_tt_local_entry_free_ref(local_entry);
1788}
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
1800 struct batadv_orig_node *orig_node,
1801 int32_t match_vid,
1802 const char *message)
1803{
1804 struct batadv_tt_global_entry *tt_global;
1805 struct batadv_tt_common_entry *tt_common_entry;
1806 uint32_t i;
1807 struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1808 struct hlist_node *safe;
1809 struct hlist_head *head;
1810 spinlock_t *list_lock;
1811 unsigned short vid;
1812
1813 if (!hash)
1814 return;
1815
1816 for (i = 0; i < hash->size; i++) {
1817 head = &hash->table[i];
1818 list_lock = &hash->list_locks[i];
1819
1820 spin_lock_bh(list_lock);
1821 hlist_for_each_entry_safe(tt_common_entry, safe,
1822 head, hash_entry) {
1823
1824 if (match_vid >= 0 && tt_common_entry->vid != match_vid)
1825 continue;
1826
1827 tt_global = container_of(tt_common_entry,
1828 struct batadv_tt_global_entry,
1829 common);
1830
1831 batadv_tt_global_del_orig_node(bat_priv, tt_global,
1832 orig_node, message);
1833
1834 if (hlist_empty(&tt_global->orig_list)) {
1835 vid = tt_global->common.vid;
1836 batadv_dbg(BATADV_DBG_TT, bat_priv,
1837 "Deleting global tt entry %pM (vid: %d): %s\n",
1838 tt_global->common.addr,
1839 BATADV_PRINT_VID(vid), message);
1840 hlist_del_rcu(&tt_common_entry->hash_entry);
1841 batadv_tt_global_entry_free_ref(tt_global);
1842 }
1843 }
1844 spin_unlock_bh(list_lock);
1845 }
1846 orig_node->capa_initialized &= ~BATADV_ORIG_CAPA_HAS_TT;
1847}
1848
1849static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
1850 char **msg)
1851{
1852 bool purge = false;
1853 unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
1854 unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;
1855
1856 if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&
1857 batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {
1858 purge = true;
1859 *msg = "Roaming timeout\n";
1860 }
1861
1862 if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&
1863 batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {
1864 purge = true;
1865 *msg = "Temporary client timeout\n";
1866 }
1867
1868 return purge;
1869}
1870
1871static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
1872{
1873 struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1874 struct hlist_head *head;
1875 struct hlist_node *node_tmp;
1876 spinlock_t *list_lock;
1877 uint32_t i;
1878 char *msg = NULL;
1879 struct batadv_tt_common_entry *tt_common;
1880 struct batadv_tt_global_entry *tt_global;
1881
1882 for (i = 0; i < hash->size; i++) {
1883 head = &hash->table[i];
1884 list_lock = &hash->list_locks[i];
1885
1886 spin_lock_bh(list_lock);
1887 hlist_for_each_entry_safe(tt_common, node_tmp, head,
1888 hash_entry) {
1889 tt_global = container_of(tt_common,
1890 struct batadv_tt_global_entry,
1891 common);
1892
1893 if (!batadv_tt_global_to_purge(tt_global, &msg))
1894 continue;
1895
1896 batadv_dbg(BATADV_DBG_TT, bat_priv,
1897 "Deleting global tt entry %pM (vid: %d): %s\n",
1898 tt_global->common.addr,
1899 BATADV_PRINT_VID(tt_global->common.vid),
1900 msg);
1901
1902 hlist_del_rcu(&tt_common->hash_entry);
1903
1904 batadv_tt_global_entry_free_ref(tt_global);
1905 }
1906 spin_unlock_bh(list_lock);
1907 }
1908}
1909
1910static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
1911{
1912 struct batadv_hashtable *hash;
1913 spinlock_t *list_lock;
1914 struct batadv_tt_common_entry *tt_common_entry;
1915 struct batadv_tt_global_entry *tt_global;
1916 struct hlist_node *node_tmp;
1917 struct hlist_head *head;
1918 uint32_t i;
1919
1920 if (!bat_priv->tt.global_hash)
1921 return;
1922
1923 hash = bat_priv->tt.global_hash;
1924
1925 for (i = 0; i < hash->size; i++) {
1926 head = &hash->table[i];
1927 list_lock = &hash->list_locks[i];
1928
1929 spin_lock_bh(list_lock);
1930 hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1931 head, hash_entry) {
1932 hlist_del_rcu(&tt_common_entry->hash_entry);
1933 tt_global = container_of(tt_common_entry,
1934 struct batadv_tt_global_entry,
1935 common);
1936 batadv_tt_global_entry_free_ref(tt_global);
1937 }
1938 spin_unlock_bh(list_lock);
1939 }
1940
1941 batadv_hash_destroy(hash);
1942
1943 bat_priv->tt.global_hash = NULL;
1944}
1945
1946static bool
1947_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
1948 struct batadv_tt_global_entry *tt_global_entry)
1949{
1950 bool ret = false;
1951
1952 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
1953 tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
1954 ret = true;
1955
1956
1957 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&
1958 tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)
1959 ret = true;
1960
1961 return ret;
1962}
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
1979 const uint8_t *src,
1980 const uint8_t *addr,
1981 unsigned short vid)
1982{
1983 struct batadv_tt_local_entry *tt_local_entry = NULL;
1984 struct batadv_tt_global_entry *tt_global_entry = NULL;
1985 struct batadv_orig_node *orig_node = NULL;
1986 struct batadv_tt_orig_list_entry *best_entry;
1987
1988 if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {
1989 tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);
1990 if (!tt_local_entry ||
1991 (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))
1992 goto out;
1993 }
1994
1995 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
1996 if (!tt_global_entry)
1997 goto out;
1998
1999
2000
2001
2002 if (tt_local_entry &&
2003 _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
2004 goto out;
2005
2006 rcu_read_lock();
2007 best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
2008
2009 if (best_entry)
2010 orig_node = best_entry->orig_node;
2011 if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))
2012 orig_node = NULL;
2013 rcu_read_unlock();
2014
2015out:
2016 if (tt_global_entry)
2017 batadv_tt_global_entry_free_ref(tt_global_entry);
2018 if (tt_local_entry)
2019 batadv_tt_local_entry_free_ref(tt_local_entry);
2020
2021 return orig_node;
2022}
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048static uint32_t batadv_tt_global_crc(struct batadv_priv *bat_priv,
2049 struct batadv_orig_node *orig_node,
2050 unsigned short vid)
2051{
2052 struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2053 struct batadv_tt_common_entry *tt_common;
2054 struct batadv_tt_global_entry *tt_global;
2055 struct hlist_head *head;
2056 uint32_t i, crc_tmp, crc = 0;
2057 uint8_t flags;
2058 __be16 tmp_vid;
2059
2060 for (i = 0; i < hash->size; i++) {
2061 head = &hash->table[i];
2062
2063 rcu_read_lock();
2064 hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2065 tt_global = container_of(tt_common,
2066 struct batadv_tt_global_entry,
2067 common);
2068
2069
2070
2071 if (tt_common->vid != vid)
2072 continue;
2073
2074
2075
2076
2077
2078
2079 if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
2080 continue;
2081
2082
2083
2084
2085 if (tt_common->flags & BATADV_TT_CLIENT_TEMP)
2086 continue;
2087
2088
2089
2090
2091 if (!batadv_tt_global_entry_has_orig(tt_global,
2092 orig_node))
2093 continue;
2094
2095
2096
2097
2098 tmp_vid = htons(tt_common->vid);
2099 crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2100
2101
2102
2103
2104 flags = tt_common->flags & BATADV_TT_SYNC_MASK;
2105 crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2106
2107 crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2108 }
2109 rcu_read_unlock();
2110 }
2111
2112 return crc;
2113}
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125static uint32_t batadv_tt_local_crc(struct batadv_priv *bat_priv,
2126 unsigned short vid)
2127{
2128 struct batadv_hashtable *hash = bat_priv->tt.local_hash;
2129 struct batadv_tt_common_entry *tt_common;
2130 struct hlist_head *head;
2131 uint32_t i, crc_tmp, crc = 0;
2132 uint8_t flags;
2133 __be16 tmp_vid;
2134
2135 for (i = 0; i < hash->size; i++) {
2136 head = &hash->table[i];
2137
2138 rcu_read_lock();
2139 hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2140
2141
2142
2143 if (tt_common->vid != vid)
2144 continue;
2145
2146
2147
2148
2149 if (tt_common->flags & BATADV_TT_CLIENT_NEW)
2150 continue;
2151
2152
2153
2154
2155 tmp_vid = htons(tt_common->vid);
2156 crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2157
2158
2159
2160
2161 flags = tt_common->flags & BATADV_TT_SYNC_MASK;
2162 crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2163
2164 crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2165 }
2166 rcu_read_unlock();
2167 }
2168
2169 return crc;
2170}
2171
2172static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
2173{
2174 struct batadv_tt_req_node *node, *safe;
2175
2176 spin_lock_bh(&bat_priv->tt.req_list_lock);
2177
2178 list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2179 list_del(&node->list);
2180 kfree(node);
2181 }
2182
2183 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2184}
2185
2186static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
2187 struct batadv_orig_node *orig_node,
2188 const void *tt_buff,
2189 uint16_t tt_buff_len)
2190{
2191
2192
2193
2194 spin_lock_bh(&orig_node->tt_buff_lock);
2195 if (tt_buff_len > 0) {
2196 kfree(orig_node->tt_buff);
2197 orig_node->tt_buff_len = 0;
2198 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
2199 if (orig_node->tt_buff) {
2200 memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
2201 orig_node->tt_buff_len = tt_buff_len;
2202 }
2203 }
2204 spin_unlock_bh(&orig_node->tt_buff_lock);
2205}
2206
2207static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
2208{
2209 struct batadv_tt_req_node *node, *safe;
2210
2211 spin_lock_bh(&bat_priv->tt.req_list_lock);
2212 list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2213 if (batadv_has_timed_out(node->issued_at,
2214 BATADV_TT_REQUEST_TIMEOUT)) {
2215 list_del(&node->list);
2216 kfree(node);
2217 }
2218 }
2219 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2220}
2221
2222
2223
2224
2225static struct batadv_tt_req_node *
2226batadv_new_tt_req_node(struct batadv_priv *bat_priv,
2227 struct batadv_orig_node *orig_node)
2228{
2229 struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
2230
2231 spin_lock_bh(&bat_priv->tt.req_list_lock);
2232 list_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
2233 if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
2234 !batadv_has_timed_out(tt_req_node_tmp->issued_at,
2235 BATADV_TT_REQUEST_TIMEOUT))
2236 goto unlock;
2237 }
2238
2239 tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
2240 if (!tt_req_node)
2241 goto unlock;
2242
2243 ether_addr_copy(tt_req_node->addr, orig_node->orig);
2244 tt_req_node->issued_at = jiffies;
2245
2246 list_add(&tt_req_node->list, &bat_priv->tt.req_list);
2247unlock:
2248 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2249 return tt_req_node;
2250}
2251
2252
2253
2254
2255
2256
2257
2258
2259static int batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)
2260{
2261 const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2262
2263 if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
2264 return 0;
2265 return 1;
2266}
2267
2268static int batadv_tt_global_valid(const void *entry_ptr,
2269 const void *data_ptr)
2270{
2271 const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2272 const struct batadv_tt_global_entry *tt_global_entry;
2273 const struct batadv_orig_node *orig_node = data_ptr;
2274
2275 if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
2276 tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
2277 return 0;
2278
2279 tt_global_entry = container_of(tt_common_entry,
2280 struct batadv_tt_global_entry,
2281 common);
2282
2283 return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);
2284}
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
2297 struct batadv_hashtable *hash,
2298 void *tvlv_buff, uint16_t tt_len,
2299 int (*valid_cb)(const void *, const void *),
2300 void *cb_data)
2301{
2302 struct batadv_tt_common_entry *tt_common_entry;
2303 struct batadv_tvlv_tt_change *tt_change;
2304 struct hlist_head *head;
2305 uint16_t tt_tot, tt_num_entries = 0;
2306 uint32_t i;
2307
2308 tt_tot = batadv_tt_entries(tt_len);
2309 tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;
2310
2311 rcu_read_lock();
2312 for (i = 0; i < hash->size; i++) {
2313 head = &hash->table[i];
2314
2315 hlist_for_each_entry_rcu(tt_common_entry,
2316 head, hash_entry) {
2317 if (tt_tot == tt_num_entries)
2318 break;
2319
2320 if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
2321 continue;
2322
2323 ether_addr_copy(tt_change->addr, tt_common_entry->addr);
2324 tt_change->flags = tt_common_entry->flags;
2325 tt_change->vid = htons(tt_common_entry->vid);
2326 memset(tt_change->reserved, 0,
2327 sizeof(tt_change->reserved));
2328
2329 tt_num_entries++;
2330 tt_change++;
2331 }
2332 }
2333 rcu_read_unlock();
2334}
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,
2347 struct batadv_tvlv_tt_vlan_data *tt_vlan,
2348 uint16_t num_vlan)
2349{
2350 struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;
2351 struct batadv_orig_node_vlan *vlan;
2352 uint32_t crc;
2353 int i;
2354
2355
2356 for (i = 0; i < num_vlan; i++) {
2357 tt_vlan_tmp = tt_vlan + i;
2358
2359
2360
2361
2362 if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,
2363 orig_node->orig,
2364 ntohs(tt_vlan_tmp->vid)))
2365 continue;
2366
2367 vlan = batadv_orig_node_vlan_get(orig_node,
2368 ntohs(tt_vlan_tmp->vid));
2369 if (!vlan)
2370 return false;
2371
2372 crc = vlan->tt.crc;
2373 batadv_orig_node_vlan_free_ref(vlan);
2374
2375 if (crc != ntohl(tt_vlan_tmp->crc))
2376 return false;
2377 }
2378
2379 return true;
2380}
2381
2382
2383
2384
2385
2386static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)
2387{
2388 struct batadv_softif_vlan *vlan;
2389
2390
2391 rcu_read_lock();
2392 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
2393 vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);
2394 }
2395 rcu_read_unlock();
2396}
2397
2398
2399
2400
2401
2402
2403static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
2404 struct batadv_orig_node *orig_node)
2405{
2406 struct batadv_orig_node_vlan *vlan;
2407 uint32_t crc;
2408
2409
2410 rcu_read_lock();
2411 list_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
2412
2413
2414
2415 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
2416 vlan->vid))
2417 continue;
2418
2419 crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);
2420 vlan->tt.crc = crc;
2421 }
2422 rcu_read_unlock();
2423}
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435static int batadv_send_tt_request(struct batadv_priv *bat_priv,
2436 struct batadv_orig_node *dst_orig_node,
2437 uint8_t ttvn,
2438 struct batadv_tvlv_tt_vlan_data *tt_vlan,
2439 uint16_t num_vlan, bool full_table)
2440{
2441 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2442 struct batadv_tt_req_node *tt_req_node = NULL;
2443 struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
2444 struct batadv_hard_iface *primary_if;
2445 bool ret = false;
2446 int i, size;
2447
2448 primary_if = batadv_primary_if_get_selected(bat_priv);
2449 if (!primary_if)
2450 goto out;
2451
2452
2453
2454
2455 tt_req_node = batadv_new_tt_req_node(bat_priv, dst_orig_node);
2456 if (!tt_req_node)
2457 goto out;
2458
2459 size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
2460 tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
2461 if (!tvlv_tt_data)
2462 goto out;
2463
2464 tvlv_tt_data->flags = BATADV_TT_REQUEST;
2465 tvlv_tt_data->ttvn = ttvn;
2466 tvlv_tt_data->num_vlan = htons(num_vlan);
2467
2468
2469
2470
2471 tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);
2472 for (i = 0; i < num_vlan; i++) {
2473 tt_vlan_req->vid = tt_vlan->vid;
2474 tt_vlan_req->crc = tt_vlan->crc;
2475
2476 tt_vlan_req++;
2477 tt_vlan++;
2478 }
2479
2480 if (full_table)
2481 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2482
2483 batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",
2484 dst_orig_node->orig, full_table ? 'F' : '.');
2485
2486 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
2487 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2488 dst_orig_node->orig, BATADV_TVLV_TT, 1,
2489 tvlv_tt_data, size);
2490 ret = true;
2491
2492out:
2493 if (primary_if)
2494 batadv_hardif_free_ref(primary_if);
2495 if (ret && tt_req_node) {
2496 spin_lock_bh(&bat_priv->tt.req_list_lock);
2497 list_del(&tt_req_node->list);
2498 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2499 kfree(tt_req_node);
2500 }
2501 kfree(tvlv_tt_data);
2502 return ret;
2503}
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
2516 struct batadv_tvlv_tt_data *tt_data,
2517 uint8_t *req_src, uint8_t *req_dst)
2518{
2519 struct batadv_orig_node *req_dst_orig_node;
2520 struct batadv_orig_node *res_dst_orig_node = NULL;
2521 struct batadv_tvlv_tt_change *tt_change;
2522 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2523 struct batadv_tvlv_tt_vlan_data *tt_vlan;
2524 bool ret = false, full_table;
2525 uint8_t orig_ttvn, req_ttvn;
2526 uint16_t tvlv_len;
2527 int32_t tt_len;
2528
2529 batadv_dbg(BATADV_DBG_TT, bat_priv,
2530 "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
2531 req_src, tt_data->ttvn, req_dst,
2532 (tt_data->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
2533
2534
2535 req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
2536 if (!req_dst_orig_node)
2537 goto out;
2538
2539 res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
2540 if (!res_dst_orig_node)
2541 goto out;
2542
2543 orig_ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
2544 req_ttvn = tt_data->ttvn;
2545
2546 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
2547
2548 if (orig_ttvn != req_ttvn ||
2549 !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
2550 ntohs(tt_data->num_vlan)))
2551 goto out;
2552
2553
2554 if (tt_data->flags & BATADV_TT_FULL_TABLE ||
2555 !req_dst_orig_node->tt_buff)
2556 full_table = true;
2557 else
2558 full_table = false;
2559
2560
2561
2562
2563 if (!full_table) {
2564 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
2565 tt_len = req_dst_orig_node->tt_buff_len;
2566
2567 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
2568 &tvlv_tt_data,
2569 &tt_change,
2570 &tt_len);
2571 if (!tt_len)
2572 goto unlock;
2573
2574
2575 memcpy(tt_change, req_dst_orig_node->tt_buff,
2576 req_dst_orig_node->tt_buff_len);
2577 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
2578 } else {
2579
2580
2581
2582 tt_len = -1;
2583 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
2584 &tvlv_tt_data,
2585 &tt_change,
2586 &tt_len);
2587 if (!tt_len)
2588 goto out;
2589
2590
2591 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,
2592 tt_change, tt_len,
2593 batadv_tt_global_valid,
2594 req_dst_orig_node);
2595 }
2596
2597
2598 tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;
2599 if (tt_len > atomic_read(&bat_priv->packet_size_max)) {
2600 net_ratelimited_function(batadv_info, bat_priv->soft_iface,
2601 "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",
2602 res_dst_orig_node->orig);
2603 goto out;
2604 }
2605
2606 tvlv_tt_data->flags = BATADV_TT_RESPONSE;
2607 tvlv_tt_data->ttvn = req_ttvn;
2608
2609 if (full_table)
2610 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2611
2612 batadv_dbg(BATADV_DBG_TT, bat_priv,
2613 "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",
2614 res_dst_orig_node->orig, req_dst_orig_node->orig,
2615 full_table ? 'F' : '.', req_ttvn);
2616
2617 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2618
2619 batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
2620 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
2621 tvlv_len);
2622
2623 ret = true;
2624 goto out;
2625
2626unlock:
2627 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
2628
2629out:
2630 if (res_dst_orig_node)
2631 batadv_orig_node_free_ref(res_dst_orig_node);
2632 if (req_dst_orig_node)
2633 batadv_orig_node_free_ref(req_dst_orig_node);
2634 kfree(tvlv_tt_data);
2635 return ret;
2636}
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
2648 struct batadv_tvlv_tt_data *tt_data,
2649 uint8_t *req_src)
2650{
2651 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2652 struct batadv_hard_iface *primary_if = NULL;
2653 struct batadv_tvlv_tt_change *tt_change;
2654 struct batadv_orig_node *orig_node;
2655 uint8_t my_ttvn, req_ttvn;
2656 uint16_t tvlv_len;
2657 bool full_table;
2658 int32_t tt_len;
2659
2660 batadv_dbg(BATADV_DBG_TT, bat_priv,
2661 "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
2662 req_src, tt_data->ttvn,
2663 (tt_data->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
2664
2665 spin_lock_bh(&bat_priv->tt.commit_lock);
2666
2667 my_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
2668 req_ttvn = tt_data->ttvn;
2669
2670 orig_node = batadv_orig_hash_find(bat_priv, req_src);
2671 if (!orig_node)
2672 goto out;
2673
2674 primary_if = batadv_primary_if_get_selected(bat_priv);
2675 if (!primary_if)
2676 goto out;
2677
2678
2679
2680
2681 if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
2682 !bat_priv->tt.last_changeset)
2683 full_table = true;
2684 else
2685 full_table = false;
2686
2687
2688
2689
2690 if (!full_table) {
2691 spin_lock_bh(&bat_priv->tt.last_changeset_lock);
2692
2693 tt_len = bat_priv->tt.last_changeset_len;
2694 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
2695 &tvlv_tt_data,
2696 &tt_change,
2697 &tt_len);
2698 if (!tt_len)
2699 goto unlock;
2700
2701
2702 memcpy(tt_change, bat_priv->tt.last_changeset,
2703 bat_priv->tt.last_changeset_len);
2704 spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2705 } else {
2706 req_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
2707
2708
2709
2710
2711 tt_len = -1;
2712 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
2713 &tvlv_tt_data,
2714 &tt_change,
2715 &tt_len);
2716 if (!tt_len)
2717 goto out;
2718
2719
2720 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,
2721 tt_change, tt_len,
2722 batadv_tt_local_valid, NULL);
2723 }
2724
2725 tvlv_tt_data->flags = BATADV_TT_RESPONSE;
2726 tvlv_tt_data->ttvn = req_ttvn;
2727
2728 if (full_table)
2729 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2730
2731 batadv_dbg(BATADV_DBG_TT, bat_priv,
2732 "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
2733 orig_node->orig, full_table ? 'F' : '.', req_ttvn);
2734
2735 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2736
2737 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2738 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
2739 tvlv_len);
2740
2741 goto out;
2742
2743unlock:
2744 spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2745out:
2746 spin_unlock_bh(&bat_priv->tt.commit_lock);
2747 if (orig_node)
2748 batadv_orig_node_free_ref(orig_node);
2749 if (primary_if)
2750 batadv_hardif_free_ref(primary_if);
2751 kfree(tvlv_tt_data);
2752
2753 return true;
2754}
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
2766 struct batadv_tvlv_tt_data *tt_data,
2767 uint8_t *req_src, uint8_t *req_dst)
2768{
2769 if (batadv_is_my_mac(bat_priv, req_dst))
2770 return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
2771 return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
2772 req_dst);
2773}
2774
2775static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
2776 struct batadv_orig_node *orig_node,
2777 struct batadv_tvlv_tt_change *tt_change,
2778 uint16_t tt_num_changes, uint8_t ttvn)
2779{
2780 int i;
2781 int roams;
2782
2783 for (i = 0; i < tt_num_changes; i++) {
2784 if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
2785 roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
2786 batadv_tt_global_del(bat_priv, orig_node,
2787 (tt_change + i)->addr,
2788 ntohs((tt_change + i)->vid),
2789 "tt removed by changes",
2790 roams);
2791 } else {
2792 if (!batadv_tt_global_add(bat_priv, orig_node,
2793 (tt_change + i)->addr,
2794 ntohs((tt_change + i)->vid),
2795 (tt_change + i)->flags, ttvn))
2796
2797
2798
2799
2800
2801
2802 return;
2803 }
2804 }
2805 orig_node->capa_initialized |= BATADV_ORIG_CAPA_HAS_TT;
2806}
2807
2808static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
2809 struct batadv_tvlv_tt_change *tt_change,
2810 uint8_t ttvn, uint8_t *resp_src,
2811 uint16_t num_entries)
2812{
2813 struct batadv_orig_node *orig_node;
2814
2815 orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2816 if (!orig_node)
2817 goto out;
2818
2819
2820 batadv_tt_global_del_orig(bat_priv, orig_node, -1,
2821 "Received full table");
2822
2823 _batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
2824 ttvn);
2825
2826 spin_lock_bh(&orig_node->tt_buff_lock);
2827 kfree(orig_node->tt_buff);
2828 orig_node->tt_buff_len = 0;
2829 orig_node->tt_buff = NULL;
2830 spin_unlock_bh(&orig_node->tt_buff_lock);
2831
2832 atomic_set(&orig_node->last_ttvn, ttvn);
2833
2834out:
2835 if (orig_node)
2836 batadv_orig_node_free_ref(orig_node);
2837}
2838
2839static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
2840 struct batadv_orig_node *orig_node,
2841 uint16_t tt_num_changes, uint8_t ttvn,
2842 struct batadv_tvlv_tt_change *tt_change)
2843{
2844 _batadv_tt_update_changes(bat_priv, orig_node, tt_change,
2845 tt_num_changes, ttvn);
2846
2847 batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
2848 batadv_tt_len(tt_num_changes));
2849 atomic_set(&orig_node->last_ttvn, ttvn);
2850}
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860bool batadv_is_my_client(struct batadv_priv *bat_priv, const uint8_t *addr,
2861 unsigned short vid)
2862{
2863 struct batadv_tt_local_entry *tt_local_entry;
2864 bool ret = false;
2865
2866 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
2867 if (!tt_local_entry)
2868 goto out;
2869
2870
2871
2872 if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
2873 (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
2874 goto out;
2875 ret = true;
2876out:
2877 if (tt_local_entry)
2878 batadv_tt_local_entry_free_ref(tt_local_entry);
2879 return ret;
2880}
2881
2882
2883
2884
2885
2886
2887
2888
2889static void batadv_handle_tt_response(struct batadv_priv *bat_priv,
2890 struct batadv_tvlv_tt_data *tt_data,
2891 uint8_t *resp_src, uint16_t num_entries)
2892{
2893 struct batadv_tt_req_node *node, *safe;
2894 struct batadv_orig_node *orig_node = NULL;
2895 struct batadv_tvlv_tt_change *tt_change;
2896 uint8_t *tvlv_ptr = (uint8_t *)tt_data;
2897 uint16_t change_offset;
2898
2899 batadv_dbg(BATADV_DBG_TT, bat_priv,
2900 "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
2901 resp_src, tt_data->ttvn, num_entries,
2902 (tt_data->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
2903
2904 orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2905 if (!orig_node)
2906 goto out;
2907
2908 spin_lock_bh(&orig_node->tt_lock);
2909
2910 change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);
2911 change_offset *= ntohs(tt_data->num_vlan);
2912 change_offset += sizeof(*tt_data);
2913 tvlv_ptr += change_offset;
2914
2915 tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;
2916 if (tt_data->flags & BATADV_TT_FULL_TABLE) {
2917 batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
2918 resp_src, num_entries);
2919 } else {
2920 batadv_tt_update_changes(bat_priv, orig_node, num_entries,
2921 tt_data->ttvn, tt_change);
2922 }
2923
2924
2925 batadv_tt_global_update_crc(bat_priv, orig_node);
2926
2927 spin_unlock_bh(&orig_node->tt_lock);
2928
2929
2930 spin_lock_bh(&bat_priv->tt.req_list_lock);
2931 list_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2932 if (!batadv_compare_eth(node->addr, resp_src))
2933 continue;
2934 list_del(&node->list);
2935 kfree(node);
2936 }
2937
2938 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2939out:
2940 if (orig_node)
2941 batadv_orig_node_free_ref(orig_node);
2942}
2943
2944static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
2945{
2946 struct batadv_tt_roam_node *node, *safe;
2947
2948 spin_lock_bh(&bat_priv->tt.roam_list_lock);
2949
2950 list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
2951 list_del(&node->list);
2952 kfree(node);
2953 }
2954
2955 spin_unlock_bh(&bat_priv->tt.roam_list_lock);
2956}
2957
2958static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
2959{
2960 struct batadv_tt_roam_node *node, *safe;
2961
2962 spin_lock_bh(&bat_priv->tt.roam_list_lock);
2963 list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
2964 if (!batadv_has_timed_out(node->first_time,
2965 BATADV_ROAMING_MAX_TIME))
2966 continue;
2967
2968 list_del(&node->list);
2969 kfree(node);
2970 }
2971 spin_unlock_bh(&bat_priv->tt.roam_list_lock);
2972}
2973
2974
2975
2976
2977
2978
2979
2980static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv,
2981 uint8_t *client)
2982{
2983 struct batadv_tt_roam_node *tt_roam_node;
2984 bool ret = false;
2985
2986 spin_lock_bh(&bat_priv->tt.roam_list_lock);
2987
2988
2989
2990 list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
2991 if (!batadv_compare_eth(tt_roam_node->addr, client))
2992 continue;
2993
2994 if (batadv_has_timed_out(tt_roam_node->first_time,
2995 BATADV_ROAMING_MAX_TIME))
2996 continue;
2997
2998 if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
2999
3000 goto unlock;
3001 ret = true;
3002 break;
3003 }
3004
3005 if (!ret) {
3006 tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
3007 if (!tt_roam_node)
3008 goto unlock;
3009
3010 tt_roam_node->first_time = jiffies;
3011 atomic_set(&tt_roam_node->counter,
3012 BATADV_ROAMING_MAX_COUNT - 1);
3013 ether_addr_copy(tt_roam_node->addr, client);
3014
3015 list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3016 ret = true;
3017 }
3018
3019unlock:
3020 spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3021 return ret;
3022}
3023
3024
3025
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client,
3037 unsigned short vid,
3038 struct batadv_orig_node *orig_node)
3039{
3040 struct batadv_hard_iface *primary_if;
3041 struct batadv_tvlv_roam_adv tvlv_roam;
3042
3043 primary_if = batadv_primary_if_get_selected(bat_priv);
3044 if (!primary_if)
3045 goto out;
3046
3047
3048
3049
3050 if (!batadv_tt_check_roam_count(bat_priv, client))
3051 goto out;
3052
3053 batadv_dbg(BATADV_DBG_TT, bat_priv,
3054 "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
3055 orig_node->orig, client, BATADV_PRINT_VID(vid));
3056
3057 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3058
3059 memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3060 tvlv_roam.vid = htons(vid);
3061
3062 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3063 orig_node->orig, BATADV_TVLV_ROAM, 1,
3064 &tvlv_roam, sizeof(tvlv_roam));
3065
3066out:
3067 if (primary_if)
3068 batadv_hardif_free_ref(primary_if);
3069}
3070
3071static void batadv_tt_purge(struct work_struct *work)
3072{
3073 struct delayed_work *delayed_work;
3074 struct batadv_priv_tt *priv_tt;
3075 struct batadv_priv *bat_priv;
3076
3077 delayed_work = container_of(work, struct delayed_work, work);
3078 priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
3079 bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3080
3081 batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3082 batadv_tt_global_purge(bat_priv);
3083 batadv_tt_req_purge(bat_priv);
3084 batadv_tt_roam_purge(bat_priv);
3085
3086 queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3087 msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3088}
3089
3090void batadv_tt_free(struct batadv_priv *bat_priv)
3091{
3092 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
3093 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);
3094
3095 cancel_delayed_work_sync(&bat_priv->tt.work);
3096
3097 batadv_tt_local_table_free(bat_priv);
3098 batadv_tt_global_table_free(bat_priv);
3099 batadv_tt_req_list_free(bat_priv);
3100 batadv_tt_changes_list_free(bat_priv);
3101 batadv_tt_roam_list_free(bat_priv);
3102
3103 kfree(bat_priv->tt.last_changeset);
3104}
3105
3106
3107
3108
3109
3110
3111
3112
3113
3114static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv,
3115 uint16_t flags, bool enable, bool count)
3116{
3117 struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3118 struct batadv_tt_common_entry *tt_common_entry;
3119 uint16_t changed_num = 0;
3120 struct hlist_head *head;
3121 uint32_t i;
3122
3123 if (!hash)
3124 return;
3125
3126 for (i = 0; i < hash->size; i++) {
3127 head = &hash->table[i];
3128
3129 rcu_read_lock();
3130 hlist_for_each_entry_rcu(tt_common_entry,
3131 head, hash_entry) {
3132 if (enable) {
3133 if ((tt_common_entry->flags & flags) == flags)
3134 continue;
3135 tt_common_entry->flags |= flags;
3136 } else {
3137 if (!(tt_common_entry->flags & flags))
3138 continue;
3139 tt_common_entry->flags &= ~flags;
3140 }
3141 changed_num++;
3142
3143 if (!count)
3144 continue;
3145
3146 batadv_tt_local_size_inc(bat_priv,
3147 tt_common_entry->vid);
3148 }
3149 rcu_read_unlock();
3150 }
3151}
3152
3153
3154static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3155{
3156 struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3157 struct batadv_tt_common_entry *tt_common;
3158 struct batadv_tt_local_entry *tt_local;
3159 struct batadv_softif_vlan *vlan;
3160 struct hlist_node *node_tmp;
3161 struct hlist_head *head;
3162 spinlock_t *list_lock;
3163 uint32_t i;
3164
3165 if (!hash)
3166 return;
3167
3168 for (i = 0; i < hash->size; i++) {
3169 head = &hash->table[i];
3170 list_lock = &hash->list_locks[i];
3171
3172 spin_lock_bh(list_lock);
3173 hlist_for_each_entry_safe(tt_common, node_tmp, head,
3174 hash_entry) {
3175 if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3176 continue;
3177
3178 batadv_dbg(BATADV_DBG_TT, bat_priv,
3179 "Deleting local tt entry (%pM, vid: %d): pending\n",
3180 tt_common->addr,
3181 BATADV_PRINT_VID(tt_common->vid));
3182
3183 batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3184 hlist_del_rcu(&tt_common->hash_entry);
3185 tt_local = container_of(tt_common,
3186 struct batadv_tt_local_entry,
3187 common);
3188
3189
3190 vlan = batadv_softif_vlan_get(bat_priv, tt_common->vid);
3191 batadv_softif_vlan_free_ref(vlan);
3192 batadv_softif_vlan_free_ref(vlan);
3193
3194 batadv_tt_local_entry_free_ref(tt_local);
3195 }
3196 spin_unlock_bh(list_lock);
3197 }
3198}
3199
3200
3201
3202
3203
3204
3205
3206
3207static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3208{
3209
3210 batadv_mcast_mla_update(bat_priv);
3211
3212 if (atomic_read(&bat_priv->tt.local_changes) < 1) {
3213 if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))
3214 batadv_tt_tvlv_container_update(bat_priv);
3215 return;
3216 }
3217
3218 batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3219
3220 batadv_tt_local_purge_pending_clients(bat_priv);
3221 batadv_tt_local_update_crc(bat_priv);
3222
3223
3224 atomic_inc(&bat_priv->tt.vn);
3225 batadv_dbg(BATADV_DBG_TT, bat_priv,
3226 "Local changes committed, updating to ttvn %u\n",
3227 (uint8_t)atomic_read(&bat_priv->tt.vn));
3228
3229
3230 atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3231 batadv_tt_tvlv_container_update(bat_priv);
3232}
3233
3234
3235
3236
3237
3238
3239void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)
3240{
3241 spin_lock_bh(&bat_priv->tt.commit_lock);
3242 batadv_tt_local_commit_changes_nolock(bat_priv);
3243 spin_unlock_bh(&bat_priv->tt.commit_lock);
3244}
3245
3246bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, uint8_t *src,
3247 uint8_t *dst, unsigned short vid)
3248{
3249 struct batadv_tt_local_entry *tt_local_entry = NULL;
3250 struct batadv_tt_global_entry *tt_global_entry = NULL;
3251 struct batadv_softif_vlan *vlan;
3252 bool ret = false;
3253
3254 vlan = batadv_softif_vlan_get(bat_priv, vid);
3255 if (!vlan || !atomic_read(&vlan->ap_isolation))
3256 goto out;
3257
3258 tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3259 if (!tt_local_entry)
3260 goto out;
3261
3262 tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3263 if (!tt_global_entry)
3264 goto out;
3265
3266 if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3267 goto out;
3268
3269 ret = true;
3270
3271out:
3272 if (vlan)
3273 batadv_softif_vlan_free_ref(vlan);
3274 if (tt_global_entry)
3275 batadv_tt_global_entry_free_ref(tt_global_entry);
3276 if (tt_local_entry)
3277 batadv_tt_local_entry_free_ref(tt_local_entry);
3278 return ret;
3279}
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
3294 struct batadv_orig_node *orig_node,
3295 const void *tt_buff, uint16_t tt_num_vlan,
3296 struct batadv_tvlv_tt_change *tt_change,
3297 uint16_t tt_num_changes, uint8_t ttvn)
3298{
3299 uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
3300 struct batadv_tvlv_tt_vlan_data *tt_vlan;
3301 bool full_table = true;
3302 bool has_tt_init;
3303
3304 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
3305 has_tt_init = orig_node->capa_initialized & BATADV_ORIG_CAPA_HAS_TT;
3306
3307
3308
3309
3310 if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
3311
3312
3313
3314
3315
3316 if (!tt_num_changes) {
3317 full_table = false;
3318 goto request_table;
3319 }
3320
3321 spin_lock_bh(&orig_node->tt_lock);
3322
3323 batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
3324 ttvn, tt_change);
3325
3326
3327
3328
3329
3330 batadv_tt_global_update_crc(bat_priv, orig_node);
3331
3332 spin_unlock_bh(&orig_node->tt_lock);
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343 if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
3344 tt_num_vlan))
3345 goto request_table;
3346 } else {
3347
3348
3349
3350 if (!has_tt_init || ttvn != orig_ttvn ||
3351 !batadv_tt_global_check_crc(orig_node, tt_vlan,
3352 tt_num_vlan)) {
3353request_table:
3354 batadv_dbg(BATADV_DBG_TT, bat_priv,
3355 "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",
3356 orig_node->orig, ttvn, orig_ttvn,
3357 tt_num_changes);
3358 batadv_send_tt_request(bat_priv, orig_node, ttvn,
3359 tt_vlan, tt_num_vlan,
3360 full_table);
3361 return;
3362 }
3363 }
3364}
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
3377 uint8_t *addr, unsigned short vid)
3378{
3379 struct batadv_tt_global_entry *tt_global_entry;
3380 bool ret = false;
3381
3382 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
3383 if (!tt_global_entry)
3384 goto out;
3385
3386 ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3387 batadv_tt_global_entry_free_ref(tt_global_entry);
3388out:
3389 return ret;
3390}
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
3403 uint8_t *addr, unsigned short vid)
3404{
3405 struct batadv_tt_local_entry *tt_local_entry;
3406 bool ret = false;
3407
3408 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3409 if (!tt_local_entry)
3410 goto out;
3411
3412 ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3413 batadv_tt_local_entry_free_ref(tt_local_entry);
3414out:
3415 return ret;
3416}
3417
3418bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
3419 struct batadv_orig_node *orig_node,
3420 const unsigned char *addr,
3421 unsigned short vid)
3422{
3423 bool ret = false;
3424
3425 if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
3426 BATADV_TT_CLIENT_TEMP,
3427 atomic_read(&orig_node->last_ttvn)))
3428 goto out;
3429
3430 batadv_dbg(BATADV_DBG_TT, bat_priv,
3431 "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
3432 addr, BATADV_PRINT_VID(vid), orig_node->orig);
3433 ret = true;
3434out:
3435 return ret;
3436}
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)
3447{
3448 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
3449 int packet_size_max = atomic_read(&bat_priv->packet_size_max);
3450 int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;
3451 bool reduced = false;
3452
3453 spin_lock_bh(&bat_priv->tt.commit_lock);
3454
3455 while (true) {
3456 table_size = batadv_tt_local_table_transmit_size(bat_priv);
3457 if (packet_size_max >= table_size)
3458 break;
3459
3460 batadv_tt_local_purge(bat_priv, timeout);
3461 batadv_tt_local_purge_pending_clients(bat_priv);
3462
3463 timeout /= 2;
3464 reduced = true;
3465 net_ratelimited_function(batadv_info, soft_iface,
3466 "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",
3467 packet_size_max);
3468 }
3469
3470
3471
3472
3473 if (reduced)
3474 batadv_tt_local_commit_changes_nolock(bat_priv);
3475
3476 spin_unlock_bh(&bat_priv->tt.commit_lock);
3477}
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
3488 struct batadv_orig_node *orig,
3489 uint8_t flags, void *tvlv_value,
3490 uint16_t tvlv_value_len)
3491{
3492 struct batadv_tvlv_tt_vlan_data *tt_vlan;
3493 struct batadv_tvlv_tt_change *tt_change;
3494 struct batadv_tvlv_tt_data *tt_data;
3495 uint16_t num_entries, num_vlan;
3496
3497 if (tvlv_value_len < sizeof(*tt_data))
3498 return;
3499
3500 tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
3501 tvlv_value_len -= sizeof(*tt_data);
3502
3503 num_vlan = ntohs(tt_data->num_vlan);
3504
3505 if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)
3506 return;
3507
3508 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
3509 tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);
3510 tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;
3511
3512 num_entries = batadv_tt_entries(tvlv_value_len);
3513
3514 batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
3515 num_entries, tt_data->ttvn);
3516}
3517
3518
3519
3520
3521
3522
3523
3524
3525
3526
3527
3528
3529
3530static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3531 uint8_t *src, uint8_t *dst,
3532 void *tvlv_value,
3533 uint16_t tvlv_value_len)
3534{
3535 struct batadv_tvlv_tt_data *tt_data;
3536 uint16_t tt_vlan_len, tt_num_entries;
3537 char tt_flag;
3538 bool ret;
3539
3540 if (tvlv_value_len < sizeof(*tt_data))
3541 return NET_RX_SUCCESS;
3542
3543 tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
3544 tvlv_value_len -= sizeof(*tt_data);
3545
3546 tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);
3547 tt_vlan_len *= ntohs(tt_data->num_vlan);
3548
3549 if (tvlv_value_len < tt_vlan_len)
3550 return NET_RX_SUCCESS;
3551
3552 tvlv_value_len -= tt_vlan_len;
3553 tt_num_entries = batadv_tt_entries(tvlv_value_len);
3554
3555 switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {
3556 case BATADV_TT_REQUEST:
3557 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
3558
3559
3560
3561
3562 ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);
3563 if (!ret) {
3564 if (tt_data->flags & BATADV_TT_FULL_TABLE)
3565 tt_flag = 'F';
3566 else
3567 tt_flag = '.';
3568
3569 batadv_dbg(BATADV_DBG_TT, bat_priv,
3570 "Routing TT_REQUEST to %pM [%c]\n",
3571 dst, tt_flag);
3572
3573 return NET_RX_DROP;
3574 }
3575 break;
3576 case BATADV_TT_RESPONSE:
3577 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
3578
3579 if (batadv_is_my_mac(bat_priv, dst)) {
3580 batadv_handle_tt_response(bat_priv, tt_data,
3581 src, tt_num_entries);
3582 return NET_RX_SUCCESS;
3583 }
3584
3585 if (tt_data->flags & BATADV_TT_FULL_TABLE)
3586 tt_flag = 'F';
3587 else
3588 tt_flag = '.';
3589
3590 batadv_dbg(BATADV_DBG_TT, bat_priv,
3591 "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);
3592
3593
3594 return NET_RX_DROP;
3595 }
3596
3597 return NET_RX_SUCCESS;
3598}
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3612 uint8_t *src, uint8_t *dst,
3613 void *tvlv_value,
3614 uint16_t tvlv_value_len)
3615{
3616 struct batadv_tvlv_roam_adv *roaming_adv;
3617 struct batadv_orig_node *orig_node = NULL;
3618
3619
3620
3621
3622
3623 if (!batadv_is_my_mac(bat_priv, dst))
3624 return NET_RX_DROP;
3625
3626 if (tvlv_value_len < sizeof(*roaming_adv))
3627 goto out;
3628
3629 orig_node = batadv_orig_hash_find(bat_priv, src);
3630 if (!orig_node)
3631 goto out;
3632
3633 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
3634 roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;
3635
3636 batadv_dbg(BATADV_DBG_TT, bat_priv,
3637 "Received ROAMING_ADV from %pM (client %pM)\n",
3638 src, roaming_adv->client);
3639
3640 batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,
3641 ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
3642 atomic_read(&orig_node->last_ttvn) + 1);
3643
3644out:
3645 if (orig_node)
3646 batadv_orig_node_free_ref(orig_node);
3647 return NET_RX_SUCCESS;
3648}
3649
3650
3651
3652
3653
3654
3655
3656int batadv_tt_init(struct batadv_priv *bat_priv)
3657{
3658 int ret;
3659
3660
3661 BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));
3662
3663 ret = batadv_tt_local_init(bat_priv);
3664 if (ret < 0)
3665 return ret;
3666
3667 ret = batadv_tt_global_init(bat_priv);
3668 if (ret < 0)
3669 return ret;
3670
3671 batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,
3672 batadv_tt_tvlv_unicast_handler_v1,
3673 BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
3674
3675 batadv_tvlv_handler_register(bat_priv, NULL,
3676 batadv_roam_tvlv_unicast_handler_v1,
3677 BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);
3678
3679 INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
3680 queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3681 msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3682
3683 return 1;
3684}
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
3695bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
3696 const uint8_t *addr, unsigned short vid)
3697{
3698 struct batadv_tt_global_entry *tt;
3699 bool ret;
3700
3701 tt = batadv_tt_global_hash_find(bat_priv, addr, vid);
3702 if (!tt)
3703 return false;
3704
3705 ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;
3706
3707 batadv_tt_global_entry_free_ref(tt);
3708
3709 return ret;
3710}
3711