1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include "distributed-arp-table.h"
19#include "main.h"
20
21#include <linux/atomic.h>
22#include <linux/bitops.h>
23#include <linux/byteorder/generic.h>
24#include <linux/errno.h>
25#include <linux/etherdevice.h>
26#include <linux/fs.h>
27#include <linux/if_arp.h>
28#include <linux/if_ether.h>
29#include <linux/if_vlan.h>
30#include <linux/in.h>
31#include <linux/jiffies.h>
32#include <linux/kernel.h>
33#include <linux/list.h>
34#include <linux/rculist.h>
35#include <linux/rcupdate.h>
36#include <linux/seq_file.h>
37#include <linux/skbuff.h>
38#include <linux/slab.h>
39#include <linux/spinlock.h>
40#include <linux/stddef.h>
41#include <linux/string.h>
42#include <linux/workqueue.h>
43#include <net/arp.h>
44
45#include "hard-interface.h"
46#include "hash.h"
47#include "originator.h"
48#include "send.h"
49#include "translation-table.h"
50
51static void batadv_dat_purge(struct work_struct *work);
52
53
54
55
56
57static void batadv_dat_start_timer(struct batadv_priv *bat_priv)
58{
59 INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge);
60 queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work,
61 msecs_to_jiffies(10000));
62}
63
64
65
66
67
68
69static void batadv_dat_entry_free_ref(struct batadv_dat_entry *dat_entry)
70{
71 if (atomic_dec_and_test(&dat_entry->refcount))
72 kfree_rcu(dat_entry, rcu);
73}
74
75
76
77
78
79
80
81static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry)
82{
83 return batadv_has_timed_out(dat_entry->last_update,
84 BATADV_DAT_ENTRY_TIMEOUT);
85}
86
87
88
89
90
91
92
93
94
95
96
97
98static void __batadv_dat_purge(struct batadv_priv *bat_priv,
99 bool (*to_purge)(struct batadv_dat_entry *))
100{
101 spinlock_t *list_lock;
102 struct batadv_dat_entry *dat_entry;
103 struct hlist_node *node_tmp;
104 struct hlist_head *head;
105 u32 i;
106
107 if (!bat_priv->dat.hash)
108 return;
109
110 for (i = 0; i < bat_priv->dat.hash->size; i++) {
111 head = &bat_priv->dat.hash->table[i];
112 list_lock = &bat_priv->dat.hash->list_locks[i];
113
114 spin_lock_bh(list_lock);
115 hlist_for_each_entry_safe(dat_entry, node_tmp, head,
116 hash_entry) {
117
118
119
120 if (to_purge && !to_purge(dat_entry))
121 continue;
122
123 hlist_del_rcu(&dat_entry->hash_entry);
124 batadv_dat_entry_free_ref(dat_entry);
125 }
126 spin_unlock_bh(list_lock);
127 }
128}
129
130
131
132
133
134
135static void batadv_dat_purge(struct work_struct *work)
136{
137 struct delayed_work *delayed_work;
138 struct batadv_priv_dat *priv_dat;
139 struct batadv_priv *bat_priv;
140
141 delayed_work = container_of(work, struct delayed_work, work);
142 priv_dat = container_of(delayed_work, struct batadv_priv_dat, work);
143 bat_priv = container_of(priv_dat, struct batadv_priv, dat);
144
145 __batadv_dat_purge(bat_priv, batadv_dat_to_purge);
146 batadv_dat_start_timer(bat_priv);
147}
148
149
150
151
152
153
154
155
156static int batadv_compare_dat(const struct hlist_node *node, const void *data2)
157{
158 const void *data1 = container_of(node, struct batadv_dat_entry,
159 hash_entry);
160
161 return memcmp(data1, data2, sizeof(__be32)) == 0 ? 1 : 0;
162}
163
164
165
166
167
168
169
170
171static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)
172{
173 u8 *addr;
174
175 addr = (u8 *)(skb->data + hdr_size);
176 addr += ETH_HLEN + sizeof(struct arphdr);
177
178 return addr;
179}
180
181
182
183
184
185
186
187
188static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
189{
190 return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
191}
192
193
194
195
196
197
198
199
200static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)
201{
202 return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4;
203}
204
205
206
207
208
209
210
211
212static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
213{
214 return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4);
215}
216
217
218
219
220
221
222
223
224static u32 batadv_hash_dat(const void *data, u32 size)
225{
226 u32 hash = 0;
227 const struct batadv_dat_entry *dat = data;
228 const unsigned char *key;
229 u32 i;
230
231 key = (const unsigned char *)&dat->ip;
232 for (i = 0; i < sizeof(dat->ip); i++) {
233 hash += key[i];
234 hash += (hash << 10);
235 hash ^= (hash >> 6);
236 }
237
238 key = (const unsigned char *)&dat->vid;
239 for (i = 0; i < sizeof(dat->vid); i++) {
240 hash += key[i];
241 hash += (hash << 10);
242 hash ^= (hash >> 6);
243 }
244
245 hash += (hash << 3);
246 hash ^= (hash >> 11);
247 hash += (hash << 15);
248
249 return hash % size;
250}
251
252
253
254
255
256
257
258
259
260
261static struct batadv_dat_entry *
262batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip,
263 unsigned short vid)
264{
265 struct hlist_head *head;
266 struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL;
267 struct batadv_hashtable *hash = bat_priv->dat.hash;
268 u32 index;
269
270 if (!hash)
271 return NULL;
272
273 to_find.ip = ip;
274 to_find.vid = vid;
275
276 index = batadv_hash_dat(&to_find, hash->size);
277 head = &hash->table[index];
278
279 rcu_read_lock();
280 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
281 if (dat_entry->ip != ip)
282 continue;
283
284 if (!atomic_inc_not_zero(&dat_entry->refcount))
285 continue;
286
287 dat_entry_tmp = dat_entry;
288 break;
289 }
290 rcu_read_unlock();
291
292 return dat_entry_tmp;
293}
294
295
296
297
298
299
300
301
302static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
303 u8 *mac_addr, unsigned short vid)
304{
305 struct batadv_dat_entry *dat_entry;
306 int hash_added;
307
308 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid);
309
310 if (dat_entry) {
311 if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr))
312 ether_addr_copy(dat_entry->mac_addr, mac_addr);
313 dat_entry->last_update = jiffies;
314 batadv_dbg(BATADV_DBG_DAT, bat_priv,
315 "Entry updated: %pI4 %pM (vid: %d)\n",
316 &dat_entry->ip, dat_entry->mac_addr,
317 BATADV_PRINT_VID(vid));
318 goto out;
319 }
320
321 dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC);
322 if (!dat_entry)
323 goto out;
324
325 dat_entry->ip = ip;
326 dat_entry->vid = vid;
327 ether_addr_copy(dat_entry->mac_addr, mac_addr);
328 dat_entry->last_update = jiffies;
329 atomic_set(&dat_entry->refcount, 2);
330
331 hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat,
332 batadv_hash_dat, dat_entry,
333 &dat_entry->hash_entry);
334
335 if (unlikely(hash_added != 0)) {
336
337 batadv_dat_entry_free_ref(dat_entry);
338 goto out;
339 }
340
341 batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n",
342 &dat_entry->ip, dat_entry->mac_addr, BATADV_PRINT_VID(vid));
343
344out:
345 if (dat_entry)
346 batadv_dat_entry_free_ref(dat_entry);
347}
348
349#ifdef CONFIG_BATMAN_ADV_DEBUG
350
351
352
353
354
355
356
357
358
359static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
360 u16 type, int hdr_size, char *msg)
361{
362 struct batadv_unicast_4addr_packet *unicast_4addr_packet;
363 struct batadv_bcast_packet *bcast_pkt;
364 u8 *orig_addr;
365 __be32 ip_src, ip_dst;
366
367 if (msg)
368 batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
369
370 ip_src = batadv_arp_ip_src(skb, hdr_size);
371 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
372 batadv_dbg(BATADV_DBG_DAT, bat_priv,
373 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
374 batadv_arp_hw_src(skb, hdr_size), &ip_src,
375 batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
376
377 if (hdr_size == 0)
378 return;
379
380 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
381
382 switch (unicast_4addr_packet->u.packet_type) {
383 case BATADV_UNICAST:
384 batadv_dbg(BATADV_DBG_DAT, bat_priv,
385 "* encapsulated within a UNICAST packet\n");
386 break;
387 case BATADV_UNICAST_4ADDR:
388 batadv_dbg(BATADV_DBG_DAT, bat_priv,
389 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
390 unicast_4addr_packet->src);
391 switch (unicast_4addr_packet->subtype) {
392 case BATADV_P_DAT_DHT_PUT:
393 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
394 break;
395 case BATADV_P_DAT_DHT_GET:
396 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
397 break;
398 case BATADV_P_DAT_CACHE_REPLY:
399 batadv_dbg(BATADV_DBG_DAT, bat_priv,
400 "* type: DAT_CACHE_REPLY\n");
401 break;
402 case BATADV_P_DATA:
403 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n");
404 break;
405 default:
406 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n",
407 unicast_4addr_packet->u.packet_type);
408 }
409 break;
410 case BATADV_BCAST:
411 bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet;
412 orig_addr = bcast_pkt->orig;
413 batadv_dbg(BATADV_DBG_DAT, bat_priv,
414 "* encapsulated within a BCAST packet (src: %pM)\n",
415 orig_addr);
416 break;
417 default:
418 batadv_dbg(BATADV_DBG_DAT, bat_priv,
419 "* encapsulated within an unknown packet type (0x%x)\n",
420 unicast_4addr_packet->u.packet_type);
421 }
422}
423
424#else
425
426static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
427 u16 type, int hdr_size, char *msg)
428{
429}
430
431#endif
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res,
447 int select, batadv_dat_addr_t tmp_max,
448 batadv_dat_addr_t max,
449 batadv_dat_addr_t last_max,
450 struct batadv_orig_node *candidate,
451 struct batadv_orig_node *max_orig_node)
452{
453 bool ret = false;
454 int j;
455
456
457 if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities))
458 goto out;
459
460
461 for (j = 0; j < select; j++)
462 if (res[j].orig_node == candidate)
463 break;
464
465 if (j < select)
466 goto out;
467
468 if (tmp_max > last_max)
469 goto out;
470
471
472
473 if (tmp_max < max)
474 goto out;
475
476
477
478 if ((tmp_max == max) && max_orig_node &&
479 (batadv_compare_eth(candidate->orig, max_orig_node->orig) > 0))
480 goto out;
481
482 ret = true;
483out:
484 return ret;
485}
486
487
488
489
490
491
492
493
494
495static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
496 struct batadv_dat_candidate *cands,
497 int select, batadv_dat_addr_t ip_key,
498 batadv_dat_addr_t *last_max)
499{
500 batadv_dat_addr_t max = 0;
501 batadv_dat_addr_t tmp_max = 0;
502 struct batadv_orig_node *orig_node, *max_orig_node = NULL;
503 struct batadv_hashtable *hash = bat_priv->orig_hash;
504 struct hlist_head *head;
505 int i;
506
507
508
509
510 cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
511
512
513
514
515 for (i = 0; i < hash->size; i++) {
516 head = &hash->table[i];
517
518 rcu_read_lock();
519 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
520
521 tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
522 ip_key;
523
524 if (!batadv_is_orig_node_eligible(cands, select,
525 tmp_max, max,
526 *last_max, orig_node,
527 max_orig_node))
528 continue;
529
530 if (!atomic_inc_not_zero(&orig_node->refcount))
531 continue;
532
533 max = tmp_max;
534 if (max_orig_node)
535 batadv_orig_node_free_ref(max_orig_node);
536 max_orig_node = orig_node;
537 }
538 rcu_read_unlock();
539 }
540 if (max_orig_node) {
541 cands[select].type = BATADV_DAT_CANDIDATE_ORIG;
542 cands[select].orig_node = max_orig_node;
543 batadv_dbg(BATADV_DBG_DAT, bat_priv,
544 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
545 select, max_orig_node->orig, max_orig_node->dat_addr,
546 max);
547 }
548 *last_max = max;
549}
550
551
552
553
554
555
556
557
558
559
560
561
562
563static struct batadv_dat_candidate *
564batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst)
565{
566 int select;
567 batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key;
568 struct batadv_dat_candidate *res;
569 struct batadv_dat_entry dat;
570
571 if (!bat_priv->orig_hash)
572 return NULL;
573
574 res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res),
575 GFP_ATOMIC);
576 if (!res)
577 return NULL;
578
579 dat.ip = ip_dst;
580 dat.vid = 0;
581 ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat,
582 BATADV_DAT_ADDR_MAX);
583
584 batadv_dbg(BATADV_DBG_DAT, bat_priv,
585 "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst,
586 ip_key);
587
588 for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
589 batadv_choose_next_candidate(bat_priv, res, select, ip_key,
590 &last_max);
591
592 return res;
593}
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608static bool batadv_dat_send_data(struct batadv_priv *bat_priv,
609 struct sk_buff *skb, __be32 ip,
610 int packet_subtype)
611{
612 int i;
613 bool ret = false;
614 int send_status;
615 struct batadv_neigh_node *neigh_node = NULL;
616 struct sk_buff *tmp_skb;
617 struct batadv_dat_candidate *cand;
618
619 cand = batadv_dat_select_candidates(bat_priv, ip);
620 if (!cand)
621 goto out;
622
623 batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
624
625 for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
626 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
627 continue;
628
629 neigh_node = batadv_orig_router_get(cand[i].orig_node,
630 BATADV_IF_DEFAULT);
631 if (!neigh_node)
632 goto free_orig;
633
634 tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
635 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
636 cand[i].orig_node,
637 packet_subtype)) {
638 kfree_skb(tmp_skb);
639 goto free_neigh;
640 }
641
642 send_status = batadv_send_skb_packet(tmp_skb,
643 neigh_node->if_incoming,
644 neigh_node->addr);
645 if (send_status == NET_XMIT_SUCCESS) {
646
647 switch (packet_subtype) {
648 case BATADV_P_DAT_DHT_GET:
649 batadv_inc_counter(bat_priv,
650 BATADV_CNT_DAT_GET_TX);
651 break;
652 case BATADV_P_DAT_DHT_PUT:
653 batadv_inc_counter(bat_priv,
654 BATADV_CNT_DAT_PUT_TX);
655 break;
656 }
657
658
659 ret = true;
660 }
661free_neigh:
662 batadv_neigh_node_free_ref(neigh_node);
663free_orig:
664 batadv_orig_node_free_ref(cand[i].orig_node);
665 }
666
667out:
668 kfree(cand);
669 return ret;
670}
671
672
673
674
675
676
677static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
678{
679 char dat_mode;
680
681 dat_mode = atomic_read(&bat_priv->distributed_arp_table);
682
683 switch (dat_mode) {
684 case 0:
685 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
686 break;
687 case 1:
688 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
689 NULL, 0);
690 break;
691 }
692}
693
694
695
696
697
698
699void batadv_dat_status_update(struct net_device *net_dev)
700{
701 struct batadv_priv *bat_priv = netdev_priv(net_dev);
702
703 batadv_dat_tvlv_container_update(bat_priv);
704}
705
706
707
708
709
710
711
712
713
714static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
715 struct batadv_orig_node *orig,
716 u8 flags,
717 void *tvlv_value, u16 tvlv_value_len)
718{
719 if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
720 clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
721 else
722 set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
723}
724
725
726
727
728
729static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
730{
731 if (!bat_priv->dat.hash)
732 return;
733
734 __batadv_dat_purge(bat_priv, NULL);
735
736 batadv_hash_destroy(bat_priv->dat.hash);
737
738 bat_priv->dat.hash = NULL;
739}
740
741
742
743
744
745int batadv_dat_init(struct batadv_priv *bat_priv)
746{
747 if (bat_priv->dat.hash)
748 return 0;
749
750 bat_priv->dat.hash = batadv_hash_new(1024);
751
752 if (!bat_priv->dat.hash)
753 return -ENOMEM;
754
755 batadv_dat_start_timer(bat_priv);
756
757 batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
758 NULL, BATADV_TVLV_DAT, 1,
759 BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
760 batadv_dat_tvlv_container_update(bat_priv);
761 return 0;
762}
763
764
765
766
767
768void batadv_dat_free(struct batadv_priv *bat_priv)
769{
770 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
771 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
772
773 cancel_delayed_work_sync(&bat_priv->dat.work);
774
775 batadv_dat_hash_free(bat_priv);
776}
777
778
779
780
781
782
783int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
784{
785 struct net_device *net_dev = (struct net_device *)seq->private;
786 struct batadv_priv *bat_priv = netdev_priv(net_dev);
787 struct batadv_hashtable *hash = bat_priv->dat.hash;
788 struct batadv_dat_entry *dat_entry;
789 struct batadv_hard_iface *primary_if;
790 struct hlist_head *head;
791 unsigned long last_seen_jiffies;
792 int last_seen_msecs, last_seen_secs, last_seen_mins;
793 u32 i;
794
795 primary_if = batadv_seq_print_text_primary_if_get(seq);
796 if (!primary_if)
797 goto out;
798
799 seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name);
800 seq_printf(seq, " %-7s %-9s %4s %11s\n", "IPv4",
801 "MAC", "VID", "last-seen");
802
803 for (i = 0; i < hash->size; i++) {
804 head = &hash->table[i];
805
806 rcu_read_lock();
807 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
808 last_seen_jiffies = jiffies - dat_entry->last_update;
809 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
810 last_seen_mins = last_seen_msecs / 60000;
811 last_seen_msecs = last_seen_msecs % 60000;
812 last_seen_secs = last_seen_msecs / 1000;
813
814 seq_printf(seq, " * %15pI4 %14pM %4i %6i:%02i\n",
815 &dat_entry->ip, dat_entry->mac_addr,
816 BATADV_PRINT_VID(dat_entry->vid),
817 last_seen_mins, last_seen_secs);
818 }
819 rcu_read_unlock();
820 }
821
822out:
823 if (primary_if)
824 batadv_hardif_free_ref(primary_if);
825 return 0;
826}
827
828
829
830
831
832
833
834
835
836static u16 batadv_arp_get_type(struct batadv_priv *bat_priv,
837 struct sk_buff *skb, int hdr_size)
838{
839 struct arphdr *arphdr;
840 struct ethhdr *ethhdr;
841 __be32 ip_src, ip_dst;
842 u8 *hw_src, *hw_dst;
843 u16 type = 0;
844
845
846 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
847 goto out;
848
849 ethhdr = (struct ethhdr *)(skb->data + hdr_size);
850
851 if (ethhdr->h_proto != htons(ETH_P_ARP))
852 goto out;
853
854
855 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
856 arp_hdr_len(skb->dev))))
857 goto out;
858
859 arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
860
861
862 if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
863 goto out;
864
865 if (arphdr->ar_pro != htons(ETH_P_IP))
866 goto out;
867
868 if (arphdr->ar_hln != ETH_ALEN)
869 goto out;
870
871 if (arphdr->ar_pln != 4)
872 goto out;
873
874
875
876
877 ip_src = batadv_arp_ip_src(skb, hdr_size);
878 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
879 if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
880 ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
881 ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
882 ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
883 goto out;
884
885 hw_src = batadv_arp_hw_src(skb, hdr_size);
886 if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
887 goto out;
888
889
890 if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
891 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
892 if (is_zero_ether_addr(hw_dst) ||
893 is_multicast_ether_addr(hw_dst))
894 goto out;
895 }
896
897 type = ntohs(arphdr->ar_op);
898out:
899 return type;
900}
901
902
903
904
905
906
907
908
909
910static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
911{
912 unsigned short vid;
913
914 vid = batadv_get_vid(skb, *hdr_size);
915
916
917
918
919
920
921 if (vid & BATADV_VLAN_HAS_TAG)
922 *hdr_size += VLAN_HLEN;
923
924 return vid;
925}
926
927
928
929
930
931
932
933
934
935
936
937bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
938 struct sk_buff *skb)
939{
940 u16 type = 0;
941 __be32 ip_dst, ip_src;
942 u8 *hw_src;
943 bool ret = false;
944 struct batadv_dat_entry *dat_entry = NULL;
945 struct sk_buff *skb_new;
946 int hdr_size = 0;
947 unsigned short vid;
948
949 if (!atomic_read(&bat_priv->distributed_arp_table))
950 goto out;
951
952 vid = batadv_dat_get_vid(skb, &hdr_size);
953
954 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
955
956
957
958 if (type != ARPOP_REQUEST)
959 goto out;
960
961 batadv_dbg_arp(bat_priv, skb, type, hdr_size,
962 "Parsing outgoing ARP REQUEST");
963
964 ip_src = batadv_arp_ip_src(skb, hdr_size);
965 hw_src = batadv_arp_hw_src(skb, hdr_size);
966 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
967
968 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
969
970 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
971 if (dat_entry) {
972
973
974
975
976
977
978
979
980 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
981 ret = true;
982 goto out;
983 }
984
985 skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
986 bat_priv->soft_iface, ip_dst, hw_src,
987 dat_entry->mac_addr, hw_src);
988 if (!skb_new)
989 goto out;
990
991 if (vid & BATADV_VLAN_HAS_TAG)
992 skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q),
993 vid & VLAN_VID_MASK);
994
995 skb_reset_mac_header(skb_new);
996 skb_new->protocol = eth_type_trans(skb_new,
997 bat_priv->soft_iface);
998 bat_priv->stats.rx_packets++;
999 bat_priv->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size;
1000 bat_priv->soft_iface->last_rx = jiffies;
1001
1002 netif_rx(skb_new);
1003 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
1004 ret = true;
1005 } else {
1006
1007 ret = batadv_dat_send_data(bat_priv, skb, ip_dst,
1008 BATADV_P_DAT_DHT_GET);
1009 }
1010out:
1011 if (dat_entry)
1012 batadv_dat_entry_free_ref(dat_entry);
1013 return ret;
1014}
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
1026 struct sk_buff *skb, int hdr_size)
1027{
1028 u16 type;
1029 __be32 ip_src, ip_dst;
1030 u8 *hw_src;
1031 struct sk_buff *skb_new;
1032 struct batadv_dat_entry *dat_entry = NULL;
1033 bool ret = false;
1034 unsigned short vid;
1035 int err;
1036
1037 if (!atomic_read(&bat_priv->distributed_arp_table))
1038 goto out;
1039
1040 vid = batadv_dat_get_vid(skb, &hdr_size);
1041
1042 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1043 if (type != ARPOP_REQUEST)
1044 goto out;
1045
1046 hw_src = batadv_arp_hw_src(skb, hdr_size);
1047 ip_src = batadv_arp_ip_src(skb, hdr_size);
1048 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1049
1050 batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1051 "Parsing incoming ARP REQUEST");
1052
1053 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1054
1055 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1056 if (!dat_entry)
1057 goto out;
1058
1059 skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
1060 bat_priv->soft_iface, ip_dst, hw_src,
1061 dat_entry->mac_addr, hw_src);
1062
1063 if (!skb_new)
1064 goto out;
1065
1066
1067
1068
1069 skb_reset_mac_header(skb_new);
1070
1071 if (vid & BATADV_VLAN_HAS_TAG)
1072 skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q),
1073 vid & VLAN_VID_MASK);
1074
1075
1076
1077
1078
1079 if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
1080 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
1081 BATADV_P_DAT_CACHE_REPLY,
1082 NULL, vid);
1083 else
1084 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
1085
1086 if (err != NET_XMIT_DROP) {
1087 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
1088 ret = true;
1089 }
1090out:
1091 if (dat_entry)
1092 batadv_dat_entry_free_ref(dat_entry);
1093 if (ret)
1094 kfree_skb(skb);
1095 return ret;
1096}
1097
1098
1099
1100
1101
1102
1103void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
1104 struct sk_buff *skb)
1105{
1106 u16 type;
1107 __be32 ip_src, ip_dst;
1108 u8 *hw_src, *hw_dst;
1109 int hdr_size = 0;
1110 unsigned short vid;
1111
1112 if (!atomic_read(&bat_priv->distributed_arp_table))
1113 return;
1114
1115 vid = batadv_dat_get_vid(skb, &hdr_size);
1116
1117 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1118 if (type != ARPOP_REPLY)
1119 return;
1120
1121 batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1122 "Parsing outgoing ARP REPLY");
1123
1124 hw_src = batadv_arp_hw_src(skb, hdr_size);
1125 ip_src = batadv_arp_ip_src(skb, hdr_size);
1126 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1127 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1128
1129 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1130 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1131
1132
1133
1134
1135 batadv_dat_send_data(bat_priv, skb, ip_src, BATADV_P_DAT_DHT_PUT);
1136 batadv_dat_send_data(bat_priv, skb, ip_dst, BATADV_P_DAT_DHT_PUT);
1137}
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
1150 struct sk_buff *skb, int hdr_size)
1151{
1152 u16 type;
1153 __be32 ip_src, ip_dst;
1154 u8 *hw_src, *hw_dst;
1155 bool dropped = false;
1156 unsigned short vid;
1157
1158 if (!atomic_read(&bat_priv->distributed_arp_table))
1159 goto out;
1160
1161 vid = batadv_dat_get_vid(skb, &hdr_size);
1162
1163 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1164 if (type != ARPOP_REPLY)
1165 goto out;
1166
1167 batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1168 "Parsing incoming ARP REPLY");
1169
1170 hw_src = batadv_arp_hw_src(skb, hdr_size);
1171 ip_src = batadv_arp_ip_src(skb, hdr_size);
1172 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1173 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1174
1175
1176
1177
1178 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1179 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1180
1181
1182
1183
1184 dropped = !batadv_is_my_client(bat_priv, hw_dst, vid);
1185
1186
1187
1188
1189 dropped |= batadv_is_my_client(bat_priv, hw_src, vid);
1190out:
1191 if (dropped)
1192 kfree_skb(skb);
1193
1194 return dropped;
1195}
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
1206 struct batadv_forw_packet *forw_packet)
1207{
1208 u16 type;
1209 __be32 ip_dst;
1210 struct batadv_dat_entry *dat_entry = NULL;
1211 bool ret = false;
1212 int hdr_size = sizeof(struct batadv_bcast_packet);
1213 unsigned short vid;
1214
1215 if (!atomic_read(&bat_priv->distributed_arp_table))
1216 goto out;
1217
1218
1219
1220
1221 if (forw_packet->num_packets)
1222 goto out;
1223
1224 vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
1225
1226 type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
1227 if (type != ARPOP_REQUEST)
1228 goto out;
1229
1230 ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
1231 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1232
1233 if (!dat_entry) {
1234 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1235 "ARP Request for %pI4: fallback\n", &ip_dst);
1236 goto out;
1237 }
1238
1239 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1240 "ARP Request for %pI4: fallback prevented\n", &ip_dst);
1241 ret = true;
1242
1243out:
1244 if (dat_entry)
1245 batadv_dat_entry_free_ref(dat_entry);
1246 return ret;
1247}
1248