1
2
3
4
5
6
7#include "distributed-arp-table.h"
8#include "main.h"
9
10#include <asm/unaligned.h>
11#include <linux/atomic.h>
12#include <linux/bitops.h>
13#include <linux/byteorder/generic.h>
14#include <linux/errno.h>
15#include <linux/etherdevice.h>
16#include <linux/gfp.h>
17#include <linux/if_arp.h>
18#include <linux/if_ether.h>
19#include <linux/if_vlan.h>
20#include <linux/in.h>
21#include <linux/ip.h>
22#include <linux/jiffies.h>
23#include <linux/kernel.h>
24#include <linux/kref.h>
25#include <linux/list.h>
26#include <linux/netlink.h>
27#include <linux/rculist.h>
28#include <linux/rcupdate.h>
29#include <linux/skbuff.h>
30#include <linux/slab.h>
31#include <linux/spinlock.h>
32#include <linux/stddef.h>
33#include <linux/string.h>
34#include <linux/udp.h>
35#include <linux/workqueue.h>
36#include <net/arp.h>
37#include <net/genetlink.h>
38#include <net/netlink.h>
39#include <net/sock.h>
40#include <uapi/linux/batman_adv.h>
41
42#include "bridge_loop_avoidance.h"
43#include "hard-interface.h"
44#include "hash.h"
45#include "log.h"
46#include "netlink.h"
47#include "originator.h"
48#include "send.h"
49#include "soft-interface.h"
50#include "translation-table.h"
51#include "tvlv.h"
52
53enum batadv_bootpop {
54 BATADV_BOOTREPLY = 2,
55};
56
57enum batadv_boothtype {
58 BATADV_HTYPE_ETHERNET = 1,
59};
60
61enum batadv_dhcpoptioncode {
62 BATADV_DHCP_OPT_PAD = 0,
63 BATADV_DHCP_OPT_MSG_TYPE = 53,
64 BATADV_DHCP_OPT_END = 255,
65};
66
67enum batadv_dhcptype {
68 BATADV_DHCPACK = 5,
69};
70
71
72#define BATADV_DHCP_MAGIC 1669485411
73
74struct batadv_dhcp_packet {
75 __u8 op;
76 __u8 htype;
77 __u8 hlen;
78 __u8 hops;
79 __be32 xid;
80 __be16 secs;
81 __be16 flags;
82 __be32 ciaddr;
83 __be32 yiaddr;
84 __be32 siaddr;
85 __be32 giaddr;
86 __u8 chaddr[16];
87 __u8 sname[64];
88 __u8 file[128];
89 __be32 magic;
90
91};
92
93#define BATADV_DHCP_YIADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->yiaddr)
94#define BATADV_DHCP_CHADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->chaddr)
95
96static void batadv_dat_purge(struct work_struct *work);
97
98
99
100
101
102static void batadv_dat_start_timer(struct batadv_priv *bat_priv)
103{
104 INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge);
105 queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work,
106 msecs_to_jiffies(10000));
107}
108
109
110
111
112
113
114static void batadv_dat_entry_release(struct kref *ref)
115{
116 struct batadv_dat_entry *dat_entry;
117
118 dat_entry = container_of(ref, struct batadv_dat_entry, refcount);
119
120 kfree_rcu(dat_entry, rcu);
121}
122
123
124
125
126
127
128static void batadv_dat_entry_put(struct batadv_dat_entry *dat_entry)
129{
130 kref_put(&dat_entry->refcount, batadv_dat_entry_release);
131}
132
133
134
135
136
137
138
139static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry)
140{
141 return batadv_has_timed_out(dat_entry->last_update,
142 BATADV_DAT_ENTRY_TIMEOUT);
143}
144
145
146
147
148
149
150
151
152
153
154
155
156static void __batadv_dat_purge(struct batadv_priv *bat_priv,
157 bool (*to_purge)(struct batadv_dat_entry *))
158{
159 spinlock_t *list_lock;
160 struct batadv_dat_entry *dat_entry;
161 struct hlist_node *node_tmp;
162 struct hlist_head *head;
163 u32 i;
164
165 if (!bat_priv->dat.hash)
166 return;
167
168 for (i = 0; i < bat_priv->dat.hash->size; i++) {
169 head = &bat_priv->dat.hash->table[i];
170 list_lock = &bat_priv->dat.hash->list_locks[i];
171
172 spin_lock_bh(list_lock);
173 hlist_for_each_entry_safe(dat_entry, node_tmp, head,
174 hash_entry) {
175
176
177
178 if (to_purge && !to_purge(dat_entry))
179 continue;
180
181 hlist_del_rcu(&dat_entry->hash_entry);
182 batadv_dat_entry_put(dat_entry);
183 }
184 spin_unlock_bh(list_lock);
185 }
186}
187
188
189
190
191
192
193static void batadv_dat_purge(struct work_struct *work)
194{
195 struct delayed_work *delayed_work;
196 struct batadv_priv_dat *priv_dat;
197 struct batadv_priv *bat_priv;
198
199 delayed_work = to_delayed_work(work);
200 priv_dat = container_of(delayed_work, struct batadv_priv_dat, work);
201 bat_priv = container_of(priv_dat, struct batadv_priv, dat);
202
203 __batadv_dat_purge(bat_priv, batadv_dat_to_purge);
204 batadv_dat_start_timer(bat_priv);
205}
206
207
208
209
210
211
212
213
214static bool batadv_compare_dat(const struct hlist_node *node, const void *data2)
215{
216 const void *data1 = container_of(node, struct batadv_dat_entry,
217 hash_entry);
218
219 return memcmp(data1, data2, sizeof(__be32)) == 0;
220}
221
222
223
224
225
226
227
228
229static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)
230{
231 u8 *addr;
232
233 addr = (u8 *)(skb->data + hdr_size);
234 addr += ETH_HLEN + sizeof(struct arphdr);
235
236 return addr;
237}
238
239
240
241
242
243
244
245
246static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
247{
248 return *(__force __be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
249}
250
251
252
253
254
255
256
257
258static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)
259{
260 return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4;
261}
262
263
264
265
266
267
268
269
270static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
271{
272 u8 *dst = batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4;
273
274 return *(__force __be32 *)dst;
275}
276
277
278
279
280
281
282
283
284static u32 batadv_hash_dat(const void *data, u32 size)
285{
286 u32 hash = 0;
287 const struct batadv_dat_entry *dat = data;
288 const unsigned char *key;
289 __be16 vid;
290 u32 i;
291
292 key = (__force const unsigned char *)&dat->ip;
293 for (i = 0; i < sizeof(dat->ip); i++) {
294 hash += key[i];
295 hash += (hash << 10);
296 hash ^= (hash >> 6);
297 }
298
299 vid = htons(dat->vid);
300 key = (__force const unsigned char *)&vid;
301 for (i = 0; i < sizeof(dat->vid); i++) {
302 hash += key[i];
303 hash += (hash << 10);
304 hash ^= (hash >> 6);
305 }
306
307 hash += (hash << 3);
308 hash ^= (hash >> 11);
309 hash += (hash << 15);
310
311 return hash % size;
312}
313
314
315
316
317
318
319
320
321
322
323static struct batadv_dat_entry *
324batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip,
325 unsigned short vid)
326{
327 struct hlist_head *head;
328 struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL;
329 struct batadv_hashtable *hash = bat_priv->dat.hash;
330 u32 index;
331
332 if (!hash)
333 return NULL;
334
335 to_find.ip = ip;
336 to_find.vid = vid;
337
338 index = batadv_hash_dat(&to_find, hash->size);
339 head = &hash->table[index];
340
341 rcu_read_lock();
342 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
343 if (dat_entry->ip != ip)
344 continue;
345
346 if (!kref_get_unless_zero(&dat_entry->refcount))
347 continue;
348
349 dat_entry_tmp = dat_entry;
350 break;
351 }
352 rcu_read_unlock();
353
354 return dat_entry_tmp;
355}
356
357
358
359
360
361
362
363
364static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
365 u8 *mac_addr, unsigned short vid)
366{
367 struct batadv_dat_entry *dat_entry;
368 int hash_added;
369
370 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid);
371
372 if (dat_entry) {
373 if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr))
374 ether_addr_copy(dat_entry->mac_addr, mac_addr);
375 dat_entry->last_update = jiffies;
376 batadv_dbg(BATADV_DBG_DAT, bat_priv,
377 "Entry updated: %pI4 %pM (vid: %d)\n",
378 &dat_entry->ip, dat_entry->mac_addr,
379 batadv_print_vid(vid));
380 goto out;
381 }
382
383 dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC);
384 if (!dat_entry)
385 goto out;
386
387 dat_entry->ip = ip;
388 dat_entry->vid = vid;
389 ether_addr_copy(dat_entry->mac_addr, mac_addr);
390 dat_entry->last_update = jiffies;
391 kref_init(&dat_entry->refcount);
392
393 kref_get(&dat_entry->refcount);
394 hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat,
395 batadv_hash_dat, dat_entry,
396 &dat_entry->hash_entry);
397
398 if (unlikely(hash_added != 0)) {
399
400 batadv_dat_entry_put(dat_entry);
401 goto out;
402 }
403
404 batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n",
405 &dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid));
406
407out:
408 if (dat_entry)
409 batadv_dat_entry_put(dat_entry);
410}
411
412#ifdef CONFIG_BATMAN_ADV_DEBUG
413
414
415
416
417
418
419
420
421
422static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
423 int hdr_size, char *msg)
424{
425 struct batadv_unicast_4addr_packet *unicast_4addr_packet;
426 struct batadv_bcast_packet *bcast_pkt;
427 u8 *orig_addr;
428 __be32 ip_src, ip_dst;
429
430 if (msg)
431 batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
432
433 ip_src = batadv_arp_ip_src(skb, hdr_size);
434 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
435 batadv_dbg(BATADV_DBG_DAT, bat_priv,
436 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
437 batadv_arp_hw_src(skb, hdr_size), &ip_src,
438 batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
439
440 if (hdr_size < sizeof(struct batadv_unicast_packet))
441 return;
442
443 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
444
445 switch (unicast_4addr_packet->u.packet_type) {
446 case BATADV_UNICAST:
447 batadv_dbg(BATADV_DBG_DAT, bat_priv,
448 "* encapsulated within a UNICAST packet\n");
449 break;
450 case BATADV_UNICAST_4ADDR:
451 batadv_dbg(BATADV_DBG_DAT, bat_priv,
452 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
453 unicast_4addr_packet->src);
454 switch (unicast_4addr_packet->subtype) {
455 case BATADV_P_DAT_DHT_PUT:
456 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
457 break;
458 case BATADV_P_DAT_DHT_GET:
459 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
460 break;
461 case BATADV_P_DAT_CACHE_REPLY:
462 batadv_dbg(BATADV_DBG_DAT, bat_priv,
463 "* type: DAT_CACHE_REPLY\n");
464 break;
465 case BATADV_P_DATA:
466 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n");
467 break;
468 default:
469 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n",
470 unicast_4addr_packet->u.packet_type);
471 }
472 break;
473 case BATADV_BCAST:
474 bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet;
475 orig_addr = bcast_pkt->orig;
476 batadv_dbg(BATADV_DBG_DAT, bat_priv,
477 "* encapsulated within a BCAST packet (src: %pM)\n",
478 orig_addr);
479 break;
480 default:
481 batadv_dbg(BATADV_DBG_DAT, bat_priv,
482 "* encapsulated within an unknown packet type (0x%x)\n",
483 unicast_4addr_packet->u.packet_type);
484 }
485}
486
487#else
488
489static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
490 int hdr_size, char *msg)
491{
492}
493
494#endif
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res,
510 int select, batadv_dat_addr_t tmp_max,
511 batadv_dat_addr_t max,
512 batadv_dat_addr_t last_max,
513 struct batadv_orig_node *candidate,
514 struct batadv_orig_node *max_orig_node)
515{
516 bool ret = false;
517 int j;
518
519
520 if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities))
521 goto out;
522
523
524 for (j = 0; j < select; j++)
525 if (res[j].orig_node == candidate)
526 break;
527
528 if (j < select)
529 goto out;
530
531 if (tmp_max > last_max)
532 goto out;
533
534
535
536 if (tmp_max < max)
537 goto out;
538
539
540
541 if (tmp_max == max && max_orig_node &&
542 batadv_compare_eth(candidate->orig, max_orig_node->orig))
543 goto out;
544
545 ret = true;
546out:
547 return ret;
548}
549
550
551
552
553
554
555
556
557
558static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
559 struct batadv_dat_candidate *cands,
560 int select, batadv_dat_addr_t ip_key,
561 batadv_dat_addr_t *last_max)
562{
563 batadv_dat_addr_t max = 0;
564 batadv_dat_addr_t tmp_max = 0;
565 struct batadv_orig_node *orig_node, *max_orig_node = NULL;
566 struct batadv_hashtable *hash = bat_priv->orig_hash;
567 struct hlist_head *head;
568 int i;
569
570
571
572
573 cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
574
575
576
577
578 for (i = 0; i < hash->size; i++) {
579 head = &hash->table[i];
580
581 rcu_read_lock();
582 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
583
584 tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
585 ip_key;
586
587 if (!batadv_is_orig_node_eligible(cands, select,
588 tmp_max, max,
589 *last_max, orig_node,
590 max_orig_node))
591 continue;
592
593 if (!kref_get_unless_zero(&orig_node->refcount))
594 continue;
595
596 max = tmp_max;
597 if (max_orig_node)
598 batadv_orig_node_put(max_orig_node);
599 max_orig_node = orig_node;
600 }
601 rcu_read_unlock();
602 }
603 if (max_orig_node) {
604 cands[select].type = BATADV_DAT_CANDIDATE_ORIG;
605 cands[select].orig_node = max_orig_node;
606 batadv_dbg(BATADV_DBG_DAT, bat_priv,
607 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
608 select, max_orig_node->orig, max_orig_node->dat_addr,
609 max);
610 }
611 *last_max = max;
612}
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627static struct batadv_dat_candidate *
628batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst,
629 unsigned short vid)
630{
631 int select;
632 batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key;
633 struct batadv_dat_candidate *res;
634 struct batadv_dat_entry dat;
635
636 if (!bat_priv->orig_hash)
637 return NULL;
638
639 res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res),
640 GFP_ATOMIC);
641 if (!res)
642 return NULL;
643
644 dat.ip = ip_dst;
645 dat.vid = vid;
646 ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat,
647 BATADV_DAT_ADDR_MAX);
648
649 batadv_dbg(BATADV_DBG_DAT, bat_priv,
650 "%s(): IP=%pI4 hash(IP)=%u\n", __func__, &ip_dst,
651 ip_key);
652
653 for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
654 batadv_choose_next_candidate(bat_priv, res, select, ip_key,
655 &last_max);
656
657 return res;
658}
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674static bool batadv_dat_forward_data(struct batadv_priv *bat_priv,
675 struct sk_buff *skb, __be32 ip,
676 unsigned short vid, int packet_subtype)
677{
678 int i;
679 bool ret = false;
680 int send_status;
681 struct batadv_neigh_node *neigh_node = NULL;
682 struct sk_buff *tmp_skb;
683 struct batadv_dat_candidate *cand;
684
685 cand = batadv_dat_select_candidates(bat_priv, ip, vid);
686 if (!cand)
687 goto out;
688
689 batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
690
691 for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
692 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
693 continue;
694
695 neigh_node = batadv_orig_router_get(cand[i].orig_node,
696 BATADV_IF_DEFAULT);
697 if (!neigh_node)
698 goto free_orig;
699
700 tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
701 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
702 cand[i].orig_node,
703 packet_subtype)) {
704 kfree_skb(tmp_skb);
705 goto free_neigh;
706 }
707
708 send_status = batadv_send_unicast_skb(tmp_skb, neigh_node);
709 if (send_status == NET_XMIT_SUCCESS) {
710
711 switch (packet_subtype) {
712 case BATADV_P_DAT_DHT_GET:
713 batadv_inc_counter(bat_priv,
714 BATADV_CNT_DAT_GET_TX);
715 break;
716 case BATADV_P_DAT_DHT_PUT:
717 batadv_inc_counter(bat_priv,
718 BATADV_CNT_DAT_PUT_TX);
719 break;
720 }
721
722
723 ret = true;
724 }
725free_neigh:
726 batadv_neigh_node_put(neigh_node);
727free_orig:
728 batadv_orig_node_put(cand[i].orig_node);
729 }
730
731out:
732 kfree(cand);
733 return ret;
734}
735
736
737
738
739
740
741static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
742{
743 char dat_mode;
744
745 dat_mode = atomic_read(&bat_priv->distributed_arp_table);
746
747 switch (dat_mode) {
748 case 0:
749 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
750 break;
751 case 1:
752 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
753 NULL, 0);
754 break;
755 }
756}
757
758
759
760
761
762
763void batadv_dat_status_update(struct net_device *net_dev)
764{
765 struct batadv_priv *bat_priv = netdev_priv(net_dev);
766
767 batadv_dat_tvlv_container_update(bat_priv);
768}
769
770
771
772
773
774
775
776
777
778static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
779 struct batadv_orig_node *orig,
780 u8 flags,
781 void *tvlv_value, u16 tvlv_value_len)
782{
783 if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
784 clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
785 else
786 set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
787}
788
789
790
791
792
793static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
794{
795 if (!bat_priv->dat.hash)
796 return;
797
798 __batadv_dat_purge(bat_priv, NULL);
799
800 batadv_hash_destroy(bat_priv->dat.hash);
801
802 bat_priv->dat.hash = NULL;
803}
804
805
806
807
808
809
810
811int batadv_dat_init(struct batadv_priv *bat_priv)
812{
813 if (bat_priv->dat.hash)
814 return 0;
815
816 bat_priv->dat.hash = batadv_hash_new(1024);
817
818 if (!bat_priv->dat.hash)
819 return -ENOMEM;
820
821 batadv_dat_start_timer(bat_priv);
822
823 batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
824 NULL, BATADV_TVLV_DAT, 1,
825 BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
826 batadv_dat_tvlv_container_update(bat_priv);
827 return 0;
828}
829
830
831
832
833
834void batadv_dat_free(struct batadv_priv *bat_priv)
835{
836 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
837 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
838
839 cancel_delayed_work_sync(&bat_priv->dat.work);
840
841 batadv_dat_hash_free(bat_priv);
842}
843
844
845
846
847
848
849
850
851
852
853
854static int
855batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid,
856 struct netlink_callback *cb,
857 struct batadv_dat_entry *dat_entry)
858{
859 int msecs;
860 void *hdr;
861
862 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
863 &batadv_netlink_family, NLM_F_MULTI,
864 BATADV_CMD_GET_DAT_CACHE);
865 if (!hdr)
866 return -ENOBUFS;
867
868 genl_dump_check_consistent(cb, hdr);
869
870 msecs = jiffies_to_msecs(jiffies - dat_entry->last_update);
871
872 if (nla_put_in_addr(msg, BATADV_ATTR_DAT_CACHE_IP4ADDRESS,
873 dat_entry->ip) ||
874 nla_put(msg, BATADV_ATTR_DAT_CACHE_HWADDRESS, ETH_ALEN,
875 dat_entry->mac_addr) ||
876 nla_put_u16(msg, BATADV_ATTR_DAT_CACHE_VID, dat_entry->vid) ||
877 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
878 genlmsg_cancel(msg, hdr);
879 return -EMSGSIZE;
880 }
881
882 genlmsg_end(msg, hdr);
883 return 0;
884}
885
886
887
888
889
890
891
892
893
894
895
896
897
898static int
899batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid,
900 struct netlink_callback *cb,
901 struct batadv_hashtable *hash, unsigned int bucket,
902 int *idx_skip)
903{
904 struct batadv_dat_entry *dat_entry;
905 int idx = 0;
906
907 spin_lock_bh(&hash->list_locks[bucket]);
908 cb->seq = atomic_read(&hash->generation) << 1 | 1;
909
910 hlist_for_each_entry(dat_entry, &hash->table[bucket], hash_entry) {
911 if (idx < *idx_skip)
912 goto skip;
913
914 if (batadv_dat_cache_dump_entry(msg, portid, cb, dat_entry)) {
915 spin_unlock_bh(&hash->list_locks[bucket]);
916 *idx_skip = idx;
917
918 return -EMSGSIZE;
919 }
920
921skip:
922 idx++;
923 }
924 spin_unlock_bh(&hash->list_locks[bucket]);
925
926 return 0;
927}
928
929
930
931
932
933
934
935
936int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb)
937{
938 struct batadv_hard_iface *primary_if = NULL;
939 int portid = NETLINK_CB(cb->skb).portid;
940 struct net *net = sock_net(cb->skb->sk);
941 struct net_device *soft_iface;
942 struct batadv_hashtable *hash;
943 struct batadv_priv *bat_priv;
944 int bucket = cb->args[0];
945 int idx = cb->args[1];
946 int ifindex;
947 int ret = 0;
948
949 ifindex = batadv_netlink_get_ifindex(cb->nlh,
950 BATADV_ATTR_MESH_IFINDEX);
951 if (!ifindex)
952 return -EINVAL;
953
954 soft_iface = dev_get_by_index(net, ifindex);
955 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
956 ret = -ENODEV;
957 goto out;
958 }
959
960 bat_priv = netdev_priv(soft_iface);
961 hash = bat_priv->dat.hash;
962
963 primary_if = batadv_primary_if_get_selected(bat_priv);
964 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
965 ret = -ENOENT;
966 goto out;
967 }
968
969 while (bucket < hash->size) {
970 if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket,
971 &idx))
972 break;
973
974 bucket++;
975 idx = 0;
976 }
977
978 cb->args[0] = bucket;
979 cb->args[1] = idx;
980
981 ret = msg->len;
982
983out:
984 if (primary_if)
985 batadv_hardif_put(primary_if);
986
987 if (soft_iface)
988 dev_put(soft_iface);
989
990 return ret;
991}
992
993
994
995
996
997
998
999
1000
1001static u16 batadv_arp_get_type(struct batadv_priv *bat_priv,
1002 struct sk_buff *skb, int hdr_size)
1003{
1004 struct arphdr *arphdr;
1005 struct ethhdr *ethhdr;
1006 __be32 ip_src, ip_dst;
1007 u8 *hw_src, *hw_dst;
1008 u16 type = 0;
1009
1010
1011 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
1012 goto out;
1013
1014 ethhdr = (struct ethhdr *)(skb->data + hdr_size);
1015
1016 if (ethhdr->h_proto != htons(ETH_P_ARP))
1017 goto out;
1018
1019
1020 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
1021 arp_hdr_len(skb->dev))))
1022 goto out;
1023
1024 arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
1025
1026
1027 if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
1028 goto out;
1029
1030 if (arphdr->ar_pro != htons(ETH_P_IP))
1031 goto out;
1032
1033 if (arphdr->ar_hln != ETH_ALEN)
1034 goto out;
1035
1036 if (arphdr->ar_pln != 4)
1037 goto out;
1038
1039
1040
1041
1042 ip_src = batadv_arp_ip_src(skb, hdr_size);
1043 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1044 if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
1045 ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
1046 ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
1047 ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
1048 goto out;
1049
1050 hw_src = batadv_arp_hw_src(skb, hdr_size);
1051 if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
1052 goto out;
1053
1054
1055 if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
1056 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1057 if (is_zero_ether_addr(hw_dst) ||
1058 is_multicast_ether_addr(hw_dst))
1059 goto out;
1060 }
1061
1062 type = ntohs(arphdr->ar_op);
1063out:
1064 return type;
1065}
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
1077{
1078 unsigned short vid;
1079
1080 vid = batadv_get_vid(skb, *hdr_size);
1081
1082
1083
1084
1085
1086
1087 if (vid & BATADV_VLAN_HAS_TAG)
1088 *hdr_size += VLAN_HLEN;
1089
1090 return vid;
1091}
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107static struct sk_buff *
1108batadv_dat_arp_create_reply(struct batadv_priv *bat_priv, __be32 ip_src,
1109 __be32 ip_dst, u8 *hw_src, u8 *hw_dst,
1110 unsigned short vid)
1111{
1112 struct sk_buff *skb;
1113
1114 skb = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_dst, bat_priv->soft_iface,
1115 ip_src, hw_dst, hw_src, hw_dst);
1116 if (!skb)
1117 return NULL;
1118
1119 skb_reset_mac_header(skb);
1120
1121 if (vid & BATADV_VLAN_HAS_TAG)
1122 skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
1123 vid & VLAN_VID_MASK);
1124
1125 return skb;
1126}
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
1139 struct sk_buff *skb)
1140{
1141 u16 type = 0;
1142 __be32 ip_dst, ip_src;
1143 u8 *hw_src;
1144 bool ret = false;
1145 struct batadv_dat_entry *dat_entry = NULL;
1146 struct sk_buff *skb_new;
1147 struct net_device *soft_iface = bat_priv->soft_iface;
1148 int hdr_size = 0;
1149 unsigned short vid;
1150
1151 if (!atomic_read(&bat_priv->distributed_arp_table))
1152 goto out;
1153
1154 vid = batadv_dat_get_vid(skb, &hdr_size);
1155
1156 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1157
1158
1159
1160 if (type != ARPOP_REQUEST)
1161 goto out;
1162
1163 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REQUEST");
1164
1165 ip_src = batadv_arp_ip_src(skb, hdr_size);
1166 hw_src = batadv_arp_hw_src(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
1171 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1172 if (dat_entry) {
1173
1174
1175
1176
1177
1178
1179
1180
1181 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
1182 ret = true;
1183 goto out;
1184 }
1185
1186
1187
1188
1189
1190
1191 if (!batadv_bla_check_claim(bat_priv,
1192 dat_entry->mac_addr, vid)) {
1193 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1194 "Device %pM claimed by another backbone gw. Don't send ARP reply!",
1195 dat_entry->mac_addr);
1196 ret = true;
1197 goto out;
1198 }
1199
1200 skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
1201 dat_entry->mac_addr,
1202 hw_src, vid);
1203 if (!skb_new)
1204 goto out;
1205
1206 skb_new->protocol = eth_type_trans(skb_new, soft_iface);
1207
1208 batadv_inc_counter(bat_priv, BATADV_CNT_RX);
1209 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
1210 skb->len + ETH_HLEN + hdr_size);
1211
1212 netif_rx(skb_new);
1213 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
1214 ret = true;
1215 } else {
1216
1217 ret = batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1218 BATADV_P_DAT_DHT_GET);
1219 }
1220out:
1221 if (dat_entry)
1222 batadv_dat_entry_put(dat_entry);
1223 return ret;
1224}
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
1236 struct sk_buff *skb, int hdr_size)
1237{
1238 u16 type;
1239 __be32 ip_src, ip_dst;
1240 u8 *hw_src;
1241 struct sk_buff *skb_new;
1242 struct batadv_dat_entry *dat_entry = NULL;
1243 bool ret = false;
1244 unsigned short vid;
1245 int err;
1246
1247 if (!atomic_read(&bat_priv->distributed_arp_table))
1248 goto out;
1249
1250 vid = batadv_dat_get_vid(skb, &hdr_size);
1251
1252 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1253 if (type != ARPOP_REQUEST)
1254 goto out;
1255
1256 hw_src = batadv_arp_hw_src(skb, hdr_size);
1257 ip_src = batadv_arp_ip_src(skb, hdr_size);
1258 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1259
1260 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST");
1261
1262 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1263
1264 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1265 if (!dat_entry)
1266 goto out;
1267
1268 skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
1269 dat_entry->mac_addr, hw_src, vid);
1270 if (!skb_new)
1271 goto out;
1272
1273
1274
1275
1276
1277 if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
1278 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
1279 BATADV_P_DAT_CACHE_REPLY,
1280 NULL, vid);
1281 else
1282 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
1283
1284 if (err != NET_XMIT_DROP) {
1285 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
1286 ret = true;
1287 }
1288out:
1289 if (dat_entry)
1290 batadv_dat_entry_put(dat_entry);
1291 if (ret)
1292 kfree_skb(skb);
1293 return ret;
1294}
1295
1296
1297
1298
1299
1300
1301void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
1302 struct sk_buff *skb)
1303{
1304 u16 type;
1305 __be32 ip_src, ip_dst;
1306 u8 *hw_src, *hw_dst;
1307 int hdr_size = 0;
1308 unsigned short vid;
1309
1310 if (!atomic_read(&bat_priv->distributed_arp_table))
1311 return;
1312
1313 vid = batadv_dat_get_vid(skb, &hdr_size);
1314
1315 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1316 if (type != ARPOP_REPLY)
1317 return;
1318
1319 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REPLY");
1320
1321 hw_src = batadv_arp_hw_src(skb, hdr_size);
1322 ip_src = batadv_arp_ip_src(skb, hdr_size);
1323 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1324 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1325
1326 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1327 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1328
1329
1330
1331
1332 batadv_dat_forward_data(bat_priv, skb, ip_src, vid,
1333 BATADV_P_DAT_DHT_PUT);
1334 batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1335 BATADV_P_DAT_DHT_PUT);
1336}
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
1349 struct sk_buff *skb, int hdr_size)
1350{
1351 struct batadv_dat_entry *dat_entry = NULL;
1352 u16 type;
1353 __be32 ip_src, ip_dst;
1354 u8 *hw_src, *hw_dst;
1355 bool dropped = false;
1356 unsigned short vid;
1357
1358 if (!atomic_read(&bat_priv->distributed_arp_table))
1359 goto out;
1360
1361 vid = batadv_dat_get_vid(skb, &hdr_size);
1362
1363 type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1364 if (type != ARPOP_REPLY)
1365 goto out;
1366
1367 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REPLY");
1368
1369 hw_src = batadv_arp_hw_src(skb, hdr_size);
1370 ip_src = batadv_arp_ip_src(skb, hdr_size);
1371 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1372 ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1373
1374
1375
1376
1377
1378
1379
1380 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid);
1381 if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) {
1382 batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n",
1383 hw_src, &ip_src, hw_dst, &ip_dst,
1384 dat_entry->mac_addr, &dat_entry->ip);
1385 dropped = true;
1386 }
1387
1388
1389
1390
1391 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1392 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1393
1394 if (dropped)
1395 goto out;
1396
1397
1398
1399
1400
1401
1402
1403 if (!batadv_bla_check_claim(bat_priv, hw_src, vid)) {
1404 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1405 "Device %pM claimed by another backbone gw. Drop ARP reply.\n",
1406 hw_src);
1407 dropped = true;
1408 goto out;
1409 }
1410
1411
1412
1413
1414 dropped = !batadv_is_my_client(bat_priv, hw_dst, vid);
1415
1416
1417
1418
1419 dropped |= batadv_is_my_client(bat_priv, hw_src, vid);
1420out:
1421 if (dropped)
1422 kfree_skb(skb);
1423 if (dat_entry)
1424 batadv_dat_entry_put(dat_entry);
1425
1426 return dropped;
1427}
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440static bool
1441batadv_dat_check_dhcp_ipudp(struct sk_buff *skb, __be32 *ip_src)
1442{
1443 unsigned int offset = skb_network_offset(skb);
1444 struct udphdr *udphdr, _udphdr;
1445 struct iphdr *iphdr, _iphdr;
1446
1447 iphdr = skb_header_pointer(skb, offset, sizeof(_iphdr), &_iphdr);
1448 if (!iphdr || iphdr->version != 4 || iphdr->ihl * 4 < sizeof(_iphdr))
1449 return false;
1450
1451 if (iphdr->protocol != IPPROTO_UDP)
1452 return false;
1453
1454 offset += iphdr->ihl * 4;
1455 skb_set_transport_header(skb, offset);
1456
1457 udphdr = skb_header_pointer(skb, offset, sizeof(_udphdr), &_udphdr);
1458 if (!udphdr || udphdr->source != htons(67))
1459 return false;
1460
1461 *ip_src = get_unaligned(&iphdr->saddr);
1462
1463 return true;
1464}
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480static int
1481batadv_dat_check_dhcp(struct sk_buff *skb, __be16 proto, __be32 *ip_src)
1482{
1483 __be32 *magic, _magic;
1484 unsigned int offset;
1485 struct {
1486 __u8 op;
1487 __u8 htype;
1488 __u8 hlen;
1489 __u8 hops;
1490 } *dhcp_h, _dhcp_h;
1491
1492 if (proto != htons(ETH_P_IP))
1493 return -EINVAL;
1494
1495 if (!batadv_dat_check_dhcp_ipudp(skb, ip_src))
1496 return -EINVAL;
1497
1498 offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1499 if (skb->len < offset + sizeof(struct batadv_dhcp_packet))
1500 return -EINVAL;
1501
1502 dhcp_h = skb_header_pointer(skb, offset, sizeof(_dhcp_h), &_dhcp_h);
1503 if (!dhcp_h || dhcp_h->htype != BATADV_HTYPE_ETHERNET ||
1504 dhcp_h->hlen != ETH_ALEN)
1505 return -EINVAL;
1506
1507 offset += offsetof(struct batadv_dhcp_packet, magic);
1508
1509 magic = skb_header_pointer(skb, offset, sizeof(_magic), &_magic);
1510 if (!magic || get_unaligned(magic) != htonl(BATADV_DHCP_MAGIC))
1511 return -EINVAL;
1512
1513 return dhcp_h->op;
1514}
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528static int batadv_dat_get_dhcp_message_type(struct sk_buff *skb)
1529{
1530 unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1531 u8 *type, _type;
1532 struct {
1533 u8 type;
1534 u8 len;
1535 } *tl, _tl;
1536
1537 offset += sizeof(struct batadv_dhcp_packet);
1538
1539 while ((tl = skb_header_pointer(skb, offset, sizeof(_tl), &_tl))) {
1540 if (tl->type == BATADV_DHCP_OPT_MSG_TYPE)
1541 break;
1542
1543 if (tl->type == BATADV_DHCP_OPT_END)
1544 break;
1545
1546 if (tl->type == BATADV_DHCP_OPT_PAD)
1547 offset++;
1548 else
1549 offset += tl->len + sizeof(_tl);
1550 }
1551
1552
1553 if (!tl || tl->type != BATADV_DHCP_OPT_MSG_TYPE ||
1554 tl->len != sizeof(_type))
1555 return -EINVAL;
1556
1557 offset += sizeof(_tl);
1558
1559 type = skb_header_pointer(skb, offset, sizeof(_type), &_type);
1560 if (!type)
1561 return -EINVAL;
1562
1563 return *type;
1564}
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576static bool batadv_dat_dhcp_get_yiaddr(struct sk_buff *skb, __be32 *buf)
1577{
1578 unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1579 __be32 *yiaddr;
1580
1581 offset += offsetof(struct batadv_dhcp_packet, yiaddr);
1582 yiaddr = skb_header_pointer(skb, offset, BATADV_DHCP_YIADDR_LEN, buf);
1583
1584 if (!yiaddr)
1585 return false;
1586
1587 if (yiaddr != buf)
1588 *buf = get_unaligned(yiaddr);
1589
1590 return true;
1591}
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603static bool batadv_dat_get_dhcp_chaddr(struct sk_buff *skb, u8 *buf)
1604{
1605 unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1606 u8 *chaddr;
1607
1608 offset += offsetof(struct batadv_dhcp_packet, chaddr);
1609 chaddr = skb_header_pointer(skb, offset, BATADV_DHCP_CHADDR_LEN, buf);
1610
1611 if (!chaddr)
1612 return false;
1613
1614 if (chaddr != buf)
1615 memcpy(buf, chaddr, BATADV_DHCP_CHADDR_LEN);
1616
1617 return true;
1618}
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636static void batadv_dat_put_dhcp(struct batadv_priv *bat_priv, u8 *chaddr,
1637 __be32 yiaddr, u8 *hw_dst, __be32 ip_dst,
1638 unsigned short vid)
1639{
1640 struct sk_buff *skb;
1641
1642 skb = batadv_dat_arp_create_reply(bat_priv, yiaddr, ip_dst, chaddr,
1643 hw_dst, vid);
1644 if (!skb)
1645 return;
1646
1647 skb_set_network_header(skb, ETH_HLEN);
1648
1649 batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid);
1650 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1651
1652 batadv_dat_forward_data(bat_priv, skb, yiaddr, vid,
1653 BATADV_P_DAT_DHT_PUT);
1654 batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1655 BATADV_P_DAT_DHT_PUT);
1656
1657 consume_skb(skb);
1658
1659 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1660 "Snooped from outgoing DHCPACK (server address): %pI4, %pM (vid: %i)\n",
1661 &ip_dst, hw_dst, batadv_print_vid(vid));
1662 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1663 "Snooped from outgoing DHCPACK (client address): %pI4, %pM (vid: %i)\n",
1664 &yiaddr, chaddr, batadv_print_vid(vid));
1665}
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683static bool
1684batadv_dat_check_dhcp_ack(struct sk_buff *skb, __be16 proto, __be32 *ip_src,
1685 u8 *chaddr, __be32 *yiaddr)
1686{
1687 int type;
1688
1689 type = batadv_dat_check_dhcp(skb, proto, ip_src);
1690 if (type != BATADV_BOOTREPLY)
1691 return false;
1692
1693 type = batadv_dat_get_dhcp_message_type(skb);
1694 if (type != BATADV_DHCPACK)
1695 return false;
1696
1697 if (!batadv_dat_dhcp_get_yiaddr(skb, yiaddr))
1698 return false;
1699
1700 if (!batadv_dat_get_dhcp_chaddr(skb, chaddr))
1701 return false;
1702
1703 return true;
1704}
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721void batadv_dat_snoop_outgoing_dhcp_ack(struct batadv_priv *bat_priv,
1722 struct sk_buff *skb,
1723 __be16 proto,
1724 unsigned short vid)
1725{
1726 u8 chaddr[BATADV_DHCP_CHADDR_LEN];
1727 __be32 ip_src, yiaddr;
1728
1729 if (!atomic_read(&bat_priv->distributed_arp_table))
1730 return;
1731
1732 if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr))
1733 return;
1734
1735 batadv_dat_put_dhcp(bat_priv, chaddr, yiaddr, eth_hdr(skb)->h_source,
1736 ip_src, vid);
1737}
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749void batadv_dat_snoop_incoming_dhcp_ack(struct batadv_priv *bat_priv,
1750 struct sk_buff *skb, int hdr_size)
1751{
1752 u8 chaddr[BATADV_DHCP_CHADDR_LEN];
1753 struct ethhdr *ethhdr;
1754 __be32 ip_src, yiaddr;
1755 unsigned short vid;
1756 __be16 proto;
1757 u8 *hw_src;
1758
1759 if (!atomic_read(&bat_priv->distributed_arp_table))
1760 return;
1761
1762 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
1763 return;
1764
1765 ethhdr = (struct ethhdr *)(skb->data + hdr_size);
1766 skb_set_network_header(skb, hdr_size + ETH_HLEN);
1767 proto = ethhdr->h_proto;
1768
1769 if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr))
1770 return;
1771
1772 hw_src = ethhdr->h_source;
1773 vid = batadv_dat_get_vid(skb, &hdr_size);
1774
1775 batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid);
1776 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1777
1778 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1779 "Snooped from incoming DHCPACK (server address): %pI4, %pM (vid: %i)\n",
1780 &ip_src, hw_src, batadv_print_vid(vid));
1781 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1782 "Snooped from incoming DHCPACK (client address): %pI4, %pM (vid: %i)\n",
1783 &yiaddr, chaddr, batadv_print_vid(vid));
1784}
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
1795 struct batadv_forw_packet *forw_packet)
1796{
1797 u16 type;
1798 __be32 ip_dst;
1799 struct batadv_dat_entry *dat_entry = NULL;
1800 bool ret = false;
1801 int hdr_size = sizeof(struct batadv_bcast_packet);
1802 unsigned short vid;
1803
1804 if (!atomic_read(&bat_priv->distributed_arp_table))
1805 goto out;
1806
1807
1808
1809
1810 if (batadv_forw_packet_is_rebroadcast(forw_packet))
1811 goto out;
1812
1813 vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
1814
1815 type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
1816 if (type != ARPOP_REQUEST)
1817 goto out;
1818
1819 ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
1820 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1821
1822 if (!dat_entry) {
1823 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1824 "ARP Request for %pI4: fallback\n", &ip_dst);
1825 goto out;
1826 }
1827
1828 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1829 "ARP Request for %pI4: fallback prevented\n", &ip_dst);
1830 ret = true;
1831
1832out:
1833 if (dat_entry)
1834 batadv_dat_entry_put(dat_entry);
1835 return ret;
1836}
1837