• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2011-2020  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/seq_file.h>
30 #include <linux/skbuff.h>
31 #include <linux/slab.h>
32 #include <linux/spinlock.h>
33 #include <linux/stddef.h>
34 #include <linux/string.h>
35 #include <linux/udp.h>
36 #include <linux/workqueue.h>
37 #include <net/arp.h>
38 #include <net/genetlink.h>
39 #include <net/netlink.h>
40 #include <net/sock.h>
41 #include <uapi/linux/batman_adv.h>
42 
43 #include "bridge_loop_avoidance.h"
44 #include "hard-interface.h"
45 #include "hash.h"
46 #include "log.h"
47 #include "netlink.h"
48 #include "originator.h"
49 #include "send.h"
50 #include "soft-interface.h"
51 #include "translation-table.h"
52 #include "tvlv.h"
53 
54 enum batadv_bootpop {
55 	BATADV_BOOTREPLY	= 2,
56 };
57 
58 enum batadv_boothtype {
59 	BATADV_HTYPE_ETHERNET	= 1,
60 };
61 
62 enum batadv_dhcpoptioncode {
63 	BATADV_DHCP_OPT_PAD		= 0,
64 	BATADV_DHCP_OPT_MSG_TYPE	= 53,
65 	BATADV_DHCP_OPT_END		= 255,
66 };
67 
68 enum batadv_dhcptype {
69 	BATADV_DHCPACK		= 5,
70 };
71 
72 /* { 99, 130, 83, 99 } */
73 #define BATADV_DHCP_MAGIC 1669485411
74 
75 struct batadv_dhcp_packet {
76 	__u8 op;
77 	__u8 htype;
78 	__u8 hlen;
79 	__u8 hops;
80 	__be32 xid;
81 	__be16 secs;
82 	__be16 flags;
83 	__be32 ciaddr;
84 	__be32 yiaddr;
85 	__be32 siaddr;
86 	__be32 giaddr;
87 	__u8 chaddr[16];
88 	__u8 sname[64];
89 	__u8 file[128];
90 	__be32 magic;
91 	__u8 options[];
92 };
93 
94 #define BATADV_DHCP_YIADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->yiaddr)
95 #define BATADV_DHCP_CHADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->chaddr)
96 
97 static void batadv_dat_purge(struct work_struct *work);
98 
99 /**
100  * batadv_dat_start_timer() - initialise the DAT periodic worker
101  * @bat_priv: the bat priv with all the soft interface information
102  */
batadv_dat_start_timer(struct batadv_priv * bat_priv)103 static void batadv_dat_start_timer(struct batadv_priv *bat_priv)
104 {
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  */
batadv_dat_entry_release(struct kref * ref)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  */
batadv_dat_entry_put(struct batadv_dat_entry * dat_entry)128 static 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  * batadv_dat_to_purge() - check whether a dat_entry has to be purged or not
138  * @dat_entry: the entry to check
139  *
140  * Return: true if the entry has to be purged now, false otherwise.
141  */
batadv_dat_to_purge(struct batadv_dat_entry * dat_entry)142 static 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  * __batadv_dat_purge() - delete entries from the DAT local storage
150  * @bat_priv: the bat priv with all the soft interface information
151  * @to_purge: function in charge to decide whether an entry has to be purged or
152  *	      not. This function takes the dat_entry as argument and has to
153  *	      returns a boolean value: true is the entry has to be deleted,
154  *	      false otherwise
155  *
156  * Loops over each entry in the DAT local storage and deletes it if and only if
157  * the to_purge function passed as argument returns true.
158  */
__batadv_dat_purge(struct batadv_priv * bat_priv,bool (* to_purge)(struct batadv_dat_entry *))159 static void __batadv_dat_purge(struct batadv_priv *bat_priv,
160 			       bool (*to_purge)(struct batadv_dat_entry *))
161 {
162 	spinlock_t *list_lock; /* protects write access to the hash lists */
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 			/* if a helper function has been passed as parameter,
179 			 * ask it if the entry has to be purged or not
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  * batadv_dat_purge() - periodic task that deletes old entries from the local
193  *  DAT hash table
194  * @work: kernel work struct
195  */
batadv_dat_purge(struct work_struct * work)196 static 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  * batadv_compare_dat() - comparing function used in the local DAT hash table
212  * @node: node in the local table
213  * @data2: second object to compare the node to
214  *
215  * Return: true if the two entries are the same, false otherwise.
216  */
batadv_compare_dat(const struct hlist_node * node,const void * data2)217 static 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  * batadv_arp_hw_src() - extract the hw_src field from an ARP packet
227  * @skb: ARP packet
228  * @hdr_size: size of the possible header before the ARP packet
229  *
230  * Return: the value of the hw_src field in the ARP packet.
231  */
batadv_arp_hw_src(struct sk_buff * skb,int hdr_size)232 static 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  * batadv_arp_ip_src() - extract the ip_src field from an ARP packet
244  * @skb: ARP packet
245  * @hdr_size: size of the possible header before the ARP packet
246  *
247  * Return: the value of the ip_src field in the ARP packet.
248  */
batadv_arp_ip_src(struct sk_buff * skb,int hdr_size)249 static __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  * batadv_arp_hw_dst() - extract the hw_dst field from an ARP packet
256  * @skb: ARP packet
257  * @hdr_size: size of the possible header before the ARP packet
258  *
259  * Return: the value of the hw_dst field in the ARP packet.
260  */
batadv_arp_hw_dst(struct sk_buff * skb,int hdr_size)261 static 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  * batadv_arp_ip_dst() - extract the ip_dst field from an ARP packet
268  * @skb: ARP packet
269  * @hdr_size: size of the possible header before the ARP packet
270  *
271  * Return: the value of the ip_dst field in the ARP packet.
272  */
batadv_arp_ip_dst(struct sk_buff * skb,int hdr_size)273 static __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  * batadv_hash_dat() - compute the hash value for an IP address
282  * @data: data to hash
283  * @size: size of the hash table
284  *
285  * Return: the selected index in the hash table for the given data.
286  */
batadv_hash_dat(const void * data,u32 size)287 static 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  * batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash
319  * table
320  * @bat_priv: the bat priv with all the soft interface information
321  * @ip: search key
322  * @vid: VLAN identifier
323  *
324  * Return: the dat_entry if found, NULL otherwise.
325  */
326 static struct batadv_dat_entry *
batadv_dat_entry_hash_find(struct batadv_priv * bat_priv,__be32 ip,unsigned short vid)327 batadv_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  * batadv_dat_entry_add() - add a new dat entry or update it if already exists
362  * @bat_priv: the bat priv with all the soft interface information
363  * @ip: ipv4 to add/edit
364  * @mac_addr: mac address to assign to the given ipv4
365  * @vid: VLAN identifier
366  */
batadv_dat_entry_add(struct batadv_priv * bat_priv,__be32 ip,u8 * mac_addr,unsigned short vid)367 static 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 	/* if this entry is already known, just update it */
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 		/* remove the reference for the hash */
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 
410 out:
411 	if (dat_entry)
412 		batadv_dat_entry_put(dat_entry);
413 }
414 
415 #ifdef CONFIG_BATMAN_ADV_DEBUG
416 
417 /**
418  * batadv_dbg_arp() - print a debug message containing all the ARP packet
419  *  details
420  * @bat_priv: the bat priv with all the soft interface information
421  * @skb: ARP packet
422  * @hdr_size: size of the possible header before the ARP packet
423  * @msg: message to print together with the debugging information
424  */
batadv_dbg_arp(struct batadv_priv * bat_priv,struct sk_buff * skb,int hdr_size,char * msg)425 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
426 			   int hdr_size, char *msg)
427 {
428 	struct batadv_unicast_4addr_packet *unicast_4addr_packet;
429 	struct batadv_bcast_packet *bcast_pkt;
430 	u8 *orig_addr;
431 	__be32 ip_src, ip_dst;
432 
433 	if (msg)
434 		batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
435 
436 	ip_src = batadv_arp_ip_src(skb, hdr_size);
437 	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
438 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
439 		   "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
440 		   batadv_arp_hw_src(skb, hdr_size), &ip_src,
441 		   batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
442 
443 	if (hdr_size < sizeof(struct batadv_unicast_packet))
444 		return;
445 
446 	unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
447 
448 	switch (unicast_4addr_packet->u.packet_type) {
449 	case BATADV_UNICAST:
450 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
451 			   "* encapsulated within a UNICAST packet\n");
452 		break;
453 	case BATADV_UNICAST_4ADDR:
454 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
455 			   "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
456 			   unicast_4addr_packet->src);
457 		switch (unicast_4addr_packet->subtype) {
458 		case BATADV_P_DAT_DHT_PUT:
459 			batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
460 			break;
461 		case BATADV_P_DAT_DHT_GET:
462 			batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
463 			break;
464 		case BATADV_P_DAT_CACHE_REPLY:
465 			batadv_dbg(BATADV_DBG_DAT, bat_priv,
466 				   "* type: DAT_CACHE_REPLY\n");
467 			break;
468 		case BATADV_P_DATA:
469 			batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n");
470 			break;
471 		default:
472 			batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n",
473 				   unicast_4addr_packet->u.packet_type);
474 		}
475 		break;
476 	case BATADV_BCAST:
477 		bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet;
478 		orig_addr = bcast_pkt->orig;
479 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
480 			   "* encapsulated within a BCAST packet (src: %pM)\n",
481 			   orig_addr);
482 		break;
483 	default:
484 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
485 			   "* encapsulated within an unknown packet type (0x%x)\n",
486 			   unicast_4addr_packet->u.packet_type);
487 	}
488 }
489 
490 #else
491 
batadv_dbg_arp(struct batadv_priv * bat_priv,struct sk_buff * skb,int hdr_size,char * msg)492 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
493 			   int hdr_size, char *msg)
494 {
495 }
496 
497 #endif /* CONFIG_BATMAN_ADV_DEBUG */
498 
499 /**
500  * batadv_is_orig_node_eligible() - check whether a node can be a DHT candidate
501  * @res: the array with the already selected candidates
502  * @select: number of already selected candidates
503  * @tmp_max: address of the currently evaluated node
504  * @max: current round max address
505  * @last_max: address of the last selected candidate
506  * @candidate: orig_node under evaluation
507  * @max_orig_node: last selected candidate
508  *
509  * Return: true if the node has been elected as next candidate or false
510  * otherwise.
511  */
batadv_is_orig_node_eligible(struct batadv_dat_candidate * res,int select,batadv_dat_addr_t tmp_max,batadv_dat_addr_t max,batadv_dat_addr_t last_max,struct batadv_orig_node * candidate,struct batadv_orig_node * max_orig_node)512 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res,
513 					 int select, batadv_dat_addr_t tmp_max,
514 					 batadv_dat_addr_t max,
515 					 batadv_dat_addr_t last_max,
516 					 struct batadv_orig_node *candidate,
517 					 struct batadv_orig_node *max_orig_node)
518 {
519 	bool ret = false;
520 	int j;
521 
522 	/* check if orig node candidate is running DAT */
523 	if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities))
524 		goto out;
525 
526 	/* Check if this node has already been selected... */
527 	for (j = 0; j < select; j++)
528 		if (res[j].orig_node == candidate)
529 			break;
530 	/* ..and possibly skip it */
531 	if (j < select)
532 		goto out;
533 	/* sanity check: has it already been selected? This should not happen */
534 	if (tmp_max > last_max)
535 		goto out;
536 	/* check if during this iteration an originator with a closer dht
537 	 * address has already been found
538 	 */
539 	if (tmp_max < max)
540 		goto out;
541 	/* this is an hash collision with the temporary selected node. Choose
542 	 * the one with the lowest address
543 	 */
544 	if (tmp_max == max && max_orig_node &&
545 	    batadv_compare_eth(candidate->orig, max_orig_node->orig))
546 		goto out;
547 
548 	ret = true;
549 out:
550 	return ret;
551 }
552 
553 /**
554  * batadv_choose_next_candidate() - select the next DHT candidate
555  * @bat_priv: the bat priv with all the soft interface information
556  * @cands: candidates array
557  * @select: number of candidates already present in the array
558  * @ip_key: key to look up in the DHT
559  * @last_max: pointer where the address of the selected candidate will be saved
560  */
batadv_choose_next_candidate(struct batadv_priv * bat_priv,struct batadv_dat_candidate * cands,int select,batadv_dat_addr_t ip_key,batadv_dat_addr_t * last_max)561 static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
562 					 struct batadv_dat_candidate *cands,
563 					 int select, batadv_dat_addr_t ip_key,
564 					 batadv_dat_addr_t *last_max)
565 {
566 	batadv_dat_addr_t max = 0;
567 	batadv_dat_addr_t tmp_max = 0;
568 	struct batadv_orig_node *orig_node, *max_orig_node = NULL;
569 	struct batadv_hashtable *hash = bat_priv->orig_hash;
570 	struct hlist_head *head;
571 	int i;
572 
573 	/* if no node is eligible as candidate, leave the candidate type as
574 	 * NOT_FOUND
575 	 */
576 	cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
577 
578 	/* iterate over the originator list and find the node with the closest
579 	 * dat_address which has not been selected yet
580 	 */
581 	for (i = 0; i < hash->size; i++) {
582 		head = &hash->table[i];
583 
584 		rcu_read_lock();
585 		hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
586 			/* the dht space is a ring using unsigned addresses */
587 			tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
588 				  ip_key;
589 
590 			if (!batadv_is_orig_node_eligible(cands, select,
591 							  tmp_max, max,
592 							  *last_max, orig_node,
593 							  max_orig_node))
594 				continue;
595 
596 			if (!kref_get_unless_zero(&orig_node->refcount))
597 				continue;
598 
599 			max = tmp_max;
600 			if (max_orig_node)
601 				batadv_orig_node_put(max_orig_node);
602 			max_orig_node = orig_node;
603 		}
604 		rcu_read_unlock();
605 	}
606 	if (max_orig_node) {
607 		cands[select].type = BATADV_DAT_CANDIDATE_ORIG;
608 		cands[select].orig_node = max_orig_node;
609 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
610 			   "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
611 			   select, max_orig_node->orig, max_orig_node->dat_addr,
612 			   max);
613 	}
614 	*last_max = max;
615 }
616 
617 /**
618  * batadv_dat_select_candidates() - select the nodes which the DHT message has
619  *  to be sent to
620  * @bat_priv: the bat priv with all the soft interface information
621  * @ip_dst: ipv4 to look up in the DHT
622  * @vid: VLAN identifier
623  *
624  * An originator O is selected if and only if its DHT_ID value is one of three
625  * closest values (from the LEFT, with wrap around if needed) then the hash
626  * value of the key. ip_dst is the key.
627  *
628  * Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM.
629  */
630 static struct batadv_dat_candidate *
batadv_dat_select_candidates(struct batadv_priv * bat_priv,__be32 ip_dst,unsigned short vid)631 batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst,
632 			     unsigned short vid)
633 {
634 	int select;
635 	batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key;
636 	struct batadv_dat_candidate *res;
637 	struct batadv_dat_entry dat;
638 
639 	if (!bat_priv->orig_hash)
640 		return NULL;
641 
642 	res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res),
643 			    GFP_ATOMIC);
644 	if (!res)
645 		return NULL;
646 
647 	dat.ip = ip_dst;
648 	dat.vid = vid;
649 	ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat,
650 						    BATADV_DAT_ADDR_MAX);
651 
652 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
653 		   "%s(): IP=%pI4 hash(IP)=%u\n", __func__, &ip_dst,
654 		   ip_key);
655 
656 	for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
657 		batadv_choose_next_candidate(bat_priv, res, select, ip_key,
658 					     &last_max);
659 
660 	return res;
661 }
662 
663 /**
664  * batadv_dat_forward_data() - copy and send payload to the selected candidates
665  * @bat_priv: the bat priv with all the soft interface information
666  * @skb: payload to send
667  * @ip: the DHT key
668  * @vid: VLAN identifier
669  * @packet_subtype: unicast4addr packet subtype to use
670  *
671  * This function copies the skb with pskb_copy() and is sent as a unicast packet
672  * to each of the selected candidates.
673  *
674  * Return: true if the packet is sent to at least one candidate, false
675  * otherwise.
676  */
batadv_dat_forward_data(struct batadv_priv * bat_priv,struct sk_buff * skb,__be32 ip,unsigned short vid,int packet_subtype)677 static bool batadv_dat_forward_data(struct batadv_priv *bat_priv,
678 				    struct sk_buff *skb, __be32 ip,
679 				    unsigned short vid, int packet_subtype)
680 {
681 	int i;
682 	bool ret = false;
683 	int send_status;
684 	struct batadv_neigh_node *neigh_node = NULL;
685 	struct sk_buff *tmp_skb;
686 	struct batadv_dat_candidate *cand;
687 
688 	cand = batadv_dat_select_candidates(bat_priv, ip, vid);
689 	if (!cand)
690 		goto out;
691 
692 	batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
693 
694 	for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
695 		if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
696 			continue;
697 
698 		neigh_node = batadv_orig_router_get(cand[i].orig_node,
699 						    BATADV_IF_DEFAULT);
700 		if (!neigh_node)
701 			goto free_orig;
702 
703 		tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
704 		if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
705 							   cand[i].orig_node,
706 							   packet_subtype)) {
707 			kfree_skb(tmp_skb);
708 			goto free_neigh;
709 		}
710 
711 		send_status = batadv_send_unicast_skb(tmp_skb, neigh_node);
712 		if (send_status == NET_XMIT_SUCCESS) {
713 			/* count the sent packet */
714 			switch (packet_subtype) {
715 			case BATADV_P_DAT_DHT_GET:
716 				batadv_inc_counter(bat_priv,
717 						   BATADV_CNT_DAT_GET_TX);
718 				break;
719 			case BATADV_P_DAT_DHT_PUT:
720 				batadv_inc_counter(bat_priv,
721 						   BATADV_CNT_DAT_PUT_TX);
722 				break;
723 			}
724 
725 			/* packet sent to a candidate: return true */
726 			ret = true;
727 		}
728 free_neigh:
729 		batadv_neigh_node_put(neigh_node);
730 free_orig:
731 		batadv_orig_node_put(cand[i].orig_node);
732 	}
733 
734 out:
735 	kfree(cand);
736 	return ret;
737 }
738 
739 /**
740  * batadv_dat_tvlv_container_update() - update the dat tvlv container after dat
741  *  setting change
742  * @bat_priv: the bat priv with all the soft interface information
743  */
batadv_dat_tvlv_container_update(struct batadv_priv * bat_priv)744 static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
745 {
746 	char dat_mode;
747 
748 	dat_mode = atomic_read(&bat_priv->distributed_arp_table);
749 
750 	switch (dat_mode) {
751 	case 0:
752 		batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
753 		break;
754 	case 1:
755 		batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
756 					       NULL, 0);
757 		break;
758 	}
759 }
760 
761 /**
762  * batadv_dat_status_update() - update the dat tvlv container after dat
763  *  setting change
764  * @net_dev: the soft interface net device
765  */
batadv_dat_status_update(struct net_device * net_dev)766 void batadv_dat_status_update(struct net_device *net_dev)
767 {
768 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
769 
770 	batadv_dat_tvlv_container_update(bat_priv);
771 }
772 
773 /**
774  * batadv_dat_tvlv_ogm_handler_v1() - process incoming dat tvlv container
775  * @bat_priv: the bat priv with all the soft interface information
776  * @orig: the orig_node of the ogm
777  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
778  * @tvlv_value: tvlv buffer containing the gateway data
779  * @tvlv_value_len: tvlv buffer length
780  */
batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv * bat_priv,struct batadv_orig_node * orig,u8 flags,void * tvlv_value,u16 tvlv_value_len)781 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
782 					   struct batadv_orig_node *orig,
783 					   u8 flags,
784 					   void *tvlv_value, u16 tvlv_value_len)
785 {
786 	if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
787 		clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
788 	else
789 		set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
790 }
791 
792 /**
793  * batadv_dat_hash_free() - free the local DAT hash table
794  * @bat_priv: the bat priv with all the soft interface information
795  */
batadv_dat_hash_free(struct batadv_priv * bat_priv)796 static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
797 {
798 	if (!bat_priv->dat.hash)
799 		return;
800 
801 	__batadv_dat_purge(bat_priv, NULL);
802 
803 	batadv_hash_destroy(bat_priv->dat.hash);
804 
805 	bat_priv->dat.hash = NULL;
806 }
807 
808 /**
809  * batadv_dat_init() - initialise the DAT internals
810  * @bat_priv: the bat priv with all the soft interface information
811  *
812  * Return: 0 in case of success, a negative error code otherwise
813  */
batadv_dat_init(struct batadv_priv * bat_priv)814 int batadv_dat_init(struct batadv_priv *bat_priv)
815 {
816 	if (bat_priv->dat.hash)
817 		return 0;
818 
819 	bat_priv->dat.hash = batadv_hash_new(1024);
820 
821 	if (!bat_priv->dat.hash)
822 		return -ENOMEM;
823 
824 	INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge);
825 	batadv_dat_start_timer(bat_priv);
826 
827 	batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
828 				     NULL, BATADV_TVLV_DAT, 1,
829 				     BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
830 	batadv_dat_tvlv_container_update(bat_priv);
831 	return 0;
832 }
833 
834 /**
835  * batadv_dat_free() - free the DAT internals
836  * @bat_priv: the bat priv with all the soft interface information
837  */
batadv_dat_free(struct batadv_priv * bat_priv)838 void batadv_dat_free(struct batadv_priv *bat_priv)
839 {
840 	batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
841 	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
842 
843 	cancel_delayed_work_sync(&bat_priv->dat.work);
844 
845 	batadv_dat_hash_free(bat_priv);
846 }
847 
848 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
849 /**
850  * batadv_dat_cache_seq_print_text() - print the local DAT hash table
851  * @seq: seq file to print on
852  * @offset: not used
853  *
854  * Return: always 0
855  */
batadv_dat_cache_seq_print_text(struct seq_file * seq,void * offset)856 int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
857 {
858 	struct net_device *net_dev = (struct net_device *)seq->private;
859 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
860 	struct batadv_hashtable *hash = bat_priv->dat.hash;
861 	struct batadv_dat_entry *dat_entry;
862 	struct batadv_hard_iface *primary_if;
863 	struct hlist_head *head;
864 	unsigned long last_seen_jiffies;
865 	int last_seen_msecs, last_seen_secs, last_seen_mins;
866 	u32 i;
867 
868 	primary_if = batadv_seq_print_text_primary_if_get(seq);
869 	if (!primary_if)
870 		goto out;
871 
872 	seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name);
873 	seq_puts(seq,
874 		 "          IPv4             MAC        VID   last-seen\n");
875 
876 	for (i = 0; i < hash->size; i++) {
877 		head = &hash->table[i];
878 
879 		rcu_read_lock();
880 		hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
881 			last_seen_jiffies = jiffies - dat_entry->last_update;
882 			last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
883 			last_seen_mins = last_seen_msecs / 60000;
884 			last_seen_msecs = last_seen_msecs % 60000;
885 			last_seen_secs = last_seen_msecs / 1000;
886 
887 			seq_printf(seq, " * %15pI4 %pM %4i %6i:%02i\n",
888 				   &dat_entry->ip, dat_entry->mac_addr,
889 				   batadv_print_vid(dat_entry->vid),
890 				   last_seen_mins, last_seen_secs);
891 		}
892 		rcu_read_unlock();
893 	}
894 
895 out:
896 	if (primary_if)
897 		batadv_hardif_put(primary_if);
898 	return 0;
899 }
900 #endif
901 
902 /**
903  * batadv_dat_cache_dump_entry() - dump one entry of the DAT cache table to a
904  *  netlink socket
905  * @msg: buffer for the message
906  * @portid: netlink port
907  * @cb: Control block containing additional options
908  * @dat_entry: entry to dump
909  *
910  * Return: 0 or error code.
911  */
912 static int
batadv_dat_cache_dump_entry(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_dat_entry * dat_entry)913 batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid,
914 			    struct netlink_callback *cb,
915 			    struct batadv_dat_entry *dat_entry)
916 {
917 	int msecs;
918 	void *hdr;
919 
920 	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
921 			  &batadv_netlink_family, NLM_F_MULTI,
922 			  BATADV_CMD_GET_DAT_CACHE);
923 	if (!hdr)
924 		return -ENOBUFS;
925 
926 	genl_dump_check_consistent(cb, hdr);
927 
928 	msecs = jiffies_to_msecs(jiffies - dat_entry->last_update);
929 
930 	if (nla_put_in_addr(msg, BATADV_ATTR_DAT_CACHE_IP4ADDRESS,
931 			    dat_entry->ip) ||
932 	    nla_put(msg, BATADV_ATTR_DAT_CACHE_HWADDRESS, ETH_ALEN,
933 		    dat_entry->mac_addr) ||
934 	    nla_put_u16(msg, BATADV_ATTR_DAT_CACHE_VID, dat_entry->vid) ||
935 	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
936 		genlmsg_cancel(msg, hdr);
937 		return -EMSGSIZE;
938 	}
939 
940 	genlmsg_end(msg, hdr);
941 	return 0;
942 }
943 
944 /**
945  * batadv_dat_cache_dump_bucket() - dump one bucket of the DAT cache table to
946  *  a netlink socket
947  * @msg: buffer for the message
948  * @portid: netlink port
949  * @cb: Control block containing additional options
950  * @hash: hash to dump
951  * @bucket: bucket index to dump
952  * @idx_skip: How many entries to skip
953  *
954  * Return: 0 or error code.
955  */
956 static int
batadv_dat_cache_dump_bucket(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_hashtable * hash,unsigned int bucket,int * idx_skip)957 batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid,
958 			     struct netlink_callback *cb,
959 			     struct batadv_hashtable *hash, unsigned int bucket,
960 			     int *idx_skip)
961 {
962 	struct batadv_dat_entry *dat_entry;
963 	int idx = 0;
964 
965 	spin_lock_bh(&hash->list_locks[bucket]);
966 	cb->seq = atomic_read(&hash->generation) << 1 | 1;
967 
968 	hlist_for_each_entry(dat_entry, &hash->table[bucket], hash_entry) {
969 		if (idx < *idx_skip)
970 			goto skip;
971 
972 		if (batadv_dat_cache_dump_entry(msg, portid, cb, dat_entry)) {
973 			spin_unlock_bh(&hash->list_locks[bucket]);
974 			*idx_skip = idx;
975 
976 			return -EMSGSIZE;
977 		}
978 
979 skip:
980 		idx++;
981 	}
982 	spin_unlock_bh(&hash->list_locks[bucket]);
983 
984 	return 0;
985 }
986 
987 /**
988  * batadv_dat_cache_dump() - dump DAT cache table to a netlink socket
989  * @msg: buffer for the message
990  * @cb: callback structure containing arguments
991  *
992  * Return: message length.
993  */
batadv_dat_cache_dump(struct sk_buff * msg,struct netlink_callback * cb)994 int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb)
995 {
996 	struct batadv_hard_iface *primary_if = NULL;
997 	int portid = NETLINK_CB(cb->skb).portid;
998 	struct net *net = sock_net(cb->skb->sk);
999 	struct net_device *soft_iface;
1000 	struct batadv_hashtable *hash;
1001 	struct batadv_priv *bat_priv;
1002 	int bucket = cb->args[0];
1003 	int idx = cb->args[1];
1004 	int ifindex;
1005 	int ret = 0;
1006 
1007 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
1008 					     BATADV_ATTR_MESH_IFINDEX);
1009 	if (!ifindex)
1010 		return -EINVAL;
1011 
1012 	soft_iface = dev_get_by_index(net, ifindex);
1013 	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1014 		ret = -ENODEV;
1015 		goto out;
1016 	}
1017 
1018 	bat_priv = netdev_priv(soft_iface);
1019 	hash = bat_priv->dat.hash;
1020 
1021 	primary_if = batadv_primary_if_get_selected(bat_priv);
1022 	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
1023 		ret = -ENOENT;
1024 		goto out;
1025 	}
1026 
1027 	while (bucket < hash->size) {
1028 		if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket,
1029 						 &idx))
1030 			break;
1031 
1032 		bucket++;
1033 		idx = 0;
1034 	}
1035 
1036 	cb->args[0] = bucket;
1037 	cb->args[1] = idx;
1038 
1039 	ret = msg->len;
1040 
1041 out:
1042 	if (primary_if)
1043 		batadv_hardif_put(primary_if);
1044 
1045 	if (soft_iface)
1046 		dev_put(soft_iface);
1047 
1048 	return ret;
1049 }
1050 
1051 /**
1052  * batadv_arp_get_type() - parse an ARP packet and gets the type
1053  * @bat_priv: the bat priv with all the soft interface information
1054  * @skb: packet to analyse
1055  * @hdr_size: size of the possible header before the ARP packet in the skb
1056  *
1057  * Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise.
1058  */
batadv_arp_get_type(struct batadv_priv * bat_priv,struct sk_buff * skb,int hdr_size)1059 static u16 batadv_arp_get_type(struct batadv_priv *bat_priv,
1060 			       struct sk_buff *skb, int hdr_size)
1061 {
1062 	struct arphdr *arphdr;
1063 	struct ethhdr *ethhdr;
1064 	__be32 ip_src, ip_dst;
1065 	u8 *hw_src, *hw_dst;
1066 	u16 type = 0;
1067 
1068 	/* pull the ethernet header */
1069 	if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
1070 		goto out;
1071 
1072 	ethhdr = (struct ethhdr *)(skb->data + hdr_size);
1073 
1074 	if (ethhdr->h_proto != htons(ETH_P_ARP))
1075 		goto out;
1076 
1077 	/* pull the ARP payload */
1078 	if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
1079 				    arp_hdr_len(skb->dev))))
1080 		goto out;
1081 
1082 	arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
1083 
1084 	/* check whether the ARP packet carries a valid IP information */
1085 	if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
1086 		goto out;
1087 
1088 	if (arphdr->ar_pro != htons(ETH_P_IP))
1089 		goto out;
1090 
1091 	if (arphdr->ar_hln != ETH_ALEN)
1092 		goto out;
1093 
1094 	if (arphdr->ar_pln != 4)
1095 		goto out;
1096 
1097 	/* Check for bad reply/request. If the ARP message is not sane, DAT
1098 	 * will simply ignore it
1099 	 */
1100 	ip_src = batadv_arp_ip_src(skb, hdr_size);
1101 	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1102 	if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
1103 	    ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
1104 	    ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
1105 	    ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
1106 		goto out;
1107 
1108 	hw_src = batadv_arp_hw_src(skb, hdr_size);
1109 	if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
1110 		goto out;
1111 
1112 	/* don't care about the destination MAC address in ARP requests */
1113 	if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
1114 		hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1115 		if (is_zero_ether_addr(hw_dst) ||
1116 		    is_multicast_ether_addr(hw_dst))
1117 			goto out;
1118 	}
1119 
1120 	type = ntohs(arphdr->ar_op);
1121 out:
1122 	return type;
1123 }
1124 
1125 /**
1126  * batadv_dat_get_vid() - extract the VLAN identifier from skb if any
1127  * @skb: the buffer containing the packet to extract the VID from
1128  * @hdr_size: the size of the batman-adv header encapsulating the packet
1129  *
1130  * Return: If the packet embedded in the skb is vlan tagged this function
1131  * returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS
1132  * is returned.
1133  */
batadv_dat_get_vid(struct sk_buff * skb,int * hdr_size)1134 static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
1135 {
1136 	unsigned short vid;
1137 
1138 	vid = batadv_get_vid(skb, *hdr_size);
1139 
1140 	/* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
1141 	 * If the header contained in the packet is a VLAN one (which is longer)
1142 	 * hdr_size is updated so that the functions will still skip the
1143 	 * correct amount of bytes.
1144 	 */
1145 	if (vid & BATADV_VLAN_HAS_TAG)
1146 		*hdr_size += VLAN_HLEN;
1147 
1148 	return vid;
1149 }
1150 
1151 /**
1152  * batadv_dat_arp_create_reply() - create an ARP Reply
1153  * @bat_priv: the bat priv with all the soft interface information
1154  * @ip_src: ARP sender IP
1155  * @ip_dst: ARP target IP
1156  * @hw_src: Ethernet source and ARP sender MAC
1157  * @hw_dst: Ethernet destination and ARP target MAC
1158  * @vid: VLAN identifier (optional, set to zero otherwise)
1159  *
1160  * Creates an ARP Reply from the given values, optionally encapsulated in a
1161  * VLAN header.
1162  *
1163  * Return: An skb containing an ARP Reply.
1164  */
1165 static struct sk_buff *
batadv_dat_arp_create_reply(struct batadv_priv * bat_priv,__be32 ip_src,__be32 ip_dst,u8 * hw_src,u8 * hw_dst,unsigned short vid)1166 batadv_dat_arp_create_reply(struct batadv_priv *bat_priv, __be32 ip_src,
1167 			    __be32 ip_dst, u8 *hw_src, u8 *hw_dst,
1168 			    unsigned short vid)
1169 {
1170 	struct sk_buff *skb;
1171 
1172 	skb = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_dst, bat_priv->soft_iface,
1173 			 ip_src, hw_dst, hw_src, hw_dst);
1174 	if (!skb)
1175 		return NULL;
1176 
1177 	skb_reset_mac_header(skb);
1178 
1179 	if (vid & BATADV_VLAN_HAS_TAG)
1180 		skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
1181 				      vid & VLAN_VID_MASK);
1182 
1183 	return skb;
1184 }
1185 
1186 /**
1187  * batadv_dat_snoop_outgoing_arp_request() - snoop the ARP request and try to
1188  * answer using DAT
1189  * @bat_priv: the bat priv with all the soft interface information
1190  * @skb: packet to check
1191  *
1192  * Return: true if the message has been sent to the dht candidates, false
1193  * otherwise. In case of a positive return value the message has to be enqueued
1194  * to permit the fallback.
1195  */
batadv_dat_snoop_outgoing_arp_request(struct batadv_priv * bat_priv,struct sk_buff * skb)1196 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
1197 					   struct sk_buff *skb)
1198 {
1199 	u16 type = 0;
1200 	__be32 ip_dst, ip_src;
1201 	u8 *hw_src;
1202 	bool ret = false;
1203 	struct batadv_dat_entry *dat_entry = NULL;
1204 	struct sk_buff *skb_new;
1205 	struct net_device *soft_iface = bat_priv->soft_iface;
1206 	int hdr_size = 0;
1207 	unsigned short vid;
1208 
1209 	if (!atomic_read(&bat_priv->distributed_arp_table))
1210 		goto out;
1211 
1212 	vid = batadv_dat_get_vid(skb, &hdr_size);
1213 
1214 	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1215 	/* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
1216 	 * message to the selected DHT candidates
1217 	 */
1218 	if (type != ARPOP_REQUEST)
1219 		goto out;
1220 
1221 	batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REQUEST");
1222 
1223 	ip_src = batadv_arp_ip_src(skb, hdr_size);
1224 	hw_src = batadv_arp_hw_src(skb, hdr_size);
1225 	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1226 
1227 	batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1228 
1229 	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1230 	if (dat_entry) {
1231 		/* If the ARP request is destined for a local client the local
1232 		 * client will answer itself. DAT would only generate a
1233 		 * duplicate packet.
1234 		 *
1235 		 * Moreover, if the soft-interface is enslaved into a bridge, an
1236 		 * additional DAT answer may trigger kernel warnings about
1237 		 * a packet coming from the wrong port.
1238 		 */
1239 		if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
1240 			ret = true;
1241 			goto out;
1242 		}
1243 
1244 		/* If BLA is enabled, only send ARP replies if we have claimed
1245 		 * the destination for the ARP request or if no one else of
1246 		 * the backbone gws belonging to our backbone has claimed the
1247 		 * destination.
1248 		 */
1249 		if (!batadv_bla_check_claim(bat_priv,
1250 					    dat_entry->mac_addr, vid)) {
1251 			batadv_dbg(BATADV_DBG_DAT, bat_priv,
1252 				   "Device %pM claimed by another backbone gw. Don't send ARP reply!",
1253 				   dat_entry->mac_addr);
1254 			ret = true;
1255 			goto out;
1256 		}
1257 
1258 		skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
1259 						      dat_entry->mac_addr,
1260 						      hw_src, vid);
1261 		if (!skb_new)
1262 			goto out;
1263 
1264 		skb_new->protocol = eth_type_trans(skb_new, soft_iface);
1265 
1266 		batadv_inc_counter(bat_priv, BATADV_CNT_RX);
1267 		batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
1268 				   skb->len + ETH_HLEN + hdr_size);
1269 
1270 		netif_rx(skb_new);
1271 		batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
1272 		ret = true;
1273 	} else {
1274 		/* Send the request to the DHT */
1275 		ret = batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1276 					      BATADV_P_DAT_DHT_GET);
1277 	}
1278 out:
1279 	if (dat_entry)
1280 		batadv_dat_entry_put(dat_entry);
1281 	return ret;
1282 }
1283 
1284 /**
1285  * batadv_dat_snoop_incoming_arp_request() - snoop the ARP request and try to
1286  * answer using the local DAT storage
1287  * @bat_priv: the bat priv with all the soft interface information
1288  * @skb: packet to check
1289  * @hdr_size: size of the encapsulation header
1290  *
1291  * Return: true if the request has been answered, false otherwise.
1292  */
batadv_dat_snoop_incoming_arp_request(struct batadv_priv * bat_priv,struct sk_buff * skb,int hdr_size)1293 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
1294 					   struct sk_buff *skb, int hdr_size)
1295 {
1296 	u16 type;
1297 	__be32 ip_src, ip_dst;
1298 	u8 *hw_src;
1299 	struct sk_buff *skb_new;
1300 	struct batadv_dat_entry *dat_entry = NULL;
1301 	bool ret = false;
1302 	unsigned short vid;
1303 	int err;
1304 
1305 	if (!atomic_read(&bat_priv->distributed_arp_table))
1306 		goto out;
1307 
1308 	vid = batadv_dat_get_vid(skb, &hdr_size);
1309 
1310 	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1311 	if (type != ARPOP_REQUEST)
1312 		goto out;
1313 
1314 	hw_src = batadv_arp_hw_src(skb, hdr_size);
1315 	ip_src = batadv_arp_ip_src(skb, hdr_size);
1316 	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1317 
1318 	batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST");
1319 
1320 	batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1321 
1322 	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1323 	if (!dat_entry)
1324 		goto out;
1325 
1326 	skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
1327 					      dat_entry->mac_addr, hw_src, vid);
1328 	if (!skb_new)
1329 		goto out;
1330 
1331 	/* To preserve backwards compatibility, the node has choose the outgoing
1332 	 * format based on the incoming request packet type. The assumption is
1333 	 * that a node not using the 4addr packet format doesn't support it.
1334 	 */
1335 	if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
1336 		err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
1337 						   BATADV_P_DAT_CACHE_REPLY,
1338 						   NULL, vid);
1339 	else
1340 		err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
1341 
1342 	if (err != NET_XMIT_DROP) {
1343 		batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
1344 		ret = true;
1345 	}
1346 out:
1347 	if (dat_entry)
1348 		batadv_dat_entry_put(dat_entry);
1349 	if (ret)
1350 		kfree_skb(skb);
1351 	return ret;
1352 }
1353 
1354 /**
1355  * batadv_dat_snoop_outgoing_arp_reply() - snoop the ARP reply and fill the DHT
1356  * @bat_priv: the bat priv with all the soft interface information
1357  * @skb: packet to check
1358  */
batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv * bat_priv,struct sk_buff * skb)1359 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
1360 					 struct sk_buff *skb)
1361 {
1362 	u16 type;
1363 	__be32 ip_src, ip_dst;
1364 	u8 *hw_src, *hw_dst;
1365 	int hdr_size = 0;
1366 	unsigned short vid;
1367 
1368 	if (!atomic_read(&bat_priv->distributed_arp_table))
1369 		return;
1370 
1371 	vid = batadv_dat_get_vid(skb, &hdr_size);
1372 
1373 	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1374 	if (type != ARPOP_REPLY)
1375 		return;
1376 
1377 	batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REPLY");
1378 
1379 	hw_src = batadv_arp_hw_src(skb, hdr_size);
1380 	ip_src = batadv_arp_ip_src(skb, hdr_size);
1381 	hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1382 	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1383 
1384 	batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1385 	batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1386 
1387 	/* Send the ARP reply to the candidates for both the IP addresses that
1388 	 * the node obtained from the ARP reply
1389 	 */
1390 	batadv_dat_forward_data(bat_priv, skb, ip_src, vid,
1391 				BATADV_P_DAT_DHT_PUT);
1392 	batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1393 				BATADV_P_DAT_DHT_PUT);
1394 }
1395 
1396 /**
1397  * batadv_dat_snoop_incoming_arp_reply() - snoop the ARP reply and fill the
1398  *  local DAT storage only
1399  * @bat_priv: the bat priv with all the soft interface information
1400  * @skb: packet to check
1401  * @hdr_size: size of the encapsulation header
1402  *
1403  * Return: true if the packet was snooped and consumed by DAT. False if the
1404  * packet has to be delivered to the interface
1405  */
batadv_dat_snoop_incoming_arp_reply(struct batadv_priv * bat_priv,struct sk_buff * skb,int hdr_size)1406 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
1407 					 struct sk_buff *skb, int hdr_size)
1408 {
1409 	struct batadv_dat_entry *dat_entry = NULL;
1410 	u16 type;
1411 	__be32 ip_src, ip_dst;
1412 	u8 *hw_src, *hw_dst;
1413 	bool dropped = false;
1414 	unsigned short vid;
1415 
1416 	if (!atomic_read(&bat_priv->distributed_arp_table))
1417 		goto out;
1418 
1419 	vid = batadv_dat_get_vid(skb, &hdr_size);
1420 
1421 	type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1422 	if (type != ARPOP_REPLY)
1423 		goto out;
1424 
1425 	batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REPLY");
1426 
1427 	hw_src = batadv_arp_hw_src(skb, hdr_size);
1428 	ip_src = batadv_arp_ip_src(skb, hdr_size);
1429 	hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1430 	ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1431 
1432 	/* If ip_dst is already in cache and has the right mac address,
1433 	 * drop this frame if this ARP reply is destined for us because it's
1434 	 * most probably an ARP reply generated by another node of the DHT.
1435 	 * We have most probably received already a reply earlier. Delivering
1436 	 * this frame would lead to doubled receive of an ARP reply.
1437 	 */
1438 	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid);
1439 	if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) {
1440 		batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n",
1441 			   hw_src, &ip_src, hw_dst, &ip_dst,
1442 			   dat_entry->mac_addr,	&dat_entry->ip);
1443 		dropped = true;
1444 	}
1445 
1446 	/* Update our internal cache with both the IP addresses the node got
1447 	 * within the ARP reply
1448 	 */
1449 	batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1450 	batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1451 
1452 	if (dropped)
1453 		goto out;
1454 
1455 	/* If BLA is enabled, only forward ARP replies if we have claimed the
1456 	 * source of the ARP reply or if no one else of the same backbone has
1457 	 * already claimed that client. This prevents that different gateways
1458 	 * to the same backbone all forward the ARP reply leading to multiple
1459 	 * replies in the backbone.
1460 	 */
1461 	if (!batadv_bla_check_claim(bat_priv, hw_src, vid)) {
1462 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
1463 			   "Device %pM claimed by another backbone gw. Drop ARP reply.\n",
1464 			   hw_src);
1465 		dropped = true;
1466 		goto out;
1467 	}
1468 
1469 	/* if this REPLY is directed to a client of mine, let's deliver the
1470 	 * packet to the interface
1471 	 */
1472 	dropped = !batadv_is_my_client(bat_priv, hw_dst, vid);
1473 
1474 	/* if this REPLY is sent on behalf of a client of mine, let's drop the
1475 	 * packet because the client will reply by itself
1476 	 */
1477 	dropped |= batadv_is_my_client(bat_priv, hw_src, vid);
1478 out:
1479 	if (dropped)
1480 		kfree_skb(skb);
1481 	if (dat_entry)
1482 		batadv_dat_entry_put(dat_entry);
1483 	/* if dropped == false -> deliver to the interface */
1484 	return dropped;
1485 }
1486 
1487 /**
1488  * batadv_dat_check_dhcp_ipudp() - check skb for IP+UDP headers valid for DHCP
1489  * @skb: the packet to check
1490  * @ip_src: a buffer to store the IPv4 source address in
1491  *
1492  * Checks whether the given skb has an IP and UDP header valid for a DHCP
1493  * message from a DHCP server. And if so, stores the IPv4 source address in
1494  * the provided buffer.
1495  *
1496  * Return: True if valid, false otherwise.
1497  */
1498 static bool
batadv_dat_check_dhcp_ipudp(struct sk_buff * skb,__be32 * ip_src)1499 batadv_dat_check_dhcp_ipudp(struct sk_buff *skb, __be32 *ip_src)
1500 {
1501 	unsigned int offset = skb_network_offset(skb);
1502 	struct udphdr *udphdr, _udphdr;
1503 	struct iphdr *iphdr, _iphdr;
1504 
1505 	iphdr = skb_header_pointer(skb, offset, sizeof(_iphdr), &_iphdr);
1506 	if (!iphdr || iphdr->version != 4 || iphdr->ihl * 4 < sizeof(_iphdr))
1507 		return false;
1508 
1509 	if (iphdr->protocol != IPPROTO_UDP)
1510 		return false;
1511 
1512 	offset += iphdr->ihl * 4;
1513 	skb_set_transport_header(skb, offset);
1514 
1515 	udphdr = skb_header_pointer(skb, offset, sizeof(_udphdr), &_udphdr);
1516 	if (!udphdr || udphdr->source != htons(67))
1517 		return false;
1518 
1519 	*ip_src = get_unaligned(&iphdr->saddr);
1520 
1521 	return true;
1522 }
1523 
1524 /**
1525  * batadv_dat_check_dhcp() - examine packet for valid DHCP message
1526  * @skb: the packet to check
1527  * @proto: ethernet protocol hint (behind a potential vlan)
1528  * @ip_src: a buffer to store the IPv4 source address in
1529  *
1530  * Checks whether the given skb is a valid DHCP packet. And if so, stores the
1531  * IPv4 source address in the provided buffer.
1532  *
1533  * Caller needs to ensure that the skb network header is set correctly.
1534  *
1535  * Return: If skb is a valid DHCP packet, then returns its op code
1536  * (e.g. BOOTREPLY vs. BOOTREQUEST). Otherwise returns -EINVAL.
1537  */
1538 static int
batadv_dat_check_dhcp(struct sk_buff * skb,__be16 proto,__be32 * ip_src)1539 batadv_dat_check_dhcp(struct sk_buff *skb, __be16 proto, __be32 *ip_src)
1540 {
1541 	__be32 *magic, _magic;
1542 	unsigned int offset;
1543 	struct {
1544 		__u8 op;
1545 		__u8 htype;
1546 		__u8 hlen;
1547 		__u8 hops;
1548 	} *dhcp_h, _dhcp_h;
1549 
1550 	if (proto != htons(ETH_P_IP))
1551 		return -EINVAL;
1552 
1553 	if (!batadv_dat_check_dhcp_ipudp(skb, ip_src))
1554 		return -EINVAL;
1555 
1556 	offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1557 	if (skb->len < offset + sizeof(struct batadv_dhcp_packet))
1558 		return -EINVAL;
1559 
1560 	dhcp_h = skb_header_pointer(skb, offset, sizeof(_dhcp_h), &_dhcp_h);
1561 	if (!dhcp_h || dhcp_h->htype != BATADV_HTYPE_ETHERNET ||
1562 	    dhcp_h->hlen != ETH_ALEN)
1563 		return -EINVAL;
1564 
1565 	offset += offsetof(struct batadv_dhcp_packet, magic);
1566 
1567 	magic = skb_header_pointer(skb, offset, sizeof(_magic), &_magic);
1568 	if (!magic || get_unaligned(magic) != htonl(BATADV_DHCP_MAGIC))
1569 		return -EINVAL;
1570 
1571 	return dhcp_h->op;
1572 }
1573 
1574 /**
1575  * batadv_dat_get_dhcp_message_type() - get message type of a DHCP packet
1576  * @skb: the DHCP packet to parse
1577  *
1578  * Iterates over the DHCP options of the given DHCP packet to find a
1579  * DHCP Message Type option and parse it.
1580  *
1581  * Caller needs to ensure that the given skb is a valid DHCP packet and
1582  * that the skb transport header is set correctly.
1583  *
1584  * Return: The found DHCP message type value, if found. -EINVAL otherwise.
1585  */
batadv_dat_get_dhcp_message_type(struct sk_buff * skb)1586 static int batadv_dat_get_dhcp_message_type(struct sk_buff *skb)
1587 {
1588 	unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1589 	u8 *type, _type;
1590 	struct {
1591 		u8 type;
1592 		u8 len;
1593 	} *tl, _tl;
1594 
1595 	offset += sizeof(struct batadv_dhcp_packet);
1596 
1597 	while ((tl = skb_header_pointer(skb, offset, sizeof(_tl), &_tl))) {
1598 		if (tl->type == BATADV_DHCP_OPT_MSG_TYPE)
1599 			break;
1600 
1601 		if (tl->type == BATADV_DHCP_OPT_END)
1602 			break;
1603 
1604 		if (tl->type == BATADV_DHCP_OPT_PAD)
1605 			offset++;
1606 		else
1607 			offset += tl->len + sizeof(_tl);
1608 	}
1609 
1610 	/* Option Overload Code not supported */
1611 	if (!tl || tl->type != BATADV_DHCP_OPT_MSG_TYPE ||
1612 	    tl->len != sizeof(_type))
1613 		return -EINVAL;
1614 
1615 	offset += sizeof(_tl);
1616 
1617 	type = skb_header_pointer(skb, offset, sizeof(_type), &_type);
1618 	if (!type)
1619 		return -EINVAL;
1620 
1621 	return *type;
1622 }
1623 
1624 /**
1625  * batadv_dat_get_dhcp_yiaddr() - get yiaddr from a DHCP packet
1626  * @skb: the DHCP packet to parse
1627  * @buf: a buffer to store the yiaddr in
1628  *
1629  * Caller needs to ensure that the given skb is a valid DHCP packet and
1630  * that the skb transport header is set correctly.
1631  *
1632  * Return: True on success, false otherwise.
1633  */
batadv_dat_dhcp_get_yiaddr(struct sk_buff * skb,__be32 * buf)1634 static bool batadv_dat_dhcp_get_yiaddr(struct sk_buff *skb, __be32 *buf)
1635 {
1636 	unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1637 	__be32 *yiaddr;
1638 
1639 	offset += offsetof(struct batadv_dhcp_packet, yiaddr);
1640 	yiaddr = skb_header_pointer(skb, offset, BATADV_DHCP_YIADDR_LEN, buf);
1641 
1642 	if (!yiaddr)
1643 		return false;
1644 
1645 	if (yiaddr != buf)
1646 		*buf = get_unaligned(yiaddr);
1647 
1648 	return true;
1649 }
1650 
1651 /**
1652  * batadv_dat_get_dhcp_chaddr() - get chaddr from a DHCP packet
1653  * @skb: the DHCP packet to parse
1654  * @buf: a buffer to store the chaddr in
1655  *
1656  * Caller needs to ensure that the given skb is a valid DHCP packet and
1657  * that the skb transport header is set correctly.
1658  *
1659  * Return: True on success, false otherwise
1660  */
batadv_dat_get_dhcp_chaddr(struct sk_buff * skb,u8 * buf)1661 static bool batadv_dat_get_dhcp_chaddr(struct sk_buff *skb, u8 *buf)
1662 {
1663 	unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1664 	u8 *chaddr;
1665 
1666 	offset += offsetof(struct batadv_dhcp_packet, chaddr);
1667 	chaddr = skb_header_pointer(skb, offset, BATADV_DHCP_CHADDR_LEN, buf);
1668 
1669 	if (!chaddr)
1670 		return false;
1671 
1672 	if (chaddr != buf)
1673 		memcpy(buf, chaddr, BATADV_DHCP_CHADDR_LEN);
1674 
1675 	return true;
1676 }
1677 
1678 /**
1679  * batadv_dat_put_dhcp() - puts addresses from a DHCP packet into the DHT and
1680  *  DAT cache
1681  * @bat_priv: the bat priv with all the soft interface information
1682  * @chaddr: the DHCP client MAC address
1683  * @yiaddr: the DHCP client IP address
1684  * @hw_dst: the DHCP server MAC address
1685  * @ip_dst: the DHCP server IP address
1686  * @vid: VLAN identifier
1687  *
1688  * Adds given MAC/IP pairs to the local DAT cache and propagates them further
1689  * into the DHT.
1690  *
1691  * For the DHT propagation, client MAC + IP will appear as the ARP Reply
1692  * transmitter (and hw_dst/ip_dst as the target).
1693  */
batadv_dat_put_dhcp(struct batadv_priv * bat_priv,u8 * chaddr,__be32 yiaddr,u8 * hw_dst,__be32 ip_dst,unsigned short vid)1694 static void batadv_dat_put_dhcp(struct batadv_priv *bat_priv, u8 *chaddr,
1695 				__be32 yiaddr, u8 *hw_dst, __be32 ip_dst,
1696 				unsigned short vid)
1697 {
1698 	struct sk_buff *skb;
1699 
1700 	skb = batadv_dat_arp_create_reply(bat_priv, yiaddr, ip_dst, chaddr,
1701 					  hw_dst, vid);
1702 	if (!skb)
1703 		return;
1704 
1705 	skb_set_network_header(skb, ETH_HLEN);
1706 
1707 	batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid);
1708 	batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1709 
1710 	batadv_dat_forward_data(bat_priv, skb, yiaddr, vid,
1711 				BATADV_P_DAT_DHT_PUT);
1712 	batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1713 				BATADV_P_DAT_DHT_PUT);
1714 
1715 	consume_skb(skb);
1716 
1717 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
1718 		   "Snooped from outgoing DHCPACK (server address): %pI4, %pM (vid: %i)\n",
1719 		   &ip_dst, hw_dst, batadv_print_vid(vid));
1720 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
1721 		   "Snooped from outgoing DHCPACK (client address): %pI4, %pM (vid: %i)\n",
1722 		   &yiaddr, chaddr, batadv_print_vid(vid));
1723 }
1724 
1725 /**
1726  * batadv_dat_check_dhcp_ack() - examine packet for valid DHCP message
1727  * @skb: the packet to check
1728  * @proto: ethernet protocol hint (behind a potential vlan)
1729  * @ip_src: a buffer to store the IPv4 source address in
1730  * @chaddr: a buffer to store the DHCP Client Hardware Address in
1731  * @yiaddr: a buffer to store the DHCP Your IP Address in
1732  *
1733  * Checks whether the given skb is a valid DHCPACK. And if so, stores the
1734  * IPv4 server source address (ip_src), client MAC address (chaddr) and client
1735  * IPv4 address (yiaddr) in the provided buffers.
1736  *
1737  * Caller needs to ensure that the skb network header is set correctly.
1738  *
1739  * Return: True if the skb is a valid DHCPACK. False otherwise.
1740  */
1741 static bool
batadv_dat_check_dhcp_ack(struct sk_buff * skb,__be16 proto,__be32 * ip_src,u8 * chaddr,__be32 * yiaddr)1742 batadv_dat_check_dhcp_ack(struct sk_buff *skb, __be16 proto, __be32 *ip_src,
1743 			  u8 *chaddr, __be32 *yiaddr)
1744 {
1745 	int type;
1746 
1747 	type = batadv_dat_check_dhcp(skb, proto, ip_src);
1748 	if (type != BATADV_BOOTREPLY)
1749 		return false;
1750 
1751 	type = batadv_dat_get_dhcp_message_type(skb);
1752 	if (type != BATADV_DHCPACK)
1753 		return false;
1754 
1755 	if (!batadv_dat_dhcp_get_yiaddr(skb, yiaddr))
1756 		return false;
1757 
1758 	if (!batadv_dat_get_dhcp_chaddr(skb, chaddr))
1759 		return false;
1760 
1761 	return true;
1762 }
1763 
1764 /**
1765  * batadv_dat_snoop_outgoing_dhcp_ack() - snoop DHCPACK and fill DAT with it
1766  * @bat_priv: the bat priv with all the soft interface information
1767  * @skb: the packet to snoop
1768  * @proto: ethernet protocol hint (behind a potential vlan)
1769  * @vid: VLAN identifier
1770  *
1771  * This function first checks whether the given skb is a valid DHCPACK. If
1772  * so then its source MAC and IP as well as its DHCP Client Hardware Address
1773  * field and DHCP Your IP Address field are added to the local DAT cache and
1774  * propagated into the DHT.
1775  *
1776  * Caller needs to ensure that the skb mac and network headers are set
1777  * correctly.
1778  */
batadv_dat_snoop_outgoing_dhcp_ack(struct batadv_priv * bat_priv,struct sk_buff * skb,__be16 proto,unsigned short vid)1779 void batadv_dat_snoop_outgoing_dhcp_ack(struct batadv_priv *bat_priv,
1780 					struct sk_buff *skb,
1781 					__be16 proto,
1782 					unsigned short vid)
1783 {
1784 	u8 chaddr[BATADV_DHCP_CHADDR_LEN];
1785 	__be32 ip_src, yiaddr;
1786 
1787 	if (!atomic_read(&bat_priv->distributed_arp_table))
1788 		return;
1789 
1790 	if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr))
1791 		return;
1792 
1793 	batadv_dat_put_dhcp(bat_priv, chaddr, yiaddr, eth_hdr(skb)->h_source,
1794 			    ip_src, vid);
1795 }
1796 
1797 /**
1798  * batadv_dat_snoop_incoming_dhcp_ack() - snoop DHCPACK and fill DAT cache
1799  * @bat_priv: the bat priv with all the soft interface information
1800  * @skb: the packet to snoop
1801  * @hdr_size: header size, up to the tail of the batman-adv header
1802  *
1803  * This function first checks whether the given skb is a valid DHCPACK. If
1804  * so then its source MAC and IP as well as its DHCP Client Hardware Address
1805  * field and DHCP Your IP Address field are added to the local DAT cache.
1806  */
batadv_dat_snoop_incoming_dhcp_ack(struct batadv_priv * bat_priv,struct sk_buff * skb,int hdr_size)1807 void batadv_dat_snoop_incoming_dhcp_ack(struct batadv_priv *bat_priv,
1808 					struct sk_buff *skb, int hdr_size)
1809 {
1810 	u8 chaddr[BATADV_DHCP_CHADDR_LEN];
1811 	struct ethhdr *ethhdr;
1812 	__be32 ip_src, yiaddr;
1813 	unsigned short vid;
1814 	__be16 proto;
1815 	u8 *hw_src;
1816 
1817 	if (!atomic_read(&bat_priv->distributed_arp_table))
1818 		return;
1819 
1820 	if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
1821 		return;
1822 
1823 	ethhdr = (struct ethhdr *)(skb->data + hdr_size);
1824 	skb_set_network_header(skb, hdr_size + ETH_HLEN);
1825 	proto = ethhdr->h_proto;
1826 
1827 	if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr))
1828 		return;
1829 
1830 	hw_src = ethhdr->h_source;
1831 	vid = batadv_dat_get_vid(skb, &hdr_size);
1832 
1833 	batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid);
1834 	batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1835 
1836 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
1837 		   "Snooped from incoming DHCPACK (server address): %pI4, %pM (vid: %i)\n",
1838 		   &ip_src, hw_src, batadv_print_vid(vid));
1839 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
1840 		   "Snooped from incoming DHCPACK (client address): %pI4, %pM (vid: %i)\n",
1841 		   &yiaddr, chaddr, batadv_print_vid(vid));
1842 }
1843 
1844 /**
1845  * batadv_dat_drop_broadcast_packet() - check if an ARP request has to be
1846  *  dropped (because the node has already obtained the reply via DAT) or not
1847  * @bat_priv: the bat priv with all the soft interface information
1848  * @forw_packet: the broadcast packet
1849  *
1850  * Return: true if the node can drop the packet, false otherwise.
1851  */
batadv_dat_drop_broadcast_packet(struct batadv_priv * bat_priv,struct batadv_forw_packet * forw_packet)1852 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
1853 				      struct batadv_forw_packet *forw_packet)
1854 {
1855 	u16 type;
1856 	__be32 ip_dst;
1857 	struct batadv_dat_entry *dat_entry = NULL;
1858 	bool ret = false;
1859 	int hdr_size = sizeof(struct batadv_bcast_packet);
1860 	unsigned short vid;
1861 
1862 	if (!atomic_read(&bat_priv->distributed_arp_table))
1863 		goto out;
1864 
1865 	/* If this packet is an ARP_REQUEST and the node already has the
1866 	 * information that it is going to ask, then the packet can be dropped
1867 	 */
1868 	if (batadv_forw_packet_is_rebroadcast(forw_packet))
1869 		goto out;
1870 
1871 	vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
1872 
1873 	type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
1874 	if (type != ARPOP_REQUEST)
1875 		goto out;
1876 
1877 	ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
1878 	dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1879 	/* check if the node already got this entry */
1880 	if (!dat_entry) {
1881 		batadv_dbg(BATADV_DBG_DAT, bat_priv,
1882 			   "ARP Request for %pI4: fallback\n", &ip_dst);
1883 		goto out;
1884 	}
1885 
1886 	batadv_dbg(BATADV_DBG_DAT, bat_priv,
1887 		   "ARP Request for %pI4: fallback prevented\n", &ip_dst);
1888 	ret = true;
1889 
1890 out:
1891 	if (dat_entry)
1892 		batadv_dat_entry_put(dat_entry);
1893 	return ret;
1894 }
1895