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