1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) B.A.T.M.A.N. contributors:
3  *
4  * Antonio Quartulli
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 
53 enum batadv_bootpop {
54 	BATADV_BOOTREPLY	= 2,
55 };
56 
57 enum batadv_boothtype {
58 	BATADV_HTYPE_ETHERNET	= 1,
59 };
60 
61 enum batadv_dhcpoptioncode {
62 	BATADV_DHCP_OPT_PAD		= 0,
63 	BATADV_DHCP_OPT_MSG_TYPE	= 53,
64 	BATADV_DHCP_OPT_END		= 255,
65 };
66 
67 enum batadv_dhcptype {
68 	BATADV_DHCPACK		= 5,
69 };
70 
71 /* { 99, 130, 83, 99 } */
72 #define BATADV_DHCP_MAGIC 1669485411
73 
74 struct 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 	/* __u8 options[]; */
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 
96 static void batadv_dat_purge(struct work_struct *work);
97 
98 /**
99  * batadv_dat_start_timer() - initialise the DAT periodic worker
100  * @bat_priv: the bat priv with all the soft interface information
101  */
102 static 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  * batadv_dat_entry_release() - release dat_entry from lists and queue for free
111  *  after rcu grace period
112  * @ref: kref pointer of the dat_entry
113  */
114 static 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  * batadv_dat_entry_put() - decrement the dat_entry refcounter and possibly
125  *  release it
126  * @dat_entry: dat_entry to be free'd
127  */
128 static 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  * batadv_dat_to_purge() - check whether a dat_entry has to be purged or not
135  * @dat_entry: the entry to check
136  *
137  * Return: true if the entry has to be purged now, false otherwise.
138  */
139 static 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  * __batadv_dat_purge() - delete entries from the DAT local storage
147  * @bat_priv: the bat priv with all the soft interface information
148  * @to_purge: function in charge to decide whether an entry has to be purged or
149  *	      not. This function takes the dat_entry as argument and has to
150  *	      returns a boolean value: true is the entry has to be deleted,
151  *	      false otherwise
152  *
153  * Loops over each entry in the DAT local storage and deletes it if and only if
154  * the to_purge function passed as argument returns true.
155  */
156 static void __batadv_dat_purge(struct batadv_priv *bat_priv,
157 			       bool (*to_purge)(struct batadv_dat_entry *))
158 {
159 	spinlock_t *list_lock; /* protects write access to the hash lists */
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 			/* if a helper function has been passed as parameter,
176 			 * ask it if the entry has to be purged or not
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  * batadv_dat_purge() - periodic task that deletes old entries from the local
190  *  DAT hash table
191  * @work: kernel work struct
192  */
193 static 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  * batadv_compare_dat() - comparing function used in the local DAT hash table
209  * @node: node in the local table
210  * @data2: second object to compare the node to
211  *
212  * Return: true if the two entries are the same, false otherwise.
213  */
214 static 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  * batadv_arp_hw_src() - extract the hw_src field from an ARP packet
224  * @skb: ARP packet
225  * @hdr_size: size of the possible header before the ARP packet
226  *
227  * Return: the value of the hw_src field in the ARP packet.
228  */
229 static 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  * batadv_arp_ip_src() - extract the ip_src field from an ARP packet
241  * @skb: ARP packet
242  * @hdr_size: size of the possible header before the ARP packet
243  *
244  * Return: the value of the ip_src field in the ARP packet.
245  */
246 static __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  * batadv_arp_hw_dst() - extract the hw_dst field from an ARP packet
253  * @skb: ARP packet
254  * @hdr_size: size of the possible header before the ARP packet
255  *
256  * Return: the value of the hw_dst field in the ARP packet.
257  */
258 static 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  * batadv_arp_ip_dst() - extract the ip_dst field from an ARP packet
265  * @skb: ARP packet
266  * @hdr_size: size of the possible header before the ARP packet
267  *
268  * Return: the value of the ip_dst field in the ARP packet.
269  */
270 static __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  * batadv_hash_dat() - compute the hash value for an IP address
279  * @data: data to hash
280  * @size: size of the hash table
281  *
282  * Return: the selected index in the hash table for the given data.
283  */
284 static 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  * batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash
316  * table
317  * @bat_priv: the bat priv with all the soft interface information
318  * @ip: search key
319  * @vid: VLAN identifier
320  *
321  * Return: the dat_entry if found, NULL otherwise.
322  */
323 static struct batadv_dat_entry *
324 batadv_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  * batadv_dat_entry_add() - add a new dat entry or update it if already exists
359  * @bat_priv: the bat priv with all the soft interface information
360  * @ip: ipv4 to add/edit
361  * @mac_addr: mac address to assign to the given ipv4
362  * @vid: VLAN identifier
363  */
364 static 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 	/* if this entry is already known, just update it */
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 		/* remove the reference for the hash */
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 
407 out:
408 	if (dat_entry)
409 		batadv_dat_entry_put(dat_entry);
410 }
411 
412 #ifdef CONFIG_BATMAN_ADV_DEBUG
413 
414 /**
415  * batadv_dbg_arp() - print a debug message containing all the ARP packet
416  *  details
417  * @bat_priv: the bat priv with all the soft interface information
418  * @skb: ARP packet
419  * @hdr_size: size of the possible header before the ARP packet
420  * @msg: message to print together with the debugging information
421  */
422 static 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 
489 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
490 			   int hdr_size, char *msg)
491 {
492 }
493 
494 #endif /* CONFIG_BATMAN_ADV_DEBUG */
495 
496 /**
497  * batadv_is_orig_node_eligible() - check whether a node can be a DHT candidate
498  * @res: the array with the already selected candidates
499  * @select: number of already selected candidates
500  * @tmp_max: address of the currently evaluated node
501  * @max: current round max address
502  * @last_max: address of the last selected candidate
503  * @candidate: orig_node under evaluation
504  * @max_orig_node: last selected candidate
505  *
506  * Return: true if the node has been elected as next candidate or false
507  * otherwise.
508  */
509 static 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 	/* check if orig node candidate is running DAT */
520 	if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities))
521 		goto out;
522 
523 	/* Check if this node has already been selected... */
524 	for (j = 0; j < select; j++)
525 		if (res[j].orig_node == candidate)
526 			break;
527 	/* ..and possibly skip it */
528 	if (j < select)
529 		goto out;
530 	/* sanity check: has it already been selected? This should not happen */
531 	if (tmp_max > last_max)
532 		goto out;
533 	/* check if during this iteration an originator with a closer dht
534 	 * address has already been found
535 	 */
536 	if (tmp_max < max)
537 		goto out;
538 	/* this is an hash collision with the temporary selected node. Choose
539 	 * the one with the lowest address
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;
546 out:
547 	return ret;
548 }
549 
550 /**
551  * batadv_choose_next_candidate() - select the next DHT candidate
552  * @bat_priv: the bat priv with all the soft interface information
553  * @cands: candidates array
554  * @select: number of candidates already present in the array
555  * @ip_key: key to look up in the DHT
556  * @last_max: pointer where the address of the selected candidate will be saved
557  */
558 static 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 	/* if no node is eligible as candidate, leave the candidate type as
571 	 * NOT_FOUND
572 	 */
573 	cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
574 
575 	/* iterate over the originator list and find the node with the closest
576 	 * dat_address which has not been selected yet
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 			/* the dht space is a ring using unsigned addresses */
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  * batadv_dat_select_candidates() - select the nodes which the DHT message has
616  *  to be sent to
617  * @bat_priv: the bat priv with all the soft interface information
618  * @ip_dst: ipv4 to look up in the DHT
619  * @vid: VLAN identifier
620  *
621  * An originator O is selected if and only if its DHT_ID value is one of three
622  * closest values (from the LEFT, with wrap around if needed) then the hash
623  * value of the key. ip_dst is the key.
624  *
625  * Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM.
626  */
627 static struct batadv_dat_candidate *
628 batadv_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  * batadv_dat_forward_data() - copy and send payload to the selected candidates
662  * @bat_priv: the bat priv with all the soft interface information
663  * @skb: payload to send
664  * @ip: the DHT key
665  * @vid: VLAN identifier
666  * @packet_subtype: unicast4addr packet subtype to use
667  *
668  * This function copies the skb with pskb_copy() and is sent as a unicast packet
669  * to each of the selected candidates.
670  *
671  * Return: true if the packet is sent to at least one candidate, false
672  * otherwise.
673  */
674 static 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 			/* count the sent packet */
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 			/* packet sent to a candidate: return true */
723 			ret = true;
724 		}
725 free_neigh:
726 		batadv_neigh_node_put(neigh_node);
727 free_orig:
728 		batadv_orig_node_put(cand[i].orig_node);
729 	}
730 
731 out:
732 	kfree(cand);
733 	return ret;
734 }
735 
736 /**
737  * batadv_dat_tvlv_container_update() - update the dat tvlv container after dat
738  *  setting change
739  * @bat_priv: the bat priv with all the soft interface information
740  */
741 static 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  * batadv_dat_status_update() - update the dat tvlv container after dat
760  *  setting change
761  * @net_dev: the soft interface net device
762  */
763 void 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  * batadv_dat_tvlv_ogm_handler_v1() - process incoming dat tvlv container
772  * @bat_priv: the bat priv with all the soft interface information
773  * @orig: the orig_node of the ogm
774  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
775  * @tvlv_value: tvlv buffer containing the gateway data
776  * @tvlv_value_len: tvlv buffer length
777  */
778 static 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  * batadv_dat_hash_free() - free the local DAT hash table
791  * @bat_priv: the bat priv with all the soft interface information
792  */
793 static 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  * batadv_dat_init() - initialise the DAT internals
807  * @bat_priv: the bat priv with all the soft interface information
808  *
809  * Return: 0 in case of success, a negative error code otherwise
810  */
811 int 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  * batadv_dat_free() - free the DAT internals
832  * @bat_priv: the bat priv with all the soft interface information
833  */
834 void 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  * batadv_dat_cache_dump_entry() - dump one entry of the DAT cache table to a
846  *  netlink socket
847  * @msg: buffer for the message
848  * @portid: netlink port
849  * @cb: Control block containing additional options
850  * @dat_entry: entry to dump
851  *
852  * Return: 0 or error code.
853  */
854 static int
855 batadv_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  * batadv_dat_cache_dump_bucket() - dump one bucket of the DAT cache table to
888  *  a netlink socket
889  * @msg: buffer for the message
890  * @portid: netlink port
891  * @cb: Control block containing additional options
892  * @hash: hash to dump
893  * @bucket: bucket index to dump
894  * @idx_skip: How many entries to skip
895  *
896  * Return: 0 or error code.
897  */
898 static int
899 batadv_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 
921 skip:
922 		idx++;
923 	}
924 	spin_unlock_bh(&hash->list_locks[bucket]);
925 
926 	return 0;
927 }
928 
929 /**
930  * batadv_dat_cache_dump() - dump DAT cache table to a netlink socket
931  * @msg: buffer for the message
932  * @cb: callback structure containing arguments
933  *
934  * Return: message length.
935  */
936 int 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 
983 out:
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  * batadv_arp_get_type() - parse an ARP packet and gets the type
995  * @bat_priv: the bat priv with all the soft interface information
996  * @skb: packet to analyse
997  * @hdr_size: size of the possible header before the ARP packet in the skb
998  *
999  * Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise.
1000  */
1001 static 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 	/* pull the ethernet header */
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 	/* pull the ARP payload */
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 	/* check whether the ARP packet carries a valid IP information */
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 	/* Check for bad reply/request. If the ARP message is not sane, DAT
1040 	 * will simply ignore it
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 	/* don't care about the destination MAC address in ARP requests */
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);
1063 out:
1064 	return type;
1065 }
1066 
1067 /**
1068  * batadv_dat_get_vid() - extract the VLAN identifier from skb if any
1069  * @skb: the buffer containing the packet to extract the VID from
1070  * @hdr_size: the size of the batman-adv header encapsulating the packet
1071  *
1072  * Return: If the packet embedded in the skb is vlan tagged this function
1073  * returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS
1074  * is returned.
1075  */
1076 static 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 	/* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
1083 	 * If the header contained in the packet is a VLAN one (which is longer)
1084 	 * hdr_size is updated so that the functions will still skip the
1085 	 * correct amount of bytes.
1086 	 */
1087 	if (vid & BATADV_VLAN_HAS_TAG)
1088 		*hdr_size += VLAN_HLEN;
1089 
1090 	return vid;
1091 }
1092 
1093 /**
1094  * batadv_dat_arp_create_reply() - create an ARP Reply
1095  * @bat_priv: the bat priv with all the soft interface information
1096  * @ip_src: ARP sender IP
1097  * @ip_dst: ARP target IP
1098  * @hw_src: Ethernet source and ARP sender MAC
1099  * @hw_dst: Ethernet destination and ARP target MAC
1100  * @vid: VLAN identifier (optional, set to zero otherwise)
1101  *
1102  * Creates an ARP Reply from the given values, optionally encapsulated in a
1103  * VLAN header.
1104  *
1105  * Return: An skb containing an ARP Reply.
1106  */
1107 static struct sk_buff *
1108 batadv_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  * batadv_dat_snoop_outgoing_arp_request() - snoop the ARP request and try to
1130  * answer using DAT
1131  * @bat_priv: the bat priv with all the soft interface information
1132  * @skb: packet to check
1133  *
1134  * Return: true if the message has been sent to the dht candidates, false
1135  * otherwise. In case of a positive return value the message has to be enqueued
1136  * to permit the fallback.
1137  */
1138 bool 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 	/* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
1158 	 * message to the selected DHT candidates
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 		/* If the ARP request is destined for a local client the local
1174 		 * client will answer itself. DAT would only generate a
1175 		 * duplicate packet.
1176 		 *
1177 		 * Moreover, if the soft-interface is enslaved into a bridge, an
1178 		 * additional DAT answer may trigger kernel warnings about
1179 		 * a packet coming from the wrong port.
1180 		 */
1181 		if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
1182 			ret = true;
1183 			goto out;
1184 		}
1185 
1186 		/* If BLA is enabled, only send ARP replies if we have claimed
1187 		 * the destination for the ARP request or if no one else of
1188 		 * the backbone gws belonging to our backbone has claimed the
1189 		 * destination.
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 		/* Send the request to the DHT */
1217 		ret = batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1218 					      BATADV_P_DAT_DHT_GET);
1219 	}
1220 out:
1221 	if (dat_entry)
1222 		batadv_dat_entry_put(dat_entry);
1223 	return ret;
1224 }
1225 
1226 /**
1227  * batadv_dat_snoop_incoming_arp_request() - snoop the ARP request and try to
1228  * answer using the local DAT storage
1229  * @bat_priv: the bat priv with all the soft interface information
1230  * @skb: packet to check
1231  * @hdr_size: size of the encapsulation header
1232  *
1233  * Return: true if the request has been answered, false otherwise.
1234  */
1235 bool 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 	/* To preserve backwards compatibility, the node has choose the outgoing
1274 	 * format based on the incoming request packet type. The assumption is
1275 	 * that a node not using the 4addr packet format doesn't support it.
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 	}
1288 out:
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  * batadv_dat_snoop_outgoing_arp_reply() - snoop the ARP reply and fill the DHT
1298  * @bat_priv: the bat priv with all the soft interface information
1299  * @skb: packet to check
1300  */
1301 void 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 	/* Send the ARP reply to the candidates for both the IP addresses that
1330 	 * the node obtained from the ARP reply
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  * batadv_dat_snoop_incoming_arp_reply() - snoop the ARP reply and fill the
1340  *  local DAT storage only
1341  * @bat_priv: the bat priv with all the soft interface information
1342  * @skb: packet to check
1343  * @hdr_size: size of the encapsulation header
1344  *
1345  * Return: true if the packet was snooped and consumed by DAT. False if the
1346  * packet has to be delivered to the interface
1347  */
1348 bool 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 	/* If ip_dst is already in cache and has the right mac address,
1375 	 * drop this frame if this ARP reply is destined for us because it's
1376 	 * most probably an ARP reply generated by another node of the DHT.
1377 	 * We have most probably received already a reply earlier. Delivering
1378 	 * this frame would lead to doubled receive of an ARP reply.
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 	/* Update our internal cache with both the IP addresses the node got
1389 	 * within the ARP reply
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 	/* If BLA is enabled, only forward ARP replies if we have claimed the
1398 	 * source of the ARP reply or if no one else of the same backbone has
1399 	 * already claimed that client. This prevents that different gateways
1400 	 * to the same backbone all forward the ARP reply leading to multiple
1401 	 * replies in the backbone.
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 	/* if this REPLY is directed to a client of mine, let's deliver the
1412 	 * packet to the interface
1413 	 */
1414 	dropped = !batadv_is_my_client(bat_priv, hw_dst, vid);
1415 
1416 	/* if this REPLY is sent on behalf of a client of mine, let's drop the
1417 	 * packet because the client will reply by itself
1418 	 */
1419 	dropped |= batadv_is_my_client(bat_priv, hw_src, vid);
1420 out:
1421 	if (dropped)
1422 		kfree_skb(skb);
1423 	if (dat_entry)
1424 		batadv_dat_entry_put(dat_entry);
1425 	/* if dropped == false -> deliver to the interface */
1426 	return dropped;
1427 }
1428 
1429 /**
1430  * batadv_dat_check_dhcp_ipudp() - check skb for IP+UDP headers valid for DHCP
1431  * @skb: the packet to check
1432  * @ip_src: a buffer to store the IPv4 source address in
1433  *
1434  * Checks whether the given skb has an IP and UDP header valid for a DHCP
1435  * message from a DHCP server. And if so, stores the IPv4 source address in
1436  * the provided buffer.
1437  *
1438  * Return: True if valid, false otherwise.
1439  */
1440 static bool
1441 batadv_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  * batadv_dat_check_dhcp() - examine packet for valid DHCP message
1468  * @skb: the packet to check
1469  * @proto: ethernet protocol hint (behind a potential vlan)
1470  * @ip_src: a buffer to store the IPv4 source address in
1471  *
1472  * Checks whether the given skb is a valid DHCP packet. And if so, stores the
1473  * IPv4 source address in the provided buffer.
1474  *
1475  * Caller needs to ensure that the skb network header is set correctly.
1476  *
1477  * Return: If skb is a valid DHCP packet, then returns its op code
1478  * (e.g. BOOTREPLY vs. BOOTREQUEST). Otherwise returns -EINVAL.
1479  */
1480 static int
1481 batadv_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  * batadv_dat_get_dhcp_message_type() - get message type of a DHCP packet
1518  * @skb: the DHCP packet to parse
1519  *
1520  * Iterates over the DHCP options of the given DHCP packet to find a
1521  * DHCP Message Type option and parse it.
1522  *
1523  * Caller needs to ensure that the given skb is a valid DHCP packet and
1524  * that the skb transport header is set correctly.
1525  *
1526  * Return: The found DHCP message type value, if found. -EINVAL otherwise.
1527  */
1528 static 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 	/* Option Overload Code not supported */
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  * batadv_dat_dhcp_get_yiaddr() - get yiaddr from a DHCP packet
1568  * @skb: the DHCP packet to parse
1569  * @buf: a buffer to store the yiaddr in
1570  *
1571  * Caller needs to ensure that the given skb is a valid DHCP packet and
1572  * that the skb transport header is set correctly.
1573  *
1574  * Return: True on success, false otherwise.
1575  */
1576 static 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  * batadv_dat_get_dhcp_chaddr() - get chaddr from a DHCP packet
1595  * @skb: the DHCP packet to parse
1596  * @buf: a buffer to store the chaddr in
1597  *
1598  * Caller needs to ensure that the given skb is a valid DHCP packet and
1599  * that the skb transport header is set correctly.
1600  *
1601  * Return: True on success, false otherwise
1602  */
1603 static 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  * batadv_dat_put_dhcp() - puts addresses from a DHCP packet into the DHT and
1622  *  DAT cache
1623  * @bat_priv: the bat priv with all the soft interface information
1624  * @chaddr: the DHCP client MAC address
1625  * @yiaddr: the DHCP client IP address
1626  * @hw_dst: the DHCP server MAC address
1627  * @ip_dst: the DHCP server IP address
1628  * @vid: VLAN identifier
1629  *
1630  * Adds given MAC/IP pairs to the local DAT cache and propagates them further
1631  * into the DHT.
1632  *
1633  * For the DHT propagation, client MAC + IP will appear as the ARP Reply
1634  * transmitter (and hw_dst/ip_dst as the target).
1635  */
1636 static 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  * batadv_dat_check_dhcp_ack() - examine packet for valid DHCP message
1669  * @skb: the packet to check
1670  * @proto: ethernet protocol hint (behind a potential vlan)
1671  * @ip_src: a buffer to store the IPv4 source address in
1672  * @chaddr: a buffer to store the DHCP Client Hardware Address in
1673  * @yiaddr: a buffer to store the DHCP Your IP Address in
1674  *
1675  * Checks whether the given skb is a valid DHCPACK. And if so, stores the
1676  * IPv4 server source address (ip_src), client MAC address (chaddr) and client
1677  * IPv4 address (yiaddr) in the provided buffers.
1678  *
1679  * Caller needs to ensure that the skb network header is set correctly.
1680  *
1681  * Return: True if the skb is a valid DHCPACK. False otherwise.
1682  */
1683 static bool
1684 batadv_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  * batadv_dat_snoop_outgoing_dhcp_ack() - snoop DHCPACK and fill DAT with it
1708  * @bat_priv: the bat priv with all the soft interface information
1709  * @skb: the packet to snoop
1710  * @proto: ethernet protocol hint (behind a potential vlan)
1711  * @vid: VLAN identifier
1712  *
1713  * This function first checks whether the given skb is a valid DHCPACK. If
1714  * so then its source MAC and IP as well as its DHCP Client Hardware Address
1715  * field and DHCP Your IP Address field are added to the local DAT cache and
1716  * propagated into the DHT.
1717  *
1718  * Caller needs to ensure that the skb mac and network headers are set
1719  * correctly.
1720  */
1721 void 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  * batadv_dat_snoop_incoming_dhcp_ack() - snoop DHCPACK and fill DAT cache
1741  * @bat_priv: the bat priv with all the soft interface information
1742  * @skb: the packet to snoop
1743  * @hdr_size: header size, up to the tail of the batman-adv header
1744  *
1745  * This function first checks whether the given skb is a valid DHCPACK. If
1746  * so then its source MAC and IP as well as its DHCP Client Hardware Address
1747  * field and DHCP Your IP Address field are added to the local DAT cache.
1748  */
1749 void 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  * batadv_dat_drop_broadcast_packet() - check if an ARP request has to be
1788  *  dropped (because the node has already obtained the reply via DAT) or not
1789  * @bat_priv: the bat priv with all the soft interface information
1790  * @forw_packet: the broadcast packet
1791  *
1792  * Return: true if the node can drop the packet, false otherwise.
1793  */
1794 bool 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 	/* If this packet is an ARP_REQUEST and the node already has the
1808 	 * information that it is going to ask, then the packet can be dropped
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 	/* check if the node already got this entry */
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 
1832 out:
1833 	if (dat_entry)
1834 		batadv_dat_entry_put(dat_entry);
1835 	return ret;
1836 }
1837