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