1
2
3
4
5
6
7#include "network-coding.h"
8#include "main.h"
9
10#include <linux/atomic.h>
11#include <linux/bitops.h>
12#include <linux/byteorder/generic.h>
13#include <linux/compiler.h>
14#include <linux/errno.h>
15#include <linux/etherdevice.h>
16#include <linux/gfp.h>
17#include <linux/if_ether.h>
18#include <linux/if_packet.h>
19#include <linux/init.h>
20#include <linux/jhash.h>
21#include <linux/jiffies.h>
22#include <linux/kernel.h>
23#include <linux/kref.h>
24#include <linux/list.h>
25#include <linux/lockdep.h>
26#include <linux/net.h>
27#include <linux/netdevice.h>
28#include <linux/prandom.h>
29#include <linux/printk.h>
30#include <linux/rculist.h>
31#include <linux/rcupdate.h>
32#include <linux/skbuff.h>
33#include <linux/slab.h>
34#include <linux/spinlock.h>
35#include <linux/stddef.h>
36#include <linux/string.h>
37#include <linux/workqueue.h>
38#include <uapi/linux/batadv_packet.h>
39
40#include "hash.h"
41#include "log.h"
42#include "originator.h"
43#include "routing.h"
44#include "send.h"
45#include "tvlv.h"
46
47static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
48static struct lock_class_key batadv_nc_decoding_hash_lock_class_key;
49
50static void batadv_nc_worker(struct work_struct *work);
51static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
52 struct batadv_hard_iface *recv_if);
53
54
55
56
57
58
59int __init batadv_nc_init(void)
60{
61 int ret;
62
63
64 ret = batadv_recv_handler_register(BATADV_CODED,
65 batadv_nc_recv_coded_packet);
66
67 return ret;
68}
69
70
71
72
73
74static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
75{
76 queue_delayed_work(batadv_event_workqueue, &bat_priv->nc.work,
77 msecs_to_jiffies(10));
78}
79
80
81
82
83
84
85static void batadv_nc_tvlv_container_update(struct batadv_priv *bat_priv)
86{
87 char nc_mode;
88
89 nc_mode = atomic_read(&bat_priv->network_coding);
90
91 switch (nc_mode) {
92 case 0:
93 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_NC, 1);
94 break;
95 case 1:
96 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_NC, 1,
97 NULL, 0);
98 break;
99 }
100}
101
102
103
104
105
106
107void batadv_nc_status_update(struct net_device *net_dev)
108{
109 struct batadv_priv *bat_priv = netdev_priv(net_dev);
110
111 batadv_nc_tvlv_container_update(bat_priv);
112}
113
114
115
116
117
118
119
120
121
122static void batadv_nc_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
123 struct batadv_orig_node *orig,
124 u8 flags,
125 void *tvlv_value, u16 tvlv_value_len)
126{
127 if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
128 clear_bit(BATADV_ORIG_CAPA_HAS_NC, &orig->capabilities);
129 else
130 set_bit(BATADV_ORIG_CAPA_HAS_NC, &orig->capabilities);
131}
132
133
134
135
136
137
138
139int batadv_nc_mesh_init(struct batadv_priv *bat_priv)
140{
141 bat_priv->nc.timestamp_fwd_flush = jiffies;
142 bat_priv->nc.timestamp_sniffed_purge = jiffies;
143
144 if (bat_priv->nc.coding_hash || bat_priv->nc.decoding_hash)
145 return 0;
146
147 bat_priv->nc.coding_hash = batadv_hash_new(128);
148 if (!bat_priv->nc.coding_hash)
149 goto err;
150
151 batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
152 &batadv_nc_coding_hash_lock_class_key);
153
154 bat_priv->nc.decoding_hash = batadv_hash_new(128);
155 if (!bat_priv->nc.decoding_hash) {
156 batadv_hash_destroy(bat_priv->nc.coding_hash);
157 goto err;
158 }
159
160 batadv_hash_set_lock_class(bat_priv->nc.decoding_hash,
161 &batadv_nc_decoding_hash_lock_class_key);
162
163 INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
164 batadv_nc_start_timer(bat_priv);
165
166 batadv_tvlv_handler_register(bat_priv, batadv_nc_tvlv_ogm_handler_v1,
167 NULL, BATADV_TVLV_NC, 1,
168 BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
169 batadv_nc_tvlv_container_update(bat_priv);
170 return 0;
171
172err:
173 return -ENOMEM;
174}
175
176
177
178
179
180void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
181{
182 atomic_set(&bat_priv->network_coding, 0);
183 bat_priv->nc.min_tq = 200;
184 bat_priv->nc.max_fwd_delay = 10;
185 bat_priv->nc.max_buffer_time = 200;
186}
187
188
189
190
191
192void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
193{
194 INIT_LIST_HEAD(&orig_node->in_coding_list);
195 INIT_LIST_HEAD(&orig_node->out_coding_list);
196 spin_lock_init(&orig_node->in_coding_list_lock);
197 spin_lock_init(&orig_node->out_coding_list_lock);
198}
199
200
201
202
203
204
205static void batadv_nc_node_release(struct kref *ref)
206{
207 struct batadv_nc_node *nc_node;
208
209 nc_node = container_of(ref, struct batadv_nc_node, refcount);
210
211 batadv_orig_node_put(nc_node->orig_node);
212 kfree_rcu(nc_node, rcu);
213}
214
215
216
217
218
219
220static void batadv_nc_node_put(struct batadv_nc_node *nc_node)
221{
222 if (!nc_node)
223 return;
224
225 kref_put(&nc_node->refcount, batadv_nc_node_release);
226}
227
228
229
230
231
232
233static void batadv_nc_path_release(struct kref *ref)
234{
235 struct batadv_nc_path *nc_path;
236
237 nc_path = container_of(ref, struct batadv_nc_path, refcount);
238
239 kfree_rcu(nc_path, rcu);
240}
241
242
243
244
245
246
247static void batadv_nc_path_put(struct batadv_nc_path *nc_path)
248{
249 if (!nc_path)
250 return;
251
252 kref_put(&nc_path->refcount, batadv_nc_path_release);
253}
254
255
256
257
258
259
260static void batadv_nc_packet_free(struct batadv_nc_packet *nc_packet,
261 bool dropped)
262{
263 if (dropped)
264 kfree_skb(nc_packet->skb);
265 else
266 consume_skb(nc_packet->skb);
267
268 batadv_nc_path_put(nc_packet->nc_path);
269 kfree(nc_packet);
270}
271
272
273
274
275
276
277
278
279static bool batadv_nc_to_purge_nc_node(struct batadv_priv *bat_priv,
280 struct batadv_nc_node *nc_node)
281{
282 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
283 return true;
284
285 return batadv_has_timed_out(nc_node->last_seen, BATADV_NC_NODE_TIMEOUT);
286}
287
288
289
290
291
292
293
294
295static bool batadv_nc_to_purge_nc_path_coding(struct batadv_priv *bat_priv,
296 struct batadv_nc_path *nc_path)
297{
298 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
299 return true;
300
301
302
303
304 return batadv_has_timed_out(nc_path->last_valid,
305 bat_priv->nc.max_fwd_delay * 10);
306}
307
308
309
310
311
312
313
314
315
316static bool batadv_nc_to_purge_nc_path_decoding(struct batadv_priv *bat_priv,
317 struct batadv_nc_path *nc_path)
318{
319 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
320 return true;
321
322
323
324
325 return batadv_has_timed_out(nc_path->last_valid,
326 bat_priv->nc.max_buffer_time * 10);
327}
328
329
330
331
332
333
334
335
336
337
338
339
340static void
341batadv_nc_purge_orig_nc_nodes(struct batadv_priv *bat_priv,
342 struct list_head *list,
343 spinlock_t *lock,
344 bool (*to_purge)(struct batadv_priv *,
345 struct batadv_nc_node *))
346{
347 struct batadv_nc_node *nc_node, *nc_node_tmp;
348
349
350 spin_lock_bh(lock);
351 list_for_each_entry_safe(nc_node, nc_node_tmp, list, list) {
352
353
354
355 if (to_purge && !to_purge(bat_priv, nc_node))
356 continue;
357
358 batadv_dbg(BATADV_DBG_NC, bat_priv,
359 "Removing nc_node %pM -> %pM\n",
360 nc_node->addr, nc_node->orig_node->orig);
361 list_del_rcu(&nc_node->list);
362 batadv_nc_node_put(nc_node);
363 }
364 spin_unlock_bh(lock);
365}
366
367
368
369
370
371
372
373
374
375
376
377void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
378 struct batadv_orig_node *orig_node,
379 bool (*to_purge)(struct batadv_priv *,
380 struct batadv_nc_node *))
381{
382
383 batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->in_coding_list,
384 &orig_node->in_coding_list_lock,
385 to_purge);
386
387
388 batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->out_coding_list,
389 &orig_node->out_coding_list_lock,
390 to_purge);
391}
392
393
394
395
396
397
398static void batadv_nc_purge_orig_hash(struct batadv_priv *bat_priv)
399{
400 struct batadv_hashtable *hash = bat_priv->orig_hash;
401 struct hlist_head *head;
402 struct batadv_orig_node *orig_node;
403 u32 i;
404
405 if (!hash)
406 return;
407
408
409 for (i = 0; i < hash->size; i++) {
410 head = &hash->table[i];
411
412 rcu_read_lock();
413 hlist_for_each_entry_rcu(orig_node, head, hash_entry)
414 batadv_nc_purge_orig(bat_priv, orig_node,
415 batadv_nc_to_purge_nc_node);
416 rcu_read_unlock();
417 }
418}
419
420
421
422
423
424
425
426
427
428
429
430static void batadv_nc_purge_paths(struct batadv_priv *bat_priv,
431 struct batadv_hashtable *hash,
432 bool (*to_purge)(struct batadv_priv *,
433 struct batadv_nc_path *))
434{
435 struct hlist_head *head;
436 struct hlist_node *node_tmp;
437 struct batadv_nc_path *nc_path;
438 spinlock_t *lock;
439 u32 i;
440
441 for (i = 0; i < hash->size; i++) {
442 head = &hash->table[i];
443 lock = &hash->list_locks[i];
444
445
446 spin_lock_bh(lock);
447 hlist_for_each_entry_safe(nc_path, node_tmp, head, hash_entry) {
448
449
450
451 if (to_purge && !to_purge(bat_priv, nc_path))
452 continue;
453
454
455
456
457
458
459 if (!unlikely(list_empty(&nc_path->packet_list))) {
460 net_ratelimited_function(printk,
461 KERN_WARNING
462 "Skipping free of non-empty nc_path (%pM -> %pM)!\n",
463 nc_path->prev_hop,
464 nc_path->next_hop);
465 continue;
466 }
467
468
469 batadv_dbg(BATADV_DBG_NC, bat_priv,
470 "Remove nc_path %pM -> %pM\n",
471 nc_path->prev_hop, nc_path->next_hop);
472 hlist_del_rcu(&nc_path->hash_entry);
473 batadv_nc_path_put(nc_path);
474 }
475 spin_unlock_bh(lock);
476 }
477}
478
479
480
481
482
483
484
485static void batadv_nc_hash_key_gen(struct batadv_nc_path *key, const char *src,
486 const char *dst)
487{
488 memcpy(key->prev_hop, src, sizeof(key->prev_hop));
489 memcpy(key->next_hop, dst, sizeof(key->next_hop));
490}
491
492
493
494
495
496
497
498
499static u32 batadv_nc_hash_choose(const void *data, u32 size)
500{
501 const struct batadv_nc_path *nc_path = data;
502 u32 hash = 0;
503
504 hash = jhash(&nc_path->prev_hop, sizeof(nc_path->prev_hop), hash);
505 hash = jhash(&nc_path->next_hop, sizeof(nc_path->next_hop), hash);
506
507 return hash % size;
508}
509
510
511
512
513
514
515
516
517
518static bool batadv_nc_hash_compare(const struct hlist_node *node,
519 const void *data2)
520{
521 const struct batadv_nc_path *nc_path1, *nc_path2;
522
523 nc_path1 = container_of(node, struct batadv_nc_path, hash_entry);
524 nc_path2 = data2;
525
526
527 if (!batadv_compare_eth(nc_path1->prev_hop, nc_path2->prev_hop))
528 return false;
529
530 if (!batadv_compare_eth(nc_path1->next_hop, nc_path2->next_hop))
531 return false;
532
533 return true;
534}
535
536
537
538
539
540
541
542
543static struct batadv_nc_path *
544batadv_nc_hash_find(struct batadv_hashtable *hash,
545 void *data)
546{
547 struct hlist_head *head;
548 struct batadv_nc_path *nc_path, *nc_path_tmp = NULL;
549 int index;
550
551 if (!hash)
552 return NULL;
553
554 index = batadv_nc_hash_choose(data, hash->size);
555 head = &hash->table[index];
556
557 rcu_read_lock();
558 hlist_for_each_entry_rcu(nc_path, head, hash_entry) {
559 if (!batadv_nc_hash_compare(&nc_path->hash_entry, data))
560 continue;
561
562 if (!kref_get_unless_zero(&nc_path->refcount))
563 continue;
564
565 nc_path_tmp = nc_path;
566 break;
567 }
568 rcu_read_unlock();
569
570 return nc_path_tmp;
571}
572
573
574
575
576
577static void batadv_nc_send_packet(struct batadv_nc_packet *nc_packet)
578{
579 batadv_send_unicast_skb(nc_packet->skb, nc_packet->neigh_node);
580 nc_packet->skb = NULL;
581 batadv_nc_packet_free(nc_packet, false);
582}
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597static bool batadv_nc_sniffed_purge(struct batadv_priv *bat_priv,
598 struct batadv_nc_path *nc_path,
599 struct batadv_nc_packet *nc_packet)
600{
601 unsigned long timeout = bat_priv->nc.max_buffer_time;
602 bool res = false;
603
604 lockdep_assert_held(&nc_path->packet_list_lock);
605
606
607
608
609 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
610 !batadv_has_timed_out(nc_packet->timestamp, timeout))
611 goto out;
612
613
614 list_del(&nc_packet->list);
615 batadv_nc_packet_free(nc_packet, true);
616
617 res = true;
618
619out:
620 return res;
621}
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636static bool batadv_nc_fwd_flush(struct batadv_priv *bat_priv,
637 struct batadv_nc_path *nc_path,
638 struct batadv_nc_packet *nc_packet)
639{
640 unsigned long timeout = bat_priv->nc.max_fwd_delay;
641
642 lockdep_assert_held(&nc_path->packet_list_lock);
643
644
645
646
647 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
648 !batadv_has_timed_out(nc_packet->timestamp, timeout))
649 return false;
650
651
652 batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
653 batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
654 nc_packet->skb->len + ETH_HLEN);
655 list_del(&nc_packet->list);
656 batadv_nc_send_packet(nc_packet);
657
658 return true;
659}
660
661
662
663
664
665
666
667
668
669
670static void
671batadv_nc_process_nc_paths(struct batadv_priv *bat_priv,
672 struct batadv_hashtable *hash,
673 bool (*process_fn)(struct batadv_priv *,
674 struct batadv_nc_path *,
675 struct batadv_nc_packet *))
676{
677 struct hlist_head *head;
678 struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
679 struct batadv_nc_path *nc_path;
680 bool ret;
681 int i;
682
683 if (!hash)
684 return;
685
686
687 for (i = 0; i < hash->size; i++) {
688 head = &hash->table[i];
689
690
691 rcu_read_lock();
692 hlist_for_each_entry_rcu(nc_path, head, hash_entry) {
693
694 spin_lock_bh(&nc_path->packet_list_lock);
695 list_for_each_entry_safe(nc_packet, nc_packet_tmp,
696 &nc_path->packet_list, list) {
697 ret = process_fn(bat_priv, nc_path, nc_packet);
698 if (!ret)
699 break;
700 }
701 spin_unlock_bh(&nc_path->packet_list_lock);
702 }
703 rcu_read_unlock();
704 }
705}
706
707
708
709
710
711
712static void batadv_nc_worker(struct work_struct *work)
713{
714 struct delayed_work *delayed_work;
715 struct batadv_priv_nc *priv_nc;
716 struct batadv_priv *bat_priv;
717 unsigned long timeout;
718
719 delayed_work = to_delayed_work(work);
720 priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
721 bat_priv = container_of(priv_nc, struct batadv_priv, nc);
722
723 batadv_nc_purge_orig_hash(bat_priv);
724 batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash,
725 batadv_nc_to_purge_nc_path_coding);
726 batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash,
727 batadv_nc_to_purge_nc_path_decoding);
728
729 timeout = bat_priv->nc.max_fwd_delay;
730
731 if (batadv_has_timed_out(bat_priv->nc.timestamp_fwd_flush, timeout)) {
732 batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.coding_hash,
733 batadv_nc_fwd_flush);
734 bat_priv->nc.timestamp_fwd_flush = jiffies;
735 }
736
737 if (batadv_has_timed_out(bat_priv->nc.timestamp_sniffed_purge,
738 bat_priv->nc.max_buffer_time)) {
739 batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.decoding_hash,
740 batadv_nc_sniffed_purge);
741 bat_priv->nc.timestamp_sniffed_purge = jiffies;
742 }
743
744
745 batadv_nc_start_timer(bat_priv);
746}
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761static bool batadv_can_nc_with_orig(struct batadv_priv *bat_priv,
762 struct batadv_orig_node *orig_node,
763 struct batadv_ogm_packet *ogm_packet)
764{
765 struct batadv_orig_ifinfo *orig_ifinfo;
766 u32 last_real_seqno;
767 u8 last_ttl;
768
769 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, BATADV_IF_DEFAULT);
770 if (!orig_ifinfo)
771 return false;
772
773 last_ttl = orig_ifinfo->last_ttl;
774 last_real_seqno = orig_ifinfo->last_real_seqno;
775 batadv_orig_ifinfo_put(orig_ifinfo);
776
777 if (last_real_seqno != ntohl(ogm_packet->seqno))
778 return false;
779 if (last_ttl != ogm_packet->ttl + 1)
780 return false;
781 if (!batadv_compare_eth(ogm_packet->orig, ogm_packet->prev_sender))
782 return false;
783 if (ogm_packet->tq < bat_priv->nc.min_tq)
784 return false;
785
786 return true;
787}
788
789
790
791
792
793
794
795
796
797
798static struct batadv_nc_node *
799batadv_nc_find_nc_node(struct batadv_orig_node *orig_node,
800 struct batadv_orig_node *orig_neigh_node,
801 bool in_coding)
802{
803 struct batadv_nc_node *nc_node, *nc_node_out = NULL;
804 struct list_head *list;
805
806 if (in_coding)
807 list = &orig_neigh_node->in_coding_list;
808 else
809 list = &orig_neigh_node->out_coding_list;
810
811
812 rcu_read_lock();
813 list_for_each_entry_rcu(nc_node, list, list) {
814 if (!batadv_compare_eth(nc_node->addr, orig_node->orig))
815 continue;
816
817 if (!kref_get_unless_zero(&nc_node->refcount))
818 continue;
819
820
821 nc_node_out = nc_node;
822 break;
823 }
824 rcu_read_unlock();
825
826 return nc_node_out;
827}
828
829
830
831
832
833
834
835
836
837
838
839
840static struct batadv_nc_node *
841batadv_nc_get_nc_node(struct batadv_priv *bat_priv,
842 struct batadv_orig_node *orig_node,
843 struct batadv_orig_node *orig_neigh_node,
844 bool in_coding)
845{
846 struct batadv_nc_node *nc_node;
847 spinlock_t *lock;
848 struct list_head *list;
849
850
851 if (in_coding) {
852 lock = &orig_neigh_node->in_coding_list_lock;
853 list = &orig_neigh_node->in_coding_list;
854 } else {
855 lock = &orig_neigh_node->out_coding_list_lock;
856 list = &orig_neigh_node->out_coding_list;
857 }
858
859 spin_lock_bh(lock);
860
861
862 nc_node = batadv_nc_find_nc_node(orig_node, orig_neigh_node, in_coding);
863
864
865 if (nc_node)
866 goto unlock;
867
868 nc_node = kzalloc(sizeof(*nc_node), GFP_ATOMIC);
869 if (!nc_node)
870 goto unlock;
871
872
873 INIT_LIST_HEAD(&nc_node->list);
874 kref_init(&nc_node->refcount);
875 ether_addr_copy(nc_node->addr, orig_node->orig);
876 kref_get(&orig_neigh_node->refcount);
877 nc_node->orig_node = orig_neigh_node;
878
879 batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_node %pM -> %pM\n",
880 nc_node->addr, nc_node->orig_node->orig);
881
882
883 kref_get(&nc_node->refcount);
884 list_add_tail_rcu(&nc_node->list, list);
885
886unlock:
887 spin_unlock_bh(lock);
888
889 return nc_node;
890}
891
892
893
894
895
896
897
898
899
900
901
902void batadv_nc_update_nc_node(struct batadv_priv *bat_priv,
903 struct batadv_orig_node *orig_node,
904 struct batadv_orig_node *orig_neigh_node,
905 struct batadv_ogm_packet *ogm_packet,
906 int is_single_hop_neigh)
907{
908 struct batadv_nc_node *in_nc_node = NULL;
909 struct batadv_nc_node *out_nc_node = NULL;
910
911
912 if (!atomic_read(&bat_priv->network_coding))
913 goto out;
914
915
916 if (!test_bit(BATADV_ORIG_CAPA_HAS_NC, &orig_node->capabilities))
917 goto out;
918
919
920 if (!batadv_can_nc_with_orig(bat_priv, orig_node, ogm_packet) &&
921 !is_single_hop_neigh)
922 goto out;
923
924
925 in_nc_node = batadv_nc_get_nc_node(bat_priv, orig_node,
926 orig_neigh_node, true);
927 if (!in_nc_node)
928 goto out;
929
930 in_nc_node->last_seen = jiffies;
931
932
933 out_nc_node = batadv_nc_get_nc_node(bat_priv, orig_neigh_node,
934 orig_node, false);
935 if (!out_nc_node)
936 goto out;
937
938 out_nc_node->last_seen = jiffies;
939
940out:
941 batadv_nc_node_put(in_nc_node);
942 batadv_nc_node_put(out_nc_node);
943}
944
945
946
947
948
949
950
951
952
953
954
955static struct batadv_nc_path *batadv_nc_get_path(struct batadv_priv *bat_priv,
956 struct batadv_hashtable *hash,
957 u8 *src,
958 u8 *dst)
959{
960 int hash_added;
961 struct batadv_nc_path *nc_path, nc_path_key;
962
963 batadv_nc_hash_key_gen(&nc_path_key, src, dst);
964
965
966 nc_path = batadv_nc_hash_find(hash, (void *)&nc_path_key);
967
968 if (nc_path) {
969
970 nc_path->last_valid = jiffies;
971 return nc_path;
972 }
973
974
975 nc_path = kzalloc(sizeof(*nc_path), GFP_ATOMIC);
976
977 if (!nc_path)
978 return NULL;
979
980
981 INIT_LIST_HEAD(&nc_path->packet_list);
982 spin_lock_init(&nc_path->packet_list_lock);
983 kref_init(&nc_path->refcount);
984 nc_path->last_valid = jiffies;
985 ether_addr_copy(nc_path->next_hop, dst);
986 ether_addr_copy(nc_path->prev_hop, src);
987
988 batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_path %pM -> %pM\n",
989 nc_path->prev_hop,
990 nc_path->next_hop);
991
992
993 kref_get(&nc_path->refcount);
994 hash_added = batadv_hash_add(hash, batadv_nc_hash_compare,
995 batadv_nc_hash_choose, &nc_path_key,
996 &nc_path->hash_entry);
997
998 if (hash_added < 0) {
999 kfree(nc_path);
1000 return NULL;
1001 }
1002
1003 return nc_path;
1004}
1005
1006
1007
1008
1009
1010
1011
1012
1013static u8 batadv_nc_random_weight_tq(u8 tq)
1014{
1015
1016 u8 rand_tq = prandom_u32_max(BATADV_TQ_MAX_VALUE + 1 - tq);
1017
1018
1019 return BATADV_TQ_MAX_VALUE - rand_tq;
1020}
1021
1022
1023
1024
1025
1026
1027
1028static void batadv_nc_memxor(char *dst, const char *src, unsigned int len)
1029{
1030 unsigned int i;
1031
1032 for (i = 0; i < len; ++i)
1033 dst[i] ^= src[i];
1034}
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047static bool batadv_nc_code_packets(struct batadv_priv *bat_priv,
1048 struct sk_buff *skb,
1049 struct ethhdr *ethhdr,
1050 struct batadv_nc_packet *nc_packet,
1051 struct batadv_neigh_node *neigh_node)
1052{
1053 u8 tq_weighted_neigh, tq_weighted_coding, tq_tmp;
1054 struct sk_buff *skb_dest, *skb_src;
1055 struct batadv_unicast_packet *packet1;
1056 struct batadv_unicast_packet *packet2;
1057 struct batadv_coded_packet *coded_packet;
1058 struct batadv_neigh_node *neigh_tmp, *router_neigh, *first_dest;
1059 struct batadv_neigh_node *router_coding = NULL, *second_dest;
1060 struct batadv_neigh_ifinfo *router_neigh_ifinfo = NULL;
1061 struct batadv_neigh_ifinfo *router_coding_ifinfo = NULL;
1062 u8 *first_source, *second_source;
1063 __be32 packet_id1, packet_id2;
1064 size_t count;
1065 bool res = false;
1066 int coding_len;
1067 int unicast_size = sizeof(*packet1);
1068 int coded_size = sizeof(*coded_packet);
1069 int header_add = coded_size - unicast_size;
1070
1071
1072
1073
1074 router_neigh = batadv_orig_router_get(neigh_node->orig_node,
1075 BATADV_IF_DEFAULT);
1076 if (!router_neigh)
1077 goto out;
1078
1079 router_neigh_ifinfo = batadv_neigh_ifinfo_get(router_neigh,
1080 BATADV_IF_DEFAULT);
1081 if (!router_neigh_ifinfo)
1082 goto out;
1083
1084 neigh_tmp = nc_packet->neigh_node;
1085 router_coding = batadv_orig_router_get(neigh_tmp->orig_node,
1086 BATADV_IF_DEFAULT);
1087 if (!router_coding)
1088 goto out;
1089
1090 router_coding_ifinfo = batadv_neigh_ifinfo_get(router_coding,
1091 BATADV_IF_DEFAULT);
1092 if (!router_coding_ifinfo)
1093 goto out;
1094
1095 tq_tmp = router_neigh_ifinfo->bat_iv.tq_avg;
1096 tq_weighted_neigh = batadv_nc_random_weight_tq(tq_tmp);
1097 tq_tmp = router_coding_ifinfo->bat_iv.tq_avg;
1098 tq_weighted_coding = batadv_nc_random_weight_tq(tq_tmp);
1099
1100
1101
1102
1103 if (tq_weighted_neigh >= tq_weighted_coding) {
1104
1105 first_dest = nc_packet->neigh_node;
1106 first_source = nc_packet->nc_path->prev_hop;
1107 second_dest = neigh_node;
1108 second_source = ethhdr->h_source;
1109 packet1 = (struct batadv_unicast_packet *)nc_packet->skb->data;
1110 packet2 = (struct batadv_unicast_packet *)skb->data;
1111 packet_id1 = nc_packet->packet_id;
1112 packet_id2 = batadv_skb_crc32(skb,
1113 skb->data + sizeof(*packet2));
1114 } else {
1115
1116 first_dest = neigh_node;
1117 first_source = ethhdr->h_source;
1118 second_dest = nc_packet->neigh_node;
1119 second_source = nc_packet->nc_path->prev_hop;
1120 packet1 = (struct batadv_unicast_packet *)skb->data;
1121 packet2 = (struct batadv_unicast_packet *)nc_packet->skb->data;
1122 packet_id1 = batadv_skb_crc32(skb,
1123 skb->data + sizeof(*packet1));
1124 packet_id2 = nc_packet->packet_id;
1125 }
1126
1127
1128
1129
1130 if (skb->len <= nc_packet->skb->len) {
1131 skb_dest = nc_packet->skb;
1132 skb_src = skb;
1133 } else {
1134 skb_dest = skb;
1135 skb_src = nc_packet->skb;
1136 }
1137
1138
1139 coding_len = skb_src->len - unicast_size;
1140
1141 if (skb_linearize(skb_dest) < 0 || skb_linearize(skb_src) < 0)
1142 goto out;
1143
1144 skb_push(skb_dest, header_add);
1145
1146 coded_packet = (struct batadv_coded_packet *)skb_dest->data;
1147 skb_reset_mac_header(skb_dest);
1148
1149 coded_packet->packet_type = BATADV_CODED;
1150 coded_packet->version = BATADV_COMPAT_VERSION;
1151 coded_packet->ttl = packet1->ttl;
1152
1153
1154 ether_addr_copy(coded_packet->first_source, first_source);
1155 ether_addr_copy(coded_packet->first_orig_dest, packet1->dest);
1156 coded_packet->first_crc = packet_id1;
1157 coded_packet->first_ttvn = packet1->ttvn;
1158
1159
1160 ether_addr_copy(coded_packet->second_dest, second_dest->addr);
1161 ether_addr_copy(coded_packet->second_source, second_source);
1162 ether_addr_copy(coded_packet->second_orig_dest, packet2->dest);
1163 coded_packet->second_crc = packet_id2;
1164 coded_packet->second_ttl = packet2->ttl;
1165 coded_packet->second_ttvn = packet2->ttvn;
1166 coded_packet->coded_len = htons(coding_len);
1167
1168
1169 batadv_nc_memxor(skb_dest->data + coded_size,
1170 skb_src->data + unicast_size, coding_len);
1171
1172
1173 if (BATADV_SKB_CB(skb_src)->decoded &&
1174 BATADV_SKB_CB(skb_dest)->decoded) {
1175
1176 count = skb_src->len + ETH_HLEN;
1177 count += skb_dest->len + ETH_HLEN;
1178 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE, 2);
1179 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES, count);
1180 } else if (!BATADV_SKB_CB(skb_src)->decoded &&
1181 !BATADV_SKB_CB(skb_dest)->decoded) {
1182
1183 count = skb_src->len + ETH_HLEN;
1184 count += skb_dest->len + ETH_HLEN;
1185 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE, 2);
1186 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES, count);
1187 } else if (BATADV_SKB_CB(skb_src)->decoded &&
1188 !BATADV_SKB_CB(skb_dest)->decoded) {
1189
1190 batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
1191 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
1192 skb_src->len + ETH_HLEN);
1193 batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
1194 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
1195 skb_dest->len + ETH_HLEN);
1196 } else if (!BATADV_SKB_CB(skb_src)->decoded &&
1197 BATADV_SKB_CB(skb_dest)->decoded) {
1198
1199 batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
1200 batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
1201 skb_src->len + ETH_HLEN);
1202 batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
1203 batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
1204 skb_dest->len + ETH_HLEN);
1205 }
1206
1207
1208 consume_skb(skb_src);
1209
1210
1211 nc_packet->skb = NULL;
1212 batadv_nc_packet_free(nc_packet, false);
1213
1214
1215 batadv_send_unicast_skb(skb_dest, first_dest);
1216 res = true;
1217out:
1218 batadv_neigh_node_put(router_neigh);
1219 batadv_neigh_node_put(router_coding);
1220 batadv_neigh_ifinfo_put(router_neigh_ifinfo);
1221 batadv_neigh_ifinfo_put(router_coding_ifinfo);
1222 return res;
1223}
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242static bool batadv_nc_skb_coding_possible(struct sk_buff *skb, u8 *dst, u8 *src)
1243{
1244 if (BATADV_SKB_CB(skb)->decoded && !batadv_compare_eth(dst, src))
1245 return false;
1246 return true;
1247}
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260static struct batadv_nc_packet *
1261batadv_nc_path_search(struct batadv_priv *bat_priv,
1262 struct batadv_nc_node *in_nc_node,
1263 struct batadv_nc_node *out_nc_node,
1264 struct sk_buff *skb,
1265 u8 *eth_dst)
1266{
1267 struct batadv_nc_path *nc_path, nc_path_key;
1268 struct batadv_nc_packet *nc_packet_out = NULL;
1269 struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
1270 struct batadv_hashtable *hash = bat_priv->nc.coding_hash;
1271 int idx;
1272
1273 if (!hash)
1274 return NULL;
1275
1276
1277 batadv_nc_hash_key_gen(&nc_path_key, in_nc_node->addr,
1278 out_nc_node->addr);
1279 idx = batadv_nc_hash_choose(&nc_path_key, hash->size);
1280
1281
1282 rcu_read_lock();
1283 hlist_for_each_entry_rcu(nc_path, &hash->table[idx], hash_entry) {
1284 if (!batadv_compare_eth(nc_path->prev_hop, in_nc_node->addr))
1285 continue;
1286
1287 if (!batadv_compare_eth(nc_path->next_hop, out_nc_node->addr))
1288 continue;
1289
1290 spin_lock_bh(&nc_path->packet_list_lock);
1291 if (list_empty(&nc_path->packet_list)) {
1292 spin_unlock_bh(&nc_path->packet_list_lock);
1293 continue;
1294 }
1295
1296 list_for_each_entry_safe(nc_packet, nc_packet_tmp,
1297 &nc_path->packet_list, list) {
1298 if (!batadv_nc_skb_coding_possible(nc_packet->skb,
1299 eth_dst,
1300 in_nc_node->addr))
1301 continue;
1302
1303
1304 list_del(&nc_packet->list);
1305 nc_packet_out = nc_packet;
1306 break;
1307 }
1308
1309 spin_unlock_bh(&nc_path->packet_list_lock);
1310 break;
1311 }
1312 rcu_read_unlock();
1313
1314 return nc_packet_out;
1315}
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328static struct batadv_nc_packet *
1329batadv_nc_skb_src_search(struct batadv_priv *bat_priv,
1330 struct sk_buff *skb,
1331 u8 *eth_dst,
1332 u8 *eth_src,
1333 struct batadv_nc_node *in_nc_node)
1334{
1335 struct batadv_orig_node *orig_node;
1336 struct batadv_nc_node *out_nc_node;
1337 struct batadv_nc_packet *nc_packet = NULL;
1338
1339 orig_node = batadv_orig_hash_find(bat_priv, eth_src);
1340 if (!orig_node)
1341 return NULL;
1342
1343 rcu_read_lock();
1344 list_for_each_entry_rcu(out_nc_node,
1345 &orig_node->out_coding_list, list) {
1346
1347 if (!batadv_nc_skb_coding_possible(skb,
1348 out_nc_node->addr, eth_src))
1349 continue;
1350
1351
1352 nc_packet = batadv_nc_path_search(bat_priv, in_nc_node,
1353 out_nc_node, skb, eth_dst);
1354 if (nc_packet)
1355 break;
1356 }
1357 rcu_read_unlock();
1358
1359 batadv_orig_node_put(orig_node);
1360 return nc_packet;
1361}
1362
1363
1364
1365
1366
1367
1368
1369
1370static void batadv_nc_skb_store_before_coding(struct batadv_priv *bat_priv,
1371 struct sk_buff *skb,
1372 u8 *eth_dst_new)
1373{
1374 struct ethhdr *ethhdr;
1375
1376
1377 skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
1378 if (!skb)
1379 return;
1380
1381
1382 ethhdr = eth_hdr(skb);
1383 ether_addr_copy(ethhdr->h_source, ethhdr->h_dest);
1384 ether_addr_copy(ethhdr->h_dest, eth_dst_new);
1385
1386
1387 skb_push(skb, ETH_HLEN);
1388
1389
1390 batadv_nc_skb_store_for_decoding(bat_priv, skb);
1391
1392
1393
1394
1395 consume_skb(skb);
1396}
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411static bool batadv_nc_skb_dst_search(struct sk_buff *skb,
1412 struct batadv_neigh_node *neigh_node,
1413 struct ethhdr *ethhdr)
1414{
1415 struct net_device *netdev = neigh_node->if_incoming->soft_iface;
1416 struct batadv_priv *bat_priv = netdev_priv(netdev);
1417 struct batadv_orig_node *orig_node = neigh_node->orig_node;
1418 struct batadv_nc_node *nc_node;
1419 struct batadv_nc_packet *nc_packet = NULL;
1420
1421 rcu_read_lock();
1422 list_for_each_entry_rcu(nc_node, &orig_node->in_coding_list, list) {
1423
1424 nc_packet = batadv_nc_skb_src_search(bat_priv, skb,
1425 neigh_node->addr,
1426 ethhdr->h_source, nc_node);
1427
1428
1429 if (nc_packet)
1430 break;
1431 }
1432 rcu_read_unlock();
1433
1434 if (!nc_packet)
1435 return false;
1436
1437
1438 batadv_nc_skb_store_before_coding(bat_priv, skb,
1439 neigh_node->addr);
1440 batadv_nc_skb_store_before_coding(bat_priv, nc_packet->skb,
1441 nc_packet->neigh_node->addr);
1442
1443
1444 if (batadv_nc_code_packets(bat_priv, skb, ethhdr, nc_packet,
1445 neigh_node))
1446 return true;
1447
1448
1449
1450
1451
1452 batadv_nc_send_packet(nc_packet);
1453 return false;
1454}
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465static bool batadv_nc_skb_add_to_path(struct sk_buff *skb,
1466 struct batadv_nc_path *nc_path,
1467 struct batadv_neigh_node *neigh_node,
1468 __be32 packet_id)
1469{
1470 struct batadv_nc_packet *nc_packet;
1471
1472 nc_packet = kzalloc(sizeof(*nc_packet), GFP_ATOMIC);
1473 if (!nc_packet)
1474 return false;
1475
1476
1477 nc_packet->timestamp = jiffies;
1478 nc_packet->packet_id = packet_id;
1479 nc_packet->skb = skb;
1480 nc_packet->neigh_node = neigh_node;
1481 nc_packet->nc_path = nc_path;
1482
1483
1484 spin_lock_bh(&nc_path->packet_list_lock);
1485 list_add_tail(&nc_packet->list, &nc_path->packet_list);
1486 spin_unlock_bh(&nc_path->packet_list_lock);
1487
1488 return true;
1489}
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499bool batadv_nc_skb_forward(struct sk_buff *skb,
1500 struct batadv_neigh_node *neigh_node)
1501{
1502 const struct net_device *netdev = neigh_node->if_incoming->soft_iface;
1503 struct batadv_priv *bat_priv = netdev_priv(netdev);
1504 struct batadv_unicast_packet *packet;
1505 struct batadv_nc_path *nc_path;
1506 struct ethhdr *ethhdr = eth_hdr(skb);
1507 __be32 packet_id;
1508 u8 *payload;
1509
1510
1511 if (!atomic_read(&bat_priv->network_coding))
1512 goto out;
1513
1514
1515 payload = skb_network_header(skb);
1516 packet = (struct batadv_unicast_packet *)payload;
1517 if (packet->packet_type != BATADV_UNICAST)
1518 goto out;
1519
1520
1521 if (batadv_nc_skb_dst_search(skb, neigh_node, ethhdr))
1522 return true;
1523
1524
1525 nc_path = batadv_nc_get_path(bat_priv,
1526 bat_priv->nc.coding_hash,
1527 ethhdr->h_source,
1528 neigh_node->addr);
1529
1530 if (!nc_path)
1531 goto out;
1532
1533
1534 packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
1535 if (!batadv_nc_skb_add_to_path(skb, nc_path, neigh_node, packet_id))
1536 goto free_nc_path;
1537
1538
1539 return true;
1540
1541free_nc_path:
1542 batadv_nc_path_put(nc_path);
1543out:
1544
1545 return false;
1546}
1547
1548
1549
1550
1551
1552
1553
1554void batadv_nc_skb_store_for_decoding(struct batadv_priv *bat_priv,
1555 struct sk_buff *skb)
1556{
1557 struct batadv_unicast_packet *packet;
1558 struct batadv_nc_path *nc_path;
1559 struct ethhdr *ethhdr = eth_hdr(skb);
1560 __be32 packet_id;
1561 u8 *payload;
1562
1563
1564 if (!atomic_read(&bat_priv->network_coding))
1565 goto out;
1566
1567
1568 payload = skb_network_header(skb);
1569 packet = (struct batadv_unicast_packet *)payload;
1570 if (packet->packet_type != BATADV_UNICAST)
1571 goto out;
1572
1573
1574 nc_path = batadv_nc_get_path(bat_priv,
1575 bat_priv->nc.decoding_hash,
1576 ethhdr->h_source,
1577 ethhdr->h_dest);
1578
1579 if (!nc_path)
1580 goto out;
1581
1582
1583 skb = skb_clone(skb, GFP_ATOMIC);
1584 if (unlikely(!skb))
1585 goto free_nc_path;
1586
1587 if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
1588 goto free_skb;
1589
1590 if (unlikely(!skb_pull_rcsum(skb, ETH_HLEN)))
1591 goto free_skb;
1592
1593
1594 packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
1595 if (!batadv_nc_skb_add_to_path(skb, nc_path, NULL, packet_id))
1596 goto free_skb;
1597
1598 batadv_inc_counter(bat_priv, BATADV_CNT_NC_BUFFER);
1599 return;
1600
1601free_skb:
1602 kfree_skb(skb);
1603free_nc_path:
1604 batadv_nc_path_put(nc_path);
1605out:
1606 return;
1607}
1608
1609
1610
1611
1612
1613
1614
1615void batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
1616 struct sk_buff *skb)
1617{
1618 struct ethhdr *ethhdr = eth_hdr(skb);
1619
1620 if (batadv_is_my_mac(bat_priv, ethhdr->h_dest))
1621 return;
1622
1623
1624 skb_push(skb, ETH_HLEN);
1625
1626 batadv_nc_skb_store_for_decoding(bat_priv, skb);
1627}
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639static struct batadv_unicast_packet *
1640batadv_nc_skb_decode_packet(struct batadv_priv *bat_priv, struct sk_buff *skb,
1641 struct batadv_nc_packet *nc_packet)
1642{
1643 const int h_size = sizeof(struct batadv_unicast_packet);
1644 const int h_diff = sizeof(struct batadv_coded_packet) - h_size;
1645 struct batadv_unicast_packet *unicast_packet;
1646 struct batadv_coded_packet coded_packet_tmp;
1647 struct ethhdr *ethhdr, ethhdr_tmp;
1648 u8 *orig_dest, ttl, ttvn;
1649 unsigned int coding_len;
1650 int err;
1651
1652
1653 memcpy(&coded_packet_tmp, skb->data, sizeof(coded_packet_tmp));
1654 memcpy(ðhdr_tmp, skb_mac_header(skb), sizeof(ethhdr_tmp));
1655
1656 if (skb_cow(skb, 0) < 0)
1657 return NULL;
1658
1659 if (unlikely(!skb_pull_rcsum(skb, h_diff)))
1660 return NULL;
1661
1662
1663
1664
1665 skb_set_mac_header(skb, -ETH_HLEN);
1666 skb_reset_network_header(skb);
1667
1668
1669 ethhdr = eth_hdr(skb);
1670 *ethhdr = ethhdr_tmp;
1671
1672
1673
1674
1675 if (batadv_is_my_mac(bat_priv, coded_packet_tmp.second_dest)) {
1676
1677
1678
1679
1680 ether_addr_copy(ethhdr->h_dest, coded_packet_tmp.second_dest);
1681 skb->pkt_type = PACKET_HOST;
1682
1683 orig_dest = coded_packet_tmp.second_orig_dest;
1684 ttl = coded_packet_tmp.second_ttl;
1685 ttvn = coded_packet_tmp.second_ttvn;
1686 } else {
1687 orig_dest = coded_packet_tmp.first_orig_dest;
1688 ttl = coded_packet_tmp.ttl;
1689 ttvn = coded_packet_tmp.first_ttvn;
1690 }
1691
1692 coding_len = ntohs(coded_packet_tmp.coded_len);
1693
1694 if (coding_len > skb->len)
1695 return NULL;
1696
1697
1698
1699
1700 batadv_nc_memxor(skb->data + h_size,
1701 nc_packet->skb->data + h_size,
1702 coding_len);
1703
1704
1705 if (nc_packet->skb->len > coding_len + h_size) {
1706 err = pskb_trim_rcsum(skb, coding_len + h_size);
1707 if (err)
1708 return NULL;
1709 }
1710
1711
1712 unicast_packet = (struct batadv_unicast_packet *)skb->data;
1713 unicast_packet->packet_type = BATADV_UNICAST;
1714 unicast_packet->version = BATADV_COMPAT_VERSION;
1715 unicast_packet->ttl = ttl;
1716 ether_addr_copy(unicast_packet->dest, orig_dest);
1717 unicast_packet->ttvn = ttvn;
1718
1719 batadv_nc_packet_free(nc_packet, false);
1720 return unicast_packet;
1721}
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732static struct batadv_nc_packet *
1733batadv_nc_find_decoding_packet(struct batadv_priv *bat_priv,
1734 struct ethhdr *ethhdr,
1735 struct batadv_coded_packet *coded)
1736{
1737 struct batadv_hashtable *hash = bat_priv->nc.decoding_hash;
1738 struct batadv_nc_packet *tmp_nc_packet, *nc_packet = NULL;
1739 struct batadv_nc_path *nc_path, nc_path_key;
1740 u8 *dest, *source;
1741 __be32 packet_id;
1742 int index;
1743
1744 if (!hash)
1745 return NULL;
1746
1747
1748 dest = ethhdr->h_source;
1749 if (!batadv_is_my_mac(bat_priv, coded->second_dest)) {
1750 source = coded->second_source;
1751 packet_id = coded->second_crc;
1752 } else {
1753 source = coded->first_source;
1754 packet_id = coded->first_crc;
1755 }
1756
1757 batadv_nc_hash_key_gen(&nc_path_key, source, dest);
1758 index = batadv_nc_hash_choose(&nc_path_key, hash->size);
1759
1760
1761 rcu_read_lock();
1762 hlist_for_each_entry_rcu(nc_path, &hash->table[index], hash_entry) {
1763
1764 spin_lock_bh(&nc_path->packet_list_lock);
1765 list_for_each_entry(tmp_nc_packet,
1766 &nc_path->packet_list, list) {
1767 if (packet_id == tmp_nc_packet->packet_id) {
1768 list_del(&tmp_nc_packet->list);
1769
1770 nc_packet = tmp_nc_packet;
1771 break;
1772 }
1773 }
1774 spin_unlock_bh(&nc_path->packet_list_lock);
1775
1776 if (nc_packet)
1777 break;
1778 }
1779 rcu_read_unlock();
1780
1781 if (!nc_packet)
1782 batadv_dbg(BATADV_DBG_NC, bat_priv,
1783 "No decoding packet found for %u\n", packet_id);
1784
1785 return nc_packet;
1786}
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
1798 struct batadv_hard_iface *recv_if)
1799{
1800 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1801 struct batadv_unicast_packet *unicast_packet;
1802 struct batadv_coded_packet *coded_packet;
1803 struct batadv_nc_packet *nc_packet;
1804 struct ethhdr *ethhdr;
1805 int hdr_size = sizeof(*coded_packet);
1806
1807
1808 if (!atomic_read(&bat_priv->network_coding))
1809 goto free_skb;
1810
1811
1812 if (unlikely(!pskb_may_pull(skb, hdr_size)))
1813 goto free_skb;
1814
1815 coded_packet = (struct batadv_coded_packet *)skb->data;
1816 ethhdr = eth_hdr(skb);
1817
1818
1819 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest) &&
1820 !batadv_is_my_mac(bat_priv, coded_packet->second_dest))
1821 goto free_skb;
1822
1823
1824 if (batadv_is_my_mac(bat_priv, coded_packet->second_dest))
1825 batadv_inc_counter(bat_priv, BATADV_CNT_NC_SNIFFED);
1826
1827 nc_packet = batadv_nc_find_decoding_packet(bat_priv, ethhdr,
1828 coded_packet);
1829 if (!nc_packet) {
1830 batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
1831 goto free_skb;
1832 }
1833
1834
1835 if (skb_linearize(skb) < 0)
1836 goto free_nc_packet;
1837
1838 if (skb_linearize(nc_packet->skb) < 0)
1839 goto free_nc_packet;
1840
1841
1842 unicast_packet = batadv_nc_skb_decode_packet(bat_priv, skb, nc_packet);
1843 if (!unicast_packet) {
1844 batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
1845 goto free_nc_packet;
1846 }
1847
1848
1849 BATADV_SKB_CB(skb)->decoded = true;
1850 batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE);
1851 batadv_add_counter(bat_priv, BATADV_CNT_NC_DECODE_BYTES,
1852 skb->len + ETH_HLEN);
1853 return batadv_recv_unicast_packet(skb, recv_if);
1854
1855free_nc_packet:
1856 batadv_nc_packet_free(nc_packet, true);
1857free_skb:
1858 kfree_skb(skb);
1859
1860 return NET_RX_DROP;
1861}
1862
1863
1864
1865
1866
1867void batadv_nc_mesh_free(struct batadv_priv *bat_priv)
1868{
1869 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_NC, 1);
1870 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_NC, 1);
1871 cancel_delayed_work_sync(&bat_priv->nc.work);
1872
1873 batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
1874 batadv_hash_destroy(bat_priv->nc.coding_hash);
1875 batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash, NULL);
1876 batadv_hash_destroy(bat_priv->nc.decoding_hash);
1877}
1878