1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) B.A.T.M.A.N. contributors:
3  *
4  * Simon Wunderlich
5  */
6 
7 #include "bridge_loop_avoidance.h"
8 #include "main.h"
9 
10 #include <linux/atomic.h>
11 #include <linux/byteorder/generic.h>
12 #include <linux/compiler.h>
13 #include <linux/crc16.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/jhash.h>
21 #include <linux/jiffies.h>
22 #include <linux/kernel.h>
23 #include <linux/kref.h>
24 #include <linux/list.h>
25 #include <linux/lockdep.h>
26 #include <linux/netdevice.h>
27 #include <linux/netlink.h>
28 #include <linux/rculist.h>
29 #include <linux/rcupdate.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/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/batadv_packet.h>
41 #include <uapi/linux/batman_adv.h>
42 
43 #include "hard-interface.h"
44 #include "hash.h"
45 #include "log.h"
46 #include "netlink.h"
47 #include "originator.h"
48 #include "soft-interface.h"
49 #include "translation-table.h"
50 
51 static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
52 
53 static void batadv_bla_periodic_work(struct work_struct *work);
54 static void
55 batadv_bla_send_announce(struct batadv_priv *bat_priv,
56 			 struct batadv_bla_backbone_gw *backbone_gw);
57 
58 /**
59  * batadv_choose_claim() - choose the right bucket for a claim.
60  * @data: data to hash
61  * @size: size of the hash table
62  *
63  * Return: the hash index of the claim
64  */
65 static inline u32 batadv_choose_claim(const void *data, u32 size)
66 {
67 	struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
68 	u32 hash = 0;
69 
70 	hash = jhash(&claim->addr, sizeof(claim->addr), hash);
71 	hash = jhash(&claim->vid, sizeof(claim->vid), hash);
72 
73 	return hash % size;
74 }
75 
76 /**
77  * batadv_choose_backbone_gw() - choose the right bucket for a backbone gateway.
78  * @data: data to hash
79  * @size: size of the hash table
80  *
81  * Return: the hash index of the backbone gateway
82  */
83 static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
84 {
85 	const struct batadv_bla_backbone_gw *gw;
86 	u32 hash = 0;
87 
88 	gw = (struct batadv_bla_backbone_gw *)data;
89 	hash = jhash(&gw->orig, sizeof(gw->orig), hash);
90 	hash = jhash(&gw->vid, sizeof(gw->vid), hash);
91 
92 	return hash % size;
93 }
94 
95 /**
96  * batadv_compare_backbone_gw() - compare address and vid of two backbone gws
97  * @node: list node of the first entry to compare
98  * @data2: pointer to the second backbone gateway
99  *
100  * Return: true if the backbones have the same data, false otherwise
101  */
102 static bool batadv_compare_backbone_gw(const struct hlist_node *node,
103 				       const void *data2)
104 {
105 	const void *data1 = container_of(node, struct batadv_bla_backbone_gw,
106 					 hash_entry);
107 	const struct batadv_bla_backbone_gw *gw1 = data1;
108 	const struct batadv_bla_backbone_gw *gw2 = data2;
109 
110 	if (!batadv_compare_eth(gw1->orig, gw2->orig))
111 		return false;
112 
113 	if (gw1->vid != gw2->vid)
114 		return false;
115 
116 	return true;
117 }
118 
119 /**
120  * batadv_compare_claim() - compare address and vid of two claims
121  * @node: list node of the first entry to compare
122  * @data2: pointer to the second claims
123  *
124  * Return: true if the claim have the same data, 0 otherwise
125  */
126 static bool batadv_compare_claim(const struct hlist_node *node,
127 				 const void *data2)
128 {
129 	const void *data1 = container_of(node, struct batadv_bla_claim,
130 					 hash_entry);
131 	const struct batadv_bla_claim *cl1 = data1;
132 	const struct batadv_bla_claim *cl2 = data2;
133 
134 	if (!batadv_compare_eth(cl1->addr, cl2->addr))
135 		return false;
136 
137 	if (cl1->vid != cl2->vid)
138 		return false;
139 
140 	return true;
141 }
142 
143 /**
144  * batadv_backbone_gw_release() - release backbone gw from lists and queue for
145  *  free after rcu grace period
146  * @ref: kref pointer of the backbone gw
147  */
148 static void batadv_backbone_gw_release(struct kref *ref)
149 {
150 	struct batadv_bla_backbone_gw *backbone_gw;
151 
152 	backbone_gw = container_of(ref, struct batadv_bla_backbone_gw,
153 				   refcount);
154 
155 	kfree_rcu(backbone_gw, rcu);
156 }
157 
158 /**
159  * batadv_backbone_gw_put() - decrement the backbone gw refcounter and possibly
160  *  release it
161  * @backbone_gw: backbone gateway to be free'd
162  */
163 static void batadv_backbone_gw_put(struct batadv_bla_backbone_gw *backbone_gw)
164 {
165 	kref_put(&backbone_gw->refcount, batadv_backbone_gw_release);
166 }
167 
168 /**
169  * batadv_claim_release() - release claim from lists and queue for free after
170  *  rcu grace period
171  * @ref: kref pointer of the claim
172  */
173 static void batadv_claim_release(struct kref *ref)
174 {
175 	struct batadv_bla_claim *claim;
176 	struct batadv_bla_backbone_gw *old_backbone_gw;
177 
178 	claim = container_of(ref, struct batadv_bla_claim, refcount);
179 
180 	spin_lock_bh(&claim->backbone_lock);
181 	old_backbone_gw = claim->backbone_gw;
182 	claim->backbone_gw = NULL;
183 	spin_unlock_bh(&claim->backbone_lock);
184 
185 	spin_lock_bh(&old_backbone_gw->crc_lock);
186 	old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
187 	spin_unlock_bh(&old_backbone_gw->crc_lock);
188 
189 	batadv_backbone_gw_put(old_backbone_gw);
190 
191 	kfree_rcu(claim, rcu);
192 }
193 
194 /**
195  * batadv_claim_put() - decrement the claim refcounter and possibly release it
196  * @claim: claim to be free'd
197  */
198 static void batadv_claim_put(struct batadv_bla_claim *claim)
199 {
200 	kref_put(&claim->refcount, batadv_claim_release);
201 }
202 
203 /**
204  * batadv_claim_hash_find() - looks for a claim in the claim hash
205  * @bat_priv: the bat priv with all the soft interface information
206  * @data: search data (may be local/static data)
207  *
208  * Return: claim if found or NULL otherwise.
209  */
210 static struct batadv_bla_claim *
211 batadv_claim_hash_find(struct batadv_priv *bat_priv,
212 		       struct batadv_bla_claim *data)
213 {
214 	struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
215 	struct hlist_head *head;
216 	struct batadv_bla_claim *claim;
217 	struct batadv_bla_claim *claim_tmp = NULL;
218 	int index;
219 
220 	if (!hash)
221 		return NULL;
222 
223 	index = batadv_choose_claim(data, hash->size);
224 	head = &hash->table[index];
225 
226 	rcu_read_lock();
227 	hlist_for_each_entry_rcu(claim, head, hash_entry) {
228 		if (!batadv_compare_claim(&claim->hash_entry, data))
229 			continue;
230 
231 		if (!kref_get_unless_zero(&claim->refcount))
232 			continue;
233 
234 		claim_tmp = claim;
235 		break;
236 	}
237 	rcu_read_unlock();
238 
239 	return claim_tmp;
240 }
241 
242 /**
243  * batadv_backbone_hash_find() - looks for a backbone gateway in the hash
244  * @bat_priv: the bat priv with all the soft interface information
245  * @addr: the address of the originator
246  * @vid: the VLAN ID
247  *
248  * Return: backbone gateway if found or NULL otherwise
249  */
250 static struct batadv_bla_backbone_gw *
251 batadv_backbone_hash_find(struct batadv_priv *bat_priv, u8 *addr,
252 			  unsigned short vid)
253 {
254 	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
255 	struct hlist_head *head;
256 	struct batadv_bla_backbone_gw search_entry, *backbone_gw;
257 	struct batadv_bla_backbone_gw *backbone_gw_tmp = NULL;
258 	int index;
259 
260 	if (!hash)
261 		return NULL;
262 
263 	ether_addr_copy(search_entry.orig, addr);
264 	search_entry.vid = vid;
265 
266 	index = batadv_choose_backbone_gw(&search_entry, hash->size);
267 	head = &hash->table[index];
268 
269 	rcu_read_lock();
270 	hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
271 		if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
272 						&search_entry))
273 			continue;
274 
275 		if (!kref_get_unless_zero(&backbone_gw->refcount))
276 			continue;
277 
278 		backbone_gw_tmp = backbone_gw;
279 		break;
280 	}
281 	rcu_read_unlock();
282 
283 	return backbone_gw_tmp;
284 }
285 
286 /**
287  * batadv_bla_del_backbone_claims() - delete all claims for a backbone
288  * @backbone_gw: backbone gateway where the claims should be removed
289  */
290 static void
291 batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
292 {
293 	struct batadv_hashtable *hash;
294 	struct hlist_node *node_tmp;
295 	struct hlist_head *head;
296 	struct batadv_bla_claim *claim;
297 	int i;
298 	spinlock_t *list_lock;	/* protects write access to the hash lists */
299 
300 	hash = backbone_gw->bat_priv->bla.claim_hash;
301 	if (!hash)
302 		return;
303 
304 	for (i = 0; i < hash->size; i++) {
305 		head = &hash->table[i];
306 		list_lock = &hash->list_locks[i];
307 
308 		spin_lock_bh(list_lock);
309 		hlist_for_each_entry_safe(claim, node_tmp,
310 					  head, hash_entry) {
311 			if (claim->backbone_gw != backbone_gw)
312 				continue;
313 
314 			batadv_claim_put(claim);
315 			hlist_del_rcu(&claim->hash_entry);
316 		}
317 		spin_unlock_bh(list_lock);
318 	}
319 
320 	/* all claims gone, initialize CRC */
321 	spin_lock_bh(&backbone_gw->crc_lock);
322 	backbone_gw->crc = BATADV_BLA_CRC_INIT;
323 	spin_unlock_bh(&backbone_gw->crc_lock);
324 }
325 
326 /**
327  * batadv_bla_send_claim() - sends a claim frame according to the provided info
328  * @bat_priv: the bat priv with all the soft interface information
329  * @mac: the mac address to be announced within the claim
330  * @vid: the VLAN ID
331  * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
332  */
333 static void batadv_bla_send_claim(struct batadv_priv *bat_priv, u8 *mac,
334 				  unsigned short vid, int claimtype)
335 {
336 	struct sk_buff *skb;
337 	struct ethhdr *ethhdr;
338 	struct batadv_hard_iface *primary_if;
339 	struct net_device *soft_iface;
340 	u8 *hw_src;
341 	struct batadv_bla_claim_dst local_claim_dest;
342 	__be32 zeroip = 0;
343 
344 	primary_if = batadv_primary_if_get_selected(bat_priv);
345 	if (!primary_if)
346 		return;
347 
348 	memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
349 	       sizeof(local_claim_dest));
350 	local_claim_dest.type = claimtype;
351 
352 	soft_iface = primary_if->soft_iface;
353 
354 	skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
355 			 /* IP DST: 0.0.0.0 */
356 			 zeroip,
357 			 primary_if->soft_iface,
358 			 /* IP SRC: 0.0.0.0 */
359 			 zeroip,
360 			 /* Ethernet DST: Broadcast */
361 			 NULL,
362 			 /* Ethernet SRC/HW SRC:  originator mac */
363 			 primary_if->net_dev->dev_addr,
364 			 /* HW DST: FF:43:05:XX:YY:YY
365 			  * with XX   = claim type
366 			  * and YY:YY = group id
367 			  */
368 			 (u8 *)&local_claim_dest);
369 
370 	if (!skb)
371 		goto out;
372 
373 	ethhdr = (struct ethhdr *)skb->data;
374 	hw_src = (u8 *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
375 
376 	/* now we pretend that the client would have sent this ... */
377 	switch (claimtype) {
378 	case BATADV_CLAIM_TYPE_CLAIM:
379 		/* normal claim frame
380 		 * set Ethernet SRC to the clients mac
381 		 */
382 		ether_addr_copy(ethhdr->h_source, mac);
383 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
384 			   "%s(): CLAIM %pM on vid %d\n", __func__, mac,
385 			   batadv_print_vid(vid));
386 		break;
387 	case BATADV_CLAIM_TYPE_UNCLAIM:
388 		/* unclaim frame
389 		 * set HW SRC to the clients mac
390 		 */
391 		ether_addr_copy(hw_src, mac);
392 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
393 			   "%s(): UNCLAIM %pM on vid %d\n", __func__, mac,
394 			   batadv_print_vid(vid));
395 		break;
396 	case BATADV_CLAIM_TYPE_ANNOUNCE:
397 		/* announcement frame
398 		 * set HW SRC to the special mac containing the crc
399 		 */
400 		ether_addr_copy(hw_src, mac);
401 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
402 			   "%s(): ANNOUNCE of %pM on vid %d\n", __func__,
403 			   ethhdr->h_source, batadv_print_vid(vid));
404 		break;
405 	case BATADV_CLAIM_TYPE_REQUEST:
406 		/* request frame
407 		 * set HW SRC and header destination to the receiving backbone
408 		 * gws mac
409 		 */
410 		ether_addr_copy(hw_src, mac);
411 		ether_addr_copy(ethhdr->h_dest, mac);
412 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
413 			   "%s(): REQUEST of %pM to %pM on vid %d\n", __func__,
414 			   ethhdr->h_source, ethhdr->h_dest,
415 			   batadv_print_vid(vid));
416 		break;
417 	case BATADV_CLAIM_TYPE_LOOPDETECT:
418 		ether_addr_copy(ethhdr->h_source, mac);
419 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
420 			   "%s(): LOOPDETECT of %pM to %pM on vid %d\n",
421 			   __func__, ethhdr->h_source, ethhdr->h_dest,
422 			   batadv_print_vid(vid));
423 
424 		break;
425 	}
426 
427 	if (vid & BATADV_VLAN_HAS_TAG) {
428 		skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
429 				      vid & VLAN_VID_MASK);
430 		if (!skb)
431 			goto out;
432 	}
433 
434 	skb_reset_mac_header(skb);
435 	skb->protocol = eth_type_trans(skb, soft_iface);
436 	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
437 	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
438 			   skb->len + ETH_HLEN);
439 
440 	netif_rx_any_context(skb);
441 out:
442 	if (primary_if)
443 		batadv_hardif_put(primary_if);
444 }
445 
446 /**
447  * batadv_bla_loopdetect_report() - worker for reporting the loop
448  * @work: work queue item
449  *
450  * Throws an uevent, as the loopdetect check function can't do that itself
451  * since the kernel may sleep while throwing uevents.
452  */
453 static void batadv_bla_loopdetect_report(struct work_struct *work)
454 {
455 	struct batadv_bla_backbone_gw *backbone_gw;
456 	struct batadv_priv *bat_priv;
457 	char vid_str[6] = { '\0' };
458 
459 	backbone_gw = container_of(work, struct batadv_bla_backbone_gw,
460 				   report_work);
461 	bat_priv = backbone_gw->bat_priv;
462 
463 	batadv_info(bat_priv->soft_iface,
464 		    "Possible loop on VLAN %d detected which can't be handled by BLA - please check your network setup!\n",
465 		    batadv_print_vid(backbone_gw->vid));
466 	snprintf(vid_str, sizeof(vid_str), "%d",
467 		 batadv_print_vid(backbone_gw->vid));
468 	vid_str[sizeof(vid_str) - 1] = 0;
469 
470 	batadv_throw_uevent(bat_priv, BATADV_UEV_BLA, BATADV_UEV_LOOPDETECT,
471 			    vid_str);
472 
473 	batadv_backbone_gw_put(backbone_gw);
474 }
475 
476 /**
477  * batadv_bla_get_backbone_gw() - finds or creates a backbone gateway
478  * @bat_priv: the bat priv with all the soft interface information
479  * @orig: the mac address of the originator
480  * @vid: the VLAN ID
481  * @own_backbone: set if the requested backbone is local
482  *
483  * Return: the (possibly created) backbone gateway or NULL on error
484  */
485 static struct batadv_bla_backbone_gw *
486 batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, u8 *orig,
487 			   unsigned short vid, bool own_backbone)
488 {
489 	struct batadv_bla_backbone_gw *entry;
490 	struct batadv_orig_node *orig_node;
491 	int hash_added;
492 
493 	entry = batadv_backbone_hash_find(bat_priv, orig, vid);
494 
495 	if (entry)
496 		return entry;
497 
498 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
499 		   "%s(): not found (%pM, %d), creating new entry\n", __func__,
500 		   orig, batadv_print_vid(vid));
501 
502 	entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
503 	if (!entry)
504 		return NULL;
505 
506 	entry->vid = vid;
507 	entry->lasttime = jiffies;
508 	entry->crc = BATADV_BLA_CRC_INIT;
509 	entry->bat_priv = bat_priv;
510 	spin_lock_init(&entry->crc_lock);
511 	atomic_set(&entry->request_sent, 0);
512 	atomic_set(&entry->wait_periods, 0);
513 	ether_addr_copy(entry->orig, orig);
514 	INIT_WORK(&entry->report_work, batadv_bla_loopdetect_report);
515 	kref_init(&entry->refcount);
516 
517 	kref_get(&entry->refcount);
518 	hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
519 				     batadv_compare_backbone_gw,
520 				     batadv_choose_backbone_gw, entry,
521 				     &entry->hash_entry);
522 
523 	if (unlikely(hash_added != 0)) {
524 		/* hash failed, free the structure */
525 		kfree(entry);
526 		return NULL;
527 	}
528 
529 	/* this is a gateway now, remove any TT entry on this VLAN */
530 	orig_node = batadv_orig_hash_find(bat_priv, orig);
531 	if (orig_node) {
532 		batadv_tt_global_del_orig(bat_priv, orig_node, vid,
533 					  "became a backbone gateway");
534 		batadv_orig_node_put(orig_node);
535 	}
536 
537 	if (own_backbone) {
538 		batadv_bla_send_announce(bat_priv, entry);
539 
540 		/* this will be decreased in the worker thread */
541 		atomic_inc(&entry->request_sent);
542 		atomic_set(&entry->wait_periods, BATADV_BLA_WAIT_PERIODS);
543 		atomic_inc(&bat_priv->bla.num_requests);
544 	}
545 
546 	return entry;
547 }
548 
549 /**
550  * batadv_bla_update_own_backbone_gw() - updates the own backbone gw for a VLAN
551  * @bat_priv: the bat priv with all the soft interface information
552  * @primary_if: the selected primary interface
553  * @vid: VLAN identifier
554  *
555  * update or add the own backbone gw to make sure we announce
556  * where we receive other backbone gws
557  */
558 static void
559 batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
560 				  struct batadv_hard_iface *primary_if,
561 				  unsigned short vid)
562 {
563 	struct batadv_bla_backbone_gw *backbone_gw;
564 
565 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
566 						 primary_if->net_dev->dev_addr,
567 						 vid, true);
568 	if (unlikely(!backbone_gw))
569 		return;
570 
571 	backbone_gw->lasttime = jiffies;
572 	batadv_backbone_gw_put(backbone_gw);
573 }
574 
575 /**
576  * batadv_bla_answer_request() - answer a bla request by sending own claims
577  * @bat_priv: the bat priv with all the soft interface information
578  * @primary_if: interface where the request came on
579  * @vid: the vid where the request came on
580  *
581  * Repeat all of our own claims, and finally send an ANNOUNCE frame
582  * to allow the requester another check if the CRC is correct now.
583  */
584 static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
585 				      struct batadv_hard_iface *primary_if,
586 				      unsigned short vid)
587 {
588 	struct hlist_head *head;
589 	struct batadv_hashtable *hash;
590 	struct batadv_bla_claim *claim;
591 	struct batadv_bla_backbone_gw *backbone_gw;
592 	int i;
593 
594 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
595 		   "%s(): received a claim request, send all of our own claims again\n",
596 		   __func__);
597 
598 	backbone_gw = batadv_backbone_hash_find(bat_priv,
599 						primary_if->net_dev->dev_addr,
600 						vid);
601 	if (!backbone_gw)
602 		return;
603 
604 	hash = bat_priv->bla.claim_hash;
605 	for (i = 0; i < hash->size; i++) {
606 		head = &hash->table[i];
607 
608 		rcu_read_lock();
609 		hlist_for_each_entry_rcu(claim, head, hash_entry) {
610 			/* only own claims are interesting */
611 			if (claim->backbone_gw != backbone_gw)
612 				continue;
613 
614 			batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
615 					      BATADV_CLAIM_TYPE_CLAIM);
616 		}
617 		rcu_read_unlock();
618 	}
619 
620 	/* finally, send an announcement frame */
621 	batadv_bla_send_announce(bat_priv, backbone_gw);
622 	batadv_backbone_gw_put(backbone_gw);
623 }
624 
625 /**
626  * batadv_bla_send_request() - send a request to repeat claims
627  * @backbone_gw: the backbone gateway from whom we are out of sync
628  *
629  * When the crc is wrong, ask the backbone gateway for a full table update.
630  * After the request, it will repeat all of his own claims and finally
631  * send an announcement claim with which we can check again.
632  */
633 static void batadv_bla_send_request(struct batadv_bla_backbone_gw *backbone_gw)
634 {
635 	/* first, remove all old entries */
636 	batadv_bla_del_backbone_claims(backbone_gw);
637 
638 	batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
639 		   "Sending REQUEST to %pM\n", backbone_gw->orig);
640 
641 	/* send request */
642 	batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
643 			      backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
644 
645 	/* no local broadcasts should be sent or received, for now. */
646 	if (!atomic_read(&backbone_gw->request_sent)) {
647 		atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
648 		atomic_set(&backbone_gw->request_sent, 1);
649 	}
650 }
651 
652 /**
653  * batadv_bla_send_announce() - Send an announcement frame
654  * @bat_priv: the bat priv with all the soft interface information
655  * @backbone_gw: our backbone gateway which should be announced
656  */
657 static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
658 				     struct batadv_bla_backbone_gw *backbone_gw)
659 {
660 	u8 mac[ETH_ALEN];
661 	__be16 crc;
662 
663 	memcpy(mac, batadv_announce_mac, 4);
664 	spin_lock_bh(&backbone_gw->crc_lock);
665 	crc = htons(backbone_gw->crc);
666 	spin_unlock_bh(&backbone_gw->crc_lock);
667 	memcpy(&mac[4], &crc, 2);
668 
669 	batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
670 			      BATADV_CLAIM_TYPE_ANNOUNCE);
671 }
672 
673 /**
674  * batadv_bla_add_claim() - Adds a claim in the claim hash
675  * @bat_priv: the bat priv with all the soft interface information
676  * @mac: the mac address of the claim
677  * @vid: the VLAN ID of the frame
678  * @backbone_gw: the backbone gateway which claims it
679  */
680 static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
681 				 const u8 *mac, const unsigned short vid,
682 				 struct batadv_bla_backbone_gw *backbone_gw)
683 {
684 	struct batadv_bla_backbone_gw *old_backbone_gw;
685 	struct batadv_bla_claim *claim;
686 	struct batadv_bla_claim search_claim;
687 	bool remove_crc = false;
688 	int hash_added;
689 
690 	ether_addr_copy(search_claim.addr, mac);
691 	search_claim.vid = vid;
692 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
693 
694 	/* create a new claim entry if it does not exist yet. */
695 	if (!claim) {
696 		claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
697 		if (!claim)
698 			return;
699 
700 		ether_addr_copy(claim->addr, mac);
701 		spin_lock_init(&claim->backbone_lock);
702 		claim->vid = vid;
703 		claim->lasttime = jiffies;
704 		kref_get(&backbone_gw->refcount);
705 		claim->backbone_gw = backbone_gw;
706 		kref_init(&claim->refcount);
707 
708 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
709 			   "%s(): adding new entry %pM, vid %d to hash ...\n",
710 			   __func__, mac, batadv_print_vid(vid));
711 
712 		kref_get(&claim->refcount);
713 		hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
714 					     batadv_compare_claim,
715 					     batadv_choose_claim, claim,
716 					     &claim->hash_entry);
717 
718 		if (unlikely(hash_added != 0)) {
719 			/* only local changes happened. */
720 			kfree(claim);
721 			return;
722 		}
723 	} else {
724 		claim->lasttime = jiffies;
725 		if (claim->backbone_gw == backbone_gw)
726 			/* no need to register a new backbone */
727 			goto claim_free_ref;
728 
729 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
730 			   "%s(): changing ownership for %pM, vid %d to gw %pM\n",
731 			   __func__, mac, batadv_print_vid(vid),
732 			   backbone_gw->orig);
733 
734 		remove_crc = true;
735 	}
736 
737 	/* replace backbone_gw atomically and adjust reference counters */
738 	spin_lock_bh(&claim->backbone_lock);
739 	old_backbone_gw = claim->backbone_gw;
740 	kref_get(&backbone_gw->refcount);
741 	claim->backbone_gw = backbone_gw;
742 	spin_unlock_bh(&claim->backbone_lock);
743 
744 	if (remove_crc) {
745 		/* remove claim address from old backbone_gw */
746 		spin_lock_bh(&old_backbone_gw->crc_lock);
747 		old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
748 		spin_unlock_bh(&old_backbone_gw->crc_lock);
749 	}
750 
751 	batadv_backbone_gw_put(old_backbone_gw);
752 
753 	/* add claim address to new backbone_gw */
754 	spin_lock_bh(&backbone_gw->crc_lock);
755 	backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
756 	spin_unlock_bh(&backbone_gw->crc_lock);
757 	backbone_gw->lasttime = jiffies;
758 
759 claim_free_ref:
760 	batadv_claim_put(claim);
761 }
762 
763 /**
764  * batadv_bla_claim_get_backbone_gw() - Get valid reference for backbone_gw of
765  *  claim
766  * @claim: claim whose backbone_gw should be returned
767  *
768  * Return: valid reference to claim::backbone_gw
769  */
770 static struct batadv_bla_backbone_gw *
771 batadv_bla_claim_get_backbone_gw(struct batadv_bla_claim *claim)
772 {
773 	struct batadv_bla_backbone_gw *backbone_gw;
774 
775 	spin_lock_bh(&claim->backbone_lock);
776 	backbone_gw = claim->backbone_gw;
777 	kref_get(&backbone_gw->refcount);
778 	spin_unlock_bh(&claim->backbone_lock);
779 
780 	return backbone_gw;
781 }
782 
783 /**
784  * batadv_bla_del_claim() - delete a claim from the claim hash
785  * @bat_priv: the bat priv with all the soft interface information
786  * @mac: mac address of the claim to be removed
787  * @vid: VLAN id for the claim to be removed
788  */
789 static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
790 				 const u8 *mac, const unsigned short vid)
791 {
792 	struct batadv_bla_claim search_claim, *claim;
793 	struct batadv_bla_claim *claim_removed_entry;
794 	struct hlist_node *claim_removed_node;
795 
796 	ether_addr_copy(search_claim.addr, mac);
797 	search_claim.vid = vid;
798 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
799 	if (!claim)
800 		return;
801 
802 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__,
803 		   mac, batadv_print_vid(vid));
804 
805 	claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash,
806 						batadv_compare_claim,
807 						batadv_choose_claim, claim);
808 	if (!claim_removed_node)
809 		goto free_claim;
810 
811 	/* reference from the hash is gone */
812 	claim_removed_entry = hlist_entry(claim_removed_node,
813 					  struct batadv_bla_claim, hash_entry);
814 	batadv_claim_put(claim_removed_entry);
815 
816 free_claim:
817 	/* don't need the reference from hash_find() anymore */
818 	batadv_claim_put(claim);
819 }
820 
821 /**
822  * batadv_handle_announce() - check for ANNOUNCE frame
823  * @bat_priv: the bat priv with all the soft interface information
824  * @an_addr: announcement mac address (ARP Sender HW address)
825  * @backbone_addr: originator address of the sender (Ethernet source MAC)
826  * @vid: the VLAN ID of the frame
827  *
828  * Return: true if handled
829  */
830 static bool batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
831 				   u8 *backbone_addr, unsigned short vid)
832 {
833 	struct batadv_bla_backbone_gw *backbone_gw;
834 	u16 backbone_crc, crc;
835 
836 	if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
837 		return false;
838 
839 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
840 						 false);
841 
842 	if (unlikely(!backbone_gw))
843 		return true;
844 
845 	/* handle as ANNOUNCE frame */
846 	backbone_gw->lasttime = jiffies;
847 	crc = ntohs(*((__force __be16 *)(&an_addr[4])));
848 
849 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
850 		   "%s(): ANNOUNCE vid %d (sent by %pM)... CRC = %#.4x\n",
851 		   __func__, batadv_print_vid(vid), backbone_gw->orig, crc);
852 
853 	spin_lock_bh(&backbone_gw->crc_lock);
854 	backbone_crc = backbone_gw->crc;
855 	spin_unlock_bh(&backbone_gw->crc_lock);
856 
857 	if (backbone_crc != crc) {
858 		batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
859 			   "%s(): CRC FAILED for %pM/%d (my = %#.4x, sent = %#.4x)\n",
860 			   __func__, backbone_gw->orig,
861 			   batadv_print_vid(backbone_gw->vid),
862 			   backbone_crc, crc);
863 
864 		batadv_bla_send_request(backbone_gw);
865 	} else {
866 		/* if we have sent a request and the crc was OK,
867 		 * we can allow traffic again.
868 		 */
869 		if (atomic_read(&backbone_gw->request_sent)) {
870 			atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
871 			atomic_set(&backbone_gw->request_sent, 0);
872 		}
873 	}
874 
875 	batadv_backbone_gw_put(backbone_gw);
876 	return true;
877 }
878 
879 /**
880  * batadv_handle_request() - check for REQUEST frame
881  * @bat_priv: the bat priv with all the soft interface information
882  * @primary_if: the primary hard interface of this batman soft interface
883  * @backbone_addr: backbone address to be requested (ARP sender HW MAC)
884  * @ethhdr: ethernet header of a packet
885  * @vid: the VLAN ID of the frame
886  *
887  * Return: true if handled
888  */
889 static bool batadv_handle_request(struct batadv_priv *bat_priv,
890 				  struct batadv_hard_iface *primary_if,
891 				  u8 *backbone_addr, struct ethhdr *ethhdr,
892 				  unsigned short vid)
893 {
894 	/* check for REQUEST frame */
895 	if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
896 		return false;
897 
898 	/* sanity check, this should not happen on a normal switch,
899 	 * we ignore it in this case.
900 	 */
901 	if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
902 		return true;
903 
904 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
905 		   "%s(): REQUEST vid %d (sent by %pM)...\n",
906 		   __func__, batadv_print_vid(vid), ethhdr->h_source);
907 
908 	batadv_bla_answer_request(bat_priv, primary_if, vid);
909 	return true;
910 }
911 
912 /**
913  * batadv_handle_unclaim() - check for UNCLAIM frame
914  * @bat_priv: the bat priv with all the soft interface information
915  * @primary_if: the primary hard interface of this batman soft interface
916  * @backbone_addr: originator address of the backbone (Ethernet source)
917  * @claim_addr: Client to be unclaimed (ARP sender HW MAC)
918  * @vid: the VLAN ID of the frame
919  *
920  * Return: true if handled
921  */
922 static bool batadv_handle_unclaim(struct batadv_priv *bat_priv,
923 				  struct batadv_hard_iface *primary_if,
924 				  u8 *backbone_addr, u8 *claim_addr,
925 				  unsigned short vid)
926 {
927 	struct batadv_bla_backbone_gw *backbone_gw;
928 
929 	/* unclaim in any case if it is our own */
930 	if (primary_if && batadv_compare_eth(backbone_addr,
931 					     primary_if->net_dev->dev_addr))
932 		batadv_bla_send_claim(bat_priv, claim_addr, vid,
933 				      BATADV_CLAIM_TYPE_UNCLAIM);
934 
935 	backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
936 
937 	if (!backbone_gw)
938 		return true;
939 
940 	/* this must be an UNCLAIM frame */
941 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
942 		   "%s(): UNCLAIM %pM on vid %d (sent by %pM)...\n", __func__,
943 		   claim_addr, batadv_print_vid(vid), backbone_gw->orig);
944 
945 	batadv_bla_del_claim(bat_priv, claim_addr, vid);
946 	batadv_backbone_gw_put(backbone_gw);
947 	return true;
948 }
949 
950 /**
951  * batadv_handle_claim() - check for CLAIM frame
952  * @bat_priv: the bat priv with all the soft interface information
953  * @primary_if: the primary hard interface of this batman soft interface
954  * @backbone_addr: originator address of the backbone (Ethernet Source)
955  * @claim_addr: client mac address to be claimed (ARP sender HW MAC)
956  * @vid: the VLAN ID of the frame
957  *
958  * Return: true if handled
959  */
960 static bool batadv_handle_claim(struct batadv_priv *bat_priv,
961 				struct batadv_hard_iface *primary_if,
962 				u8 *backbone_addr, u8 *claim_addr,
963 				unsigned short vid)
964 {
965 	struct batadv_bla_backbone_gw *backbone_gw;
966 
967 	/* register the gateway if not yet available, and add the claim. */
968 
969 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
970 						 false);
971 
972 	if (unlikely(!backbone_gw))
973 		return true;
974 
975 	/* this must be a CLAIM frame */
976 	batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
977 	if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
978 		batadv_bla_send_claim(bat_priv, claim_addr, vid,
979 				      BATADV_CLAIM_TYPE_CLAIM);
980 
981 	/* TODO: we could call something like tt_local_del() here. */
982 
983 	batadv_backbone_gw_put(backbone_gw);
984 	return true;
985 }
986 
987 /**
988  * batadv_check_claim_group() - check for claim group membership
989  * @bat_priv: the bat priv with all the soft interface information
990  * @primary_if: the primary interface of this batman interface
991  * @hw_src: the Hardware source in the ARP Header
992  * @hw_dst: the Hardware destination in the ARP Header
993  * @ethhdr: pointer to the Ethernet header of the claim frame
994  *
995  * checks if it is a claim packet and if it's on the same group.
996  * This function also applies the group ID of the sender
997  * if it is in the same mesh.
998  *
999  * Return:
1000  *	2  - if it is a claim packet and on the same group
1001  *	1  - if is a claim packet from another group
1002  *	0  - if it is not a claim packet
1003  */
1004 static int batadv_check_claim_group(struct batadv_priv *bat_priv,
1005 				    struct batadv_hard_iface *primary_if,
1006 				    u8 *hw_src, u8 *hw_dst,
1007 				    struct ethhdr *ethhdr)
1008 {
1009 	u8 *backbone_addr;
1010 	struct batadv_orig_node *orig_node;
1011 	struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
1012 
1013 	bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1014 	bla_dst_own = &bat_priv->bla.claim_dest;
1015 
1016 	/* if announcement packet, use the source,
1017 	 * otherwise assume it is in the hw_src
1018 	 */
1019 	switch (bla_dst->type) {
1020 	case BATADV_CLAIM_TYPE_CLAIM:
1021 		backbone_addr = hw_src;
1022 		break;
1023 	case BATADV_CLAIM_TYPE_REQUEST:
1024 	case BATADV_CLAIM_TYPE_ANNOUNCE:
1025 	case BATADV_CLAIM_TYPE_UNCLAIM:
1026 		backbone_addr = ethhdr->h_source;
1027 		break;
1028 	default:
1029 		return 0;
1030 	}
1031 
1032 	/* don't accept claim frames from ourselves */
1033 	if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
1034 		return 0;
1035 
1036 	/* if its already the same group, it is fine. */
1037 	if (bla_dst->group == bla_dst_own->group)
1038 		return 2;
1039 
1040 	/* lets see if this originator is in our mesh */
1041 	orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
1042 
1043 	/* don't accept claims from gateways which are not in
1044 	 * the same mesh or group.
1045 	 */
1046 	if (!orig_node)
1047 		return 1;
1048 
1049 	/* if our mesh friends mac is bigger, use it for ourselves. */
1050 	if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
1051 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
1052 			   "taking other backbones claim group: %#.4x\n",
1053 			   ntohs(bla_dst->group));
1054 		bla_dst_own->group = bla_dst->group;
1055 	}
1056 
1057 	batadv_orig_node_put(orig_node);
1058 
1059 	return 2;
1060 }
1061 
1062 /**
1063  * batadv_bla_process_claim() - Check if this is a claim frame, and process it
1064  * @bat_priv: the bat priv with all the soft interface information
1065  * @primary_if: the primary hard interface of this batman soft interface
1066  * @skb: the frame to be checked
1067  *
1068  * Return: true if it was a claim frame, otherwise return false to
1069  * tell the callee that it can use the frame on its own.
1070  */
1071 static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,
1072 				     struct batadv_hard_iface *primary_if,
1073 				     struct sk_buff *skb)
1074 {
1075 	struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
1076 	u8 *hw_src, *hw_dst;
1077 	struct vlan_hdr *vhdr, vhdr_buf;
1078 	struct ethhdr *ethhdr;
1079 	struct arphdr *arphdr;
1080 	unsigned short vid;
1081 	int vlan_depth = 0;
1082 	__be16 proto;
1083 	int headlen;
1084 	int ret;
1085 
1086 	vid = batadv_get_vid(skb, 0);
1087 	ethhdr = eth_hdr(skb);
1088 
1089 	proto = ethhdr->h_proto;
1090 	headlen = ETH_HLEN;
1091 	if (vid & BATADV_VLAN_HAS_TAG) {
1092 		/* Traverse the VLAN/Ethertypes.
1093 		 *
1094 		 * At this point it is known that the first protocol is a VLAN
1095 		 * header, so start checking at the encapsulated protocol.
1096 		 *
1097 		 * The depth of the VLAN headers is recorded to drop BLA claim
1098 		 * frames encapsulated into multiple VLAN headers (QinQ).
1099 		 */
1100 		do {
1101 			vhdr = skb_header_pointer(skb, headlen, VLAN_HLEN,
1102 						  &vhdr_buf);
1103 			if (!vhdr)
1104 				return false;
1105 
1106 			proto = vhdr->h_vlan_encapsulated_proto;
1107 			headlen += VLAN_HLEN;
1108 			vlan_depth++;
1109 		} while (proto == htons(ETH_P_8021Q));
1110 	}
1111 
1112 	if (proto != htons(ETH_P_ARP))
1113 		return false; /* not a claim frame */
1114 
1115 	/* this must be a ARP frame. check if it is a claim. */
1116 
1117 	if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
1118 		return false;
1119 
1120 	/* pskb_may_pull() may have modified the pointers, get ethhdr again */
1121 	ethhdr = eth_hdr(skb);
1122 	arphdr = (struct arphdr *)((u8 *)ethhdr + headlen);
1123 
1124 	/* Check whether the ARP frame carries a valid
1125 	 * IP information
1126 	 */
1127 	if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
1128 		return false;
1129 	if (arphdr->ar_pro != htons(ETH_P_IP))
1130 		return false;
1131 	if (arphdr->ar_hln != ETH_ALEN)
1132 		return false;
1133 	if (arphdr->ar_pln != 4)
1134 		return false;
1135 
1136 	hw_src = (u8 *)arphdr + sizeof(struct arphdr);
1137 	hw_dst = hw_src + ETH_ALEN + 4;
1138 	bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1139 	bla_dst_own = &bat_priv->bla.claim_dest;
1140 
1141 	/* check if it is a claim frame in general */
1142 	if (memcmp(bla_dst->magic, bla_dst_own->magic,
1143 		   sizeof(bla_dst->magic)) != 0)
1144 		return false;
1145 
1146 	/* check if there is a claim frame encapsulated deeper in (QinQ) and
1147 	 * drop that, as this is not supported by BLA but should also not be
1148 	 * sent via the mesh.
1149 	 */
1150 	if (vlan_depth > 1)
1151 		return true;
1152 
1153 	/* Let the loopdetect frames on the mesh in any case. */
1154 	if (bla_dst->type == BATADV_CLAIM_TYPE_LOOPDETECT)
1155 		return false;
1156 
1157 	/* check if it is a claim frame. */
1158 	ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
1159 				       ethhdr);
1160 	if (ret == 1)
1161 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
1162 			   "%s(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
1163 			   __func__, ethhdr->h_source, batadv_print_vid(vid),
1164 			   hw_src, hw_dst);
1165 
1166 	if (ret < 2)
1167 		return !!ret;
1168 
1169 	/* become a backbone gw ourselves on this vlan if not happened yet */
1170 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1171 
1172 	/* check for the different types of claim frames ... */
1173 	switch (bla_dst->type) {
1174 	case BATADV_CLAIM_TYPE_CLAIM:
1175 		if (batadv_handle_claim(bat_priv, primary_if, hw_src,
1176 					ethhdr->h_source, vid))
1177 			return true;
1178 		break;
1179 	case BATADV_CLAIM_TYPE_UNCLAIM:
1180 		if (batadv_handle_unclaim(bat_priv, primary_if,
1181 					  ethhdr->h_source, hw_src, vid))
1182 			return true;
1183 		break;
1184 
1185 	case BATADV_CLAIM_TYPE_ANNOUNCE:
1186 		if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
1187 					   vid))
1188 			return true;
1189 		break;
1190 	case BATADV_CLAIM_TYPE_REQUEST:
1191 		if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
1192 					  vid))
1193 			return true;
1194 		break;
1195 	}
1196 
1197 	batadv_dbg(BATADV_DBG_BLA, bat_priv,
1198 		   "%s(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
1199 		   __func__, ethhdr->h_source, batadv_print_vid(vid), hw_src,
1200 		   hw_dst);
1201 	return true;
1202 }
1203 
1204 /**
1205  * batadv_bla_purge_backbone_gw() - Remove backbone gateways after a timeout or
1206  *  immediately
1207  * @bat_priv: the bat priv with all the soft interface information
1208  * @now: whether the whole hash shall be wiped now
1209  *
1210  * Check when we last heard from other nodes, and remove them in case of
1211  * a time out, or clean all backbone gws if now is set.
1212  */
1213 static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
1214 {
1215 	struct batadv_bla_backbone_gw *backbone_gw;
1216 	struct hlist_node *node_tmp;
1217 	struct hlist_head *head;
1218 	struct batadv_hashtable *hash;
1219 	spinlock_t *list_lock;	/* protects write access to the hash lists */
1220 	int i;
1221 
1222 	hash = bat_priv->bla.backbone_hash;
1223 	if (!hash)
1224 		return;
1225 
1226 	for (i = 0; i < hash->size; i++) {
1227 		head = &hash->table[i];
1228 		list_lock = &hash->list_locks[i];
1229 
1230 		spin_lock_bh(list_lock);
1231 		hlist_for_each_entry_safe(backbone_gw, node_tmp,
1232 					  head, hash_entry) {
1233 			if (now)
1234 				goto purge_now;
1235 			if (!batadv_has_timed_out(backbone_gw->lasttime,
1236 						  BATADV_BLA_BACKBONE_TIMEOUT))
1237 				continue;
1238 
1239 			batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
1240 				   "%s(): backbone gw %pM timed out\n",
1241 				   __func__, backbone_gw->orig);
1242 
1243 purge_now:
1244 			/* don't wait for the pending request anymore */
1245 			if (atomic_read(&backbone_gw->request_sent))
1246 				atomic_dec(&bat_priv->bla.num_requests);
1247 
1248 			batadv_bla_del_backbone_claims(backbone_gw);
1249 
1250 			hlist_del_rcu(&backbone_gw->hash_entry);
1251 			batadv_backbone_gw_put(backbone_gw);
1252 		}
1253 		spin_unlock_bh(list_lock);
1254 	}
1255 }
1256 
1257 /**
1258  * batadv_bla_purge_claims() - Remove claims after a timeout or immediately
1259  * @bat_priv: the bat priv with all the soft interface information
1260  * @primary_if: the selected primary interface, may be NULL if now is set
1261  * @now: whether the whole hash shall be wiped now
1262  *
1263  * Check when we heard last time from our own claims, and remove them in case of
1264  * a time out, or clean all claims if now is set
1265  */
1266 static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
1267 				    struct batadv_hard_iface *primary_if,
1268 				    int now)
1269 {
1270 	struct batadv_bla_backbone_gw *backbone_gw;
1271 	struct batadv_bla_claim *claim;
1272 	struct hlist_head *head;
1273 	struct batadv_hashtable *hash;
1274 	int i;
1275 
1276 	hash = bat_priv->bla.claim_hash;
1277 	if (!hash)
1278 		return;
1279 
1280 	for (i = 0; i < hash->size; i++) {
1281 		head = &hash->table[i];
1282 
1283 		rcu_read_lock();
1284 		hlist_for_each_entry_rcu(claim, head, hash_entry) {
1285 			backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1286 			if (now)
1287 				goto purge_now;
1288 
1289 			if (!batadv_compare_eth(backbone_gw->orig,
1290 						primary_if->net_dev->dev_addr))
1291 				goto skip;
1292 
1293 			if (!batadv_has_timed_out(claim->lasttime,
1294 						  BATADV_BLA_CLAIM_TIMEOUT))
1295 				goto skip;
1296 
1297 			batadv_dbg(BATADV_DBG_BLA, bat_priv,
1298 				   "%s(): timed out.\n", __func__);
1299 
1300 purge_now:
1301 			batadv_dbg(BATADV_DBG_BLA, bat_priv,
1302 				   "%s(): %pM, vid %d\n", __func__,
1303 				   claim->addr, claim->vid);
1304 
1305 			batadv_handle_unclaim(bat_priv, primary_if,
1306 					      backbone_gw->orig,
1307 					      claim->addr, claim->vid);
1308 skip:
1309 			batadv_backbone_gw_put(backbone_gw);
1310 		}
1311 		rcu_read_unlock();
1312 	}
1313 }
1314 
1315 /**
1316  * batadv_bla_update_orig_address() - Update the backbone gateways when the own
1317  *  originator address changes
1318  * @bat_priv: the bat priv with all the soft interface information
1319  * @primary_if: the new selected primary_if
1320  * @oldif: the old primary interface, may be NULL
1321  */
1322 void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
1323 				    struct batadv_hard_iface *primary_if,
1324 				    struct batadv_hard_iface *oldif)
1325 {
1326 	struct batadv_bla_backbone_gw *backbone_gw;
1327 	struct hlist_head *head;
1328 	struct batadv_hashtable *hash;
1329 	__be16 group;
1330 	int i;
1331 
1332 	/* reset bridge loop avoidance group id */
1333 	group = htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
1334 	bat_priv->bla.claim_dest.group = group;
1335 
1336 	/* purge everything when bridge loop avoidance is turned off */
1337 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1338 		oldif = NULL;
1339 
1340 	if (!oldif) {
1341 		batadv_bla_purge_claims(bat_priv, NULL, 1);
1342 		batadv_bla_purge_backbone_gw(bat_priv, 1);
1343 		return;
1344 	}
1345 
1346 	hash = bat_priv->bla.backbone_hash;
1347 	if (!hash)
1348 		return;
1349 
1350 	for (i = 0; i < hash->size; i++) {
1351 		head = &hash->table[i];
1352 
1353 		rcu_read_lock();
1354 		hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1355 			/* own orig still holds the old value. */
1356 			if (!batadv_compare_eth(backbone_gw->orig,
1357 						oldif->net_dev->dev_addr))
1358 				continue;
1359 
1360 			ether_addr_copy(backbone_gw->orig,
1361 					primary_if->net_dev->dev_addr);
1362 			/* send an announce frame so others will ask for our
1363 			 * claims and update their tables.
1364 			 */
1365 			batadv_bla_send_announce(bat_priv, backbone_gw);
1366 		}
1367 		rcu_read_unlock();
1368 	}
1369 }
1370 
1371 /**
1372  * batadv_bla_send_loopdetect() - send a loopdetect frame
1373  * @bat_priv: the bat priv with all the soft interface information
1374  * @backbone_gw: the backbone gateway for which a loop should be detected
1375  *
1376  * To detect loops that the bridge loop avoidance can't handle, send a loop
1377  * detection packet on the backbone. Unlike other BLA frames, this frame will
1378  * be allowed on the mesh by other nodes. If it is received on the mesh, this
1379  * indicates that there is a loop.
1380  */
1381 static void
1382 batadv_bla_send_loopdetect(struct batadv_priv *bat_priv,
1383 			   struct batadv_bla_backbone_gw *backbone_gw)
1384 {
1385 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "Send loopdetect frame for vid %d\n",
1386 		   backbone_gw->vid);
1387 	batadv_bla_send_claim(bat_priv, bat_priv->bla.loopdetect_addr,
1388 			      backbone_gw->vid, BATADV_CLAIM_TYPE_LOOPDETECT);
1389 }
1390 
1391 /**
1392  * batadv_bla_status_update() - purge bla interfaces if necessary
1393  * @net_dev: the soft interface net device
1394  */
1395 void batadv_bla_status_update(struct net_device *net_dev)
1396 {
1397 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
1398 	struct batadv_hard_iface *primary_if;
1399 
1400 	primary_if = batadv_primary_if_get_selected(bat_priv);
1401 	if (!primary_if)
1402 		return;
1403 
1404 	/* this function already purges everything when bla is disabled,
1405 	 * so just call that one.
1406 	 */
1407 	batadv_bla_update_orig_address(bat_priv, primary_if, primary_if);
1408 	batadv_hardif_put(primary_if);
1409 }
1410 
1411 /**
1412  * batadv_bla_periodic_work() - performs periodic bla work
1413  * @work: kernel work struct
1414  *
1415  * periodic work to do:
1416  *  * purge structures when they are too old
1417  *  * send announcements
1418  */
1419 static void batadv_bla_periodic_work(struct work_struct *work)
1420 {
1421 	struct delayed_work *delayed_work;
1422 	struct batadv_priv *bat_priv;
1423 	struct batadv_priv_bla *priv_bla;
1424 	struct hlist_head *head;
1425 	struct batadv_bla_backbone_gw *backbone_gw;
1426 	struct batadv_hashtable *hash;
1427 	struct batadv_hard_iface *primary_if;
1428 	bool send_loopdetect = false;
1429 	int i;
1430 
1431 	delayed_work = to_delayed_work(work);
1432 	priv_bla = container_of(delayed_work, struct batadv_priv_bla, work);
1433 	bat_priv = container_of(priv_bla, struct batadv_priv, bla);
1434 	primary_if = batadv_primary_if_get_selected(bat_priv);
1435 	if (!primary_if)
1436 		goto out;
1437 
1438 	batadv_bla_purge_claims(bat_priv, primary_if, 0);
1439 	batadv_bla_purge_backbone_gw(bat_priv, 0);
1440 
1441 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1442 		goto out;
1443 
1444 	if (atomic_dec_and_test(&bat_priv->bla.loopdetect_next)) {
1445 		/* set a new random mac address for the next bridge loop
1446 		 * detection frames. Set the locally administered bit to avoid
1447 		 * collisions with users mac addresses.
1448 		 */
1449 		eth_random_addr(bat_priv->bla.loopdetect_addr);
1450 		bat_priv->bla.loopdetect_addr[0] = 0xba;
1451 		bat_priv->bla.loopdetect_addr[1] = 0xbe;
1452 		bat_priv->bla.loopdetect_lasttime = jiffies;
1453 		atomic_set(&bat_priv->bla.loopdetect_next,
1454 			   BATADV_BLA_LOOPDETECT_PERIODS);
1455 
1456 		/* mark for sending loop detect on all VLANs */
1457 		send_loopdetect = true;
1458 	}
1459 
1460 	hash = bat_priv->bla.backbone_hash;
1461 	if (!hash)
1462 		goto out;
1463 
1464 	for (i = 0; i < hash->size; i++) {
1465 		head = &hash->table[i];
1466 
1467 		rcu_read_lock();
1468 		hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1469 			if (!batadv_compare_eth(backbone_gw->orig,
1470 						primary_if->net_dev->dev_addr))
1471 				continue;
1472 
1473 			backbone_gw->lasttime = jiffies;
1474 
1475 			batadv_bla_send_announce(bat_priv, backbone_gw);
1476 			if (send_loopdetect)
1477 				batadv_bla_send_loopdetect(bat_priv,
1478 							   backbone_gw);
1479 
1480 			/* request_sent is only set after creation to avoid
1481 			 * problems when we are not yet known as backbone gw
1482 			 * in the backbone.
1483 			 *
1484 			 * We can reset this now after we waited some periods
1485 			 * to give bridge forward delays and bla group forming
1486 			 * some grace time.
1487 			 */
1488 
1489 			if (atomic_read(&backbone_gw->request_sent) == 0)
1490 				continue;
1491 
1492 			if (!atomic_dec_and_test(&backbone_gw->wait_periods))
1493 				continue;
1494 
1495 			atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
1496 			atomic_set(&backbone_gw->request_sent, 0);
1497 		}
1498 		rcu_read_unlock();
1499 	}
1500 out:
1501 	if (primary_if)
1502 		batadv_hardif_put(primary_if);
1503 
1504 	queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1505 			   msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1506 }
1507 
1508 /* The hash for claim and backbone hash receive the same key because they
1509  * are getting initialized by hash_new with the same key. Reinitializing
1510  * them with to different keys to allow nested locking without generating
1511  * lockdep warnings
1512  */
1513 static struct lock_class_key batadv_claim_hash_lock_class_key;
1514 static struct lock_class_key batadv_backbone_hash_lock_class_key;
1515 
1516 /**
1517  * batadv_bla_init() - initialize all bla structures
1518  * @bat_priv: the bat priv with all the soft interface information
1519  *
1520  * Return: 0 on success, < 0 on error.
1521  */
1522 int batadv_bla_init(struct batadv_priv *bat_priv)
1523 {
1524 	int i;
1525 	u8 claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
1526 	struct batadv_hard_iface *primary_if;
1527 	u16 crc;
1528 	unsigned long entrytime;
1529 
1530 	spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
1531 
1532 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
1533 
1534 	/* setting claim destination address */
1535 	memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
1536 	bat_priv->bla.claim_dest.type = 0;
1537 	primary_if = batadv_primary_if_get_selected(bat_priv);
1538 	if (primary_if) {
1539 		crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
1540 		bat_priv->bla.claim_dest.group = htons(crc);
1541 		batadv_hardif_put(primary_if);
1542 	} else {
1543 		bat_priv->bla.claim_dest.group = 0; /* will be set later */
1544 	}
1545 
1546 	/* initialize the duplicate list */
1547 	entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
1548 	for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
1549 		bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
1550 	bat_priv->bla.bcast_duplist_curr = 0;
1551 
1552 	atomic_set(&bat_priv->bla.loopdetect_next,
1553 		   BATADV_BLA_LOOPDETECT_PERIODS);
1554 
1555 	if (bat_priv->bla.claim_hash)
1556 		return 0;
1557 
1558 	bat_priv->bla.claim_hash = batadv_hash_new(128);
1559 	bat_priv->bla.backbone_hash = batadv_hash_new(32);
1560 
1561 	if (!bat_priv->bla.claim_hash || !bat_priv->bla.backbone_hash)
1562 		return -ENOMEM;
1563 
1564 	batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
1565 				   &batadv_claim_hash_lock_class_key);
1566 	batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
1567 				   &batadv_backbone_hash_lock_class_key);
1568 
1569 	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
1570 
1571 	INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
1572 
1573 	queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1574 			   msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1575 	return 0;
1576 }
1577 
1578 /**
1579  * batadv_bla_check_duplist() - Check if a frame is in the broadcast dup.
1580  * @bat_priv: the bat priv with all the soft interface information
1581  * @skb: contains the multicast packet to be checked
1582  * @payload_ptr: pointer to position inside the head buffer of the skb
1583  *  marking the start of the data to be CRC'ed
1584  * @orig: originator mac address, NULL if unknown
1585  *
1586  * Check if it is on our broadcast list. Another gateway might have sent the
1587  * same packet because it is connected to the same backbone, so we have to
1588  * remove this duplicate.
1589  *
1590  * This is performed by checking the CRC, which will tell us
1591  * with a good chance that it is the same packet. If it is furthermore
1592  * sent by another host, drop it. We allow equal packets from
1593  * the same host however as this might be intended.
1594  *
1595  * Return: true if a packet is in the duplicate list, false otherwise.
1596  */
1597 static bool batadv_bla_check_duplist(struct batadv_priv *bat_priv,
1598 				     struct sk_buff *skb, u8 *payload_ptr,
1599 				     const u8 *orig)
1600 {
1601 	struct batadv_bcast_duplist_entry *entry;
1602 	bool ret = false;
1603 	int i, curr;
1604 	__be32 crc;
1605 
1606 	/* calculate the crc ... */
1607 	crc = batadv_skb_crc32(skb, payload_ptr);
1608 
1609 	spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1610 
1611 	for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1612 		curr = (bat_priv->bla.bcast_duplist_curr + i);
1613 		curr %= BATADV_DUPLIST_SIZE;
1614 		entry = &bat_priv->bla.bcast_duplist[curr];
1615 
1616 		/* we can stop searching if the entry is too old ;
1617 		 * later entries will be even older
1618 		 */
1619 		if (batadv_has_timed_out(entry->entrytime,
1620 					 BATADV_DUPLIST_TIMEOUT))
1621 			break;
1622 
1623 		if (entry->crc != crc)
1624 			continue;
1625 
1626 		/* are the originators both known and not anonymous? */
1627 		if (orig && !is_zero_ether_addr(orig) &&
1628 		    !is_zero_ether_addr(entry->orig)) {
1629 			/* If known, check if the new frame came from
1630 			 * the same originator:
1631 			 * We are safe to take identical frames from the
1632 			 * same orig, if known, as multiplications in
1633 			 * the mesh are detected via the (orig, seqno) pair.
1634 			 * So we can be a bit more liberal here and allow
1635 			 * identical frames from the same orig which the source
1636 			 * host might have sent multiple times on purpose.
1637 			 */
1638 			if (batadv_compare_eth(entry->orig, orig))
1639 				continue;
1640 		}
1641 
1642 		/* this entry seems to match: same crc, not too old,
1643 		 * and from another gw. therefore return true to forbid it.
1644 		 */
1645 		ret = true;
1646 		goto out;
1647 	}
1648 	/* not found, add a new entry (overwrite the oldest entry)
1649 	 * and allow it, its the first occurrence.
1650 	 */
1651 	curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
1652 	curr %= BATADV_DUPLIST_SIZE;
1653 	entry = &bat_priv->bla.bcast_duplist[curr];
1654 	entry->crc = crc;
1655 	entry->entrytime = jiffies;
1656 
1657 	/* known originator */
1658 	if (orig)
1659 		ether_addr_copy(entry->orig, orig);
1660 	/* anonymous originator */
1661 	else
1662 		eth_zero_addr(entry->orig);
1663 
1664 	bat_priv->bla.bcast_duplist_curr = curr;
1665 
1666 out:
1667 	spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1668 
1669 	return ret;
1670 }
1671 
1672 /**
1673  * batadv_bla_check_ucast_duplist() - Check if a frame is in the broadcast dup.
1674  * @bat_priv: the bat priv with all the soft interface information
1675  * @skb: contains the multicast packet to be checked, decapsulated from a
1676  *  unicast_packet
1677  *
1678  * Check if it is on our broadcast list. Another gateway might have sent the
1679  * same packet because it is connected to the same backbone, so we have to
1680  * remove this duplicate.
1681  *
1682  * Return: true if a packet is in the duplicate list, false otherwise.
1683  */
1684 static bool batadv_bla_check_ucast_duplist(struct batadv_priv *bat_priv,
1685 					   struct sk_buff *skb)
1686 {
1687 	return batadv_bla_check_duplist(bat_priv, skb, (u8 *)skb->data, NULL);
1688 }
1689 
1690 /**
1691  * batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.
1692  * @bat_priv: the bat priv with all the soft interface information
1693  * @skb: contains the bcast_packet to be checked
1694  *
1695  * Check if it is on our broadcast list. Another gateway might have sent the
1696  * same packet because it is connected to the same backbone, so we have to
1697  * remove this duplicate.
1698  *
1699  * Return: true if a packet is in the duplicate list, false otherwise.
1700  */
1701 bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
1702 				    struct sk_buff *skb)
1703 {
1704 	struct batadv_bcast_packet *bcast_packet;
1705 	u8 *payload_ptr;
1706 
1707 	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1708 	payload_ptr = (u8 *)(bcast_packet + 1);
1709 
1710 	return batadv_bla_check_duplist(bat_priv, skb, payload_ptr,
1711 					bcast_packet->orig);
1712 }
1713 
1714 /**
1715  * batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
1716  *  the VLAN identified by vid.
1717  * @bat_priv: the bat priv with all the soft interface information
1718  * @orig: originator mac address
1719  * @vid: VLAN identifier
1720  *
1721  * Return: true if orig is a backbone for this vid, false otherwise.
1722  */
1723 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1724 				    unsigned short vid)
1725 {
1726 	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1727 	struct hlist_head *head;
1728 	struct batadv_bla_backbone_gw *backbone_gw;
1729 	int i;
1730 
1731 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1732 		return false;
1733 
1734 	if (!hash)
1735 		return false;
1736 
1737 	for (i = 0; i < hash->size; i++) {
1738 		head = &hash->table[i];
1739 
1740 		rcu_read_lock();
1741 		hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1742 			if (batadv_compare_eth(backbone_gw->orig, orig) &&
1743 			    backbone_gw->vid == vid) {
1744 				rcu_read_unlock();
1745 				return true;
1746 			}
1747 		}
1748 		rcu_read_unlock();
1749 	}
1750 
1751 	return false;
1752 }
1753 
1754 /**
1755  * batadv_bla_is_backbone_gw() - check if originator is a backbone gw for a VLAN
1756  * @skb: the frame to be checked
1757  * @orig_node: the orig_node of the frame
1758  * @hdr_size: maximum length of the frame
1759  *
1760  * Return: true if the orig_node is also a gateway on the soft interface,
1761  * otherwise it returns false.
1762  */
1763 bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
1764 			       struct batadv_orig_node *orig_node, int hdr_size)
1765 {
1766 	struct batadv_bla_backbone_gw *backbone_gw;
1767 	unsigned short vid;
1768 
1769 	if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1770 		return false;
1771 
1772 	/* first, find out the vid. */
1773 	if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
1774 		return false;
1775 
1776 	vid = batadv_get_vid(skb, hdr_size);
1777 
1778 	/* see if this originator is a backbone gw for this VLAN */
1779 	backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1780 						orig_node->orig, vid);
1781 	if (!backbone_gw)
1782 		return false;
1783 
1784 	batadv_backbone_gw_put(backbone_gw);
1785 	return true;
1786 }
1787 
1788 /**
1789  * batadv_bla_free() - free all bla structures
1790  * @bat_priv: the bat priv with all the soft interface information
1791  *
1792  * for softinterface free or module unload
1793  */
1794 void batadv_bla_free(struct batadv_priv *bat_priv)
1795 {
1796 	struct batadv_hard_iface *primary_if;
1797 
1798 	cancel_delayed_work_sync(&bat_priv->bla.work);
1799 	primary_if = batadv_primary_if_get_selected(bat_priv);
1800 
1801 	if (bat_priv->bla.claim_hash) {
1802 		batadv_bla_purge_claims(bat_priv, primary_if, 1);
1803 		batadv_hash_destroy(bat_priv->bla.claim_hash);
1804 		bat_priv->bla.claim_hash = NULL;
1805 	}
1806 	if (bat_priv->bla.backbone_hash) {
1807 		batadv_bla_purge_backbone_gw(bat_priv, 1);
1808 		batadv_hash_destroy(bat_priv->bla.backbone_hash);
1809 		bat_priv->bla.backbone_hash = NULL;
1810 	}
1811 	if (primary_if)
1812 		batadv_hardif_put(primary_if);
1813 }
1814 
1815 /**
1816  * batadv_bla_loopdetect_check() - check and handle a detected loop
1817  * @bat_priv: the bat priv with all the soft interface information
1818  * @skb: the packet to check
1819  * @primary_if: interface where the request came on
1820  * @vid: the VLAN ID of the frame
1821  *
1822  * Checks if this packet is a loop detect frame which has been sent by us,
1823  * throws an uevent and logs the event if that is the case.
1824  *
1825  * Return: true if it is a loop detect frame which is to be dropped, false
1826  * otherwise.
1827  */
1828 static bool
1829 batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
1830 			    struct batadv_hard_iface *primary_if,
1831 			    unsigned short vid)
1832 {
1833 	struct batadv_bla_backbone_gw *backbone_gw;
1834 	struct ethhdr *ethhdr;
1835 	bool ret;
1836 
1837 	ethhdr = eth_hdr(skb);
1838 
1839 	/* Only check for the MAC address and skip more checks here for
1840 	 * performance reasons - this function is on the hotpath, after all.
1841 	 */
1842 	if (!batadv_compare_eth(ethhdr->h_source,
1843 				bat_priv->bla.loopdetect_addr))
1844 		return false;
1845 
1846 	/* If the packet came too late, don't forward it on the mesh
1847 	 * but don't consider that as loop. It might be a coincidence.
1848 	 */
1849 	if (batadv_has_timed_out(bat_priv->bla.loopdetect_lasttime,
1850 				 BATADV_BLA_LOOPDETECT_TIMEOUT))
1851 		return true;
1852 
1853 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
1854 						 primary_if->net_dev->dev_addr,
1855 						 vid, true);
1856 	if (unlikely(!backbone_gw))
1857 		return true;
1858 
1859 	ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work);
1860 
1861 	/* backbone_gw is unreferenced in the report work function
1862 	 * if queue_work() call was successful
1863 	 */
1864 	if (!ret)
1865 		batadv_backbone_gw_put(backbone_gw);
1866 
1867 	return true;
1868 }
1869 
1870 /**
1871  * batadv_bla_rx() - check packets coming from the mesh.
1872  * @bat_priv: the bat priv with all the soft interface information
1873  * @skb: the frame to be checked
1874  * @vid: the VLAN ID of the frame
1875  * @packet_type: the batman packet type this frame came in
1876  *
1877  * batadv_bla_rx avoidance checks if:
1878  *  * we have to race for a claim
1879  *  * if the frame is allowed on the LAN
1880  *
1881  * In these cases, the skb is further handled by this function
1882  *
1883  * Return: true if handled, otherwise it returns false and the caller shall
1884  * further process the skb.
1885  */
1886 bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1887 		   unsigned short vid, int packet_type)
1888 {
1889 	struct batadv_bla_backbone_gw *backbone_gw;
1890 	struct ethhdr *ethhdr;
1891 	struct batadv_bla_claim search_claim, *claim = NULL;
1892 	struct batadv_hard_iface *primary_if;
1893 	bool own_claim;
1894 	bool ret;
1895 
1896 	ethhdr = eth_hdr(skb);
1897 
1898 	primary_if = batadv_primary_if_get_selected(bat_priv);
1899 	if (!primary_if)
1900 		goto handled;
1901 
1902 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1903 		goto allow;
1904 
1905 	if (batadv_bla_loopdetect_check(bat_priv, skb, primary_if, vid))
1906 		goto handled;
1907 
1908 	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1909 		/* don't allow multicast packets while requests are in flight */
1910 		if (is_multicast_ether_addr(ethhdr->h_dest))
1911 			/* Both broadcast flooding or multicast-via-unicasts
1912 			 * delivery might send to multiple backbone gateways
1913 			 * sharing the same LAN and therefore need to coordinate
1914 			 * which backbone gateway forwards into the LAN,
1915 			 * by claiming the payload source address.
1916 			 *
1917 			 * Broadcast flooding and multicast-via-unicasts
1918 			 * delivery use the following two batman packet types.
1919 			 * Note: explicitly exclude BATADV_UNICAST_4ADDR,
1920 			 * as the DHCP gateway feature will send explicitly
1921 			 * to only one BLA gateway, so the claiming process
1922 			 * should be avoided there.
1923 			 */
1924 			if (packet_type == BATADV_BCAST ||
1925 			    packet_type == BATADV_UNICAST)
1926 				goto handled;
1927 
1928 	/* potential duplicates from foreign BLA backbone gateways via
1929 	 * multicast-in-unicast packets
1930 	 */
1931 	if (is_multicast_ether_addr(ethhdr->h_dest) &&
1932 	    packet_type == BATADV_UNICAST &&
1933 	    batadv_bla_check_ucast_duplist(bat_priv, skb))
1934 		goto handled;
1935 
1936 	ether_addr_copy(search_claim.addr, ethhdr->h_source);
1937 	search_claim.vid = vid;
1938 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
1939 
1940 	if (!claim) {
1941 		/* possible optimization: race for a claim */
1942 		/* No claim exists yet, claim it for us!
1943 		 */
1944 
1945 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
1946 			   "%s(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
1947 			   __func__, ethhdr->h_source,
1948 			   batadv_is_my_client(bat_priv,
1949 					       ethhdr->h_source, vid) ?
1950 			   "yes" : "no");
1951 		batadv_handle_claim(bat_priv, primary_if,
1952 				    primary_if->net_dev->dev_addr,
1953 				    ethhdr->h_source, vid);
1954 		goto allow;
1955 	}
1956 
1957 	/* if it is our own claim ... */
1958 	backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1959 	own_claim = batadv_compare_eth(backbone_gw->orig,
1960 				       primary_if->net_dev->dev_addr);
1961 	batadv_backbone_gw_put(backbone_gw);
1962 
1963 	if (own_claim) {
1964 		/* ... allow it in any case */
1965 		claim->lasttime = jiffies;
1966 		goto allow;
1967 	}
1968 
1969 	/* if it is a multicast ... */
1970 	if (is_multicast_ether_addr(ethhdr->h_dest) &&
1971 	    (packet_type == BATADV_BCAST || packet_type == BATADV_UNICAST)) {
1972 		/* ... drop it. the responsible gateway is in charge.
1973 		 *
1974 		 * We need to check packet type because with the gateway
1975 		 * feature, broadcasts (like DHCP requests) may be sent
1976 		 * using a unicast 4 address packet type. See comment above.
1977 		 */
1978 		goto handled;
1979 	} else {
1980 		/* seems the client considers us as its best gateway.
1981 		 * send a claim and update the claim table
1982 		 * immediately.
1983 		 */
1984 		batadv_handle_claim(bat_priv, primary_if,
1985 				    primary_if->net_dev->dev_addr,
1986 				    ethhdr->h_source, vid);
1987 		goto allow;
1988 	}
1989 allow:
1990 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1991 	ret = false;
1992 	goto out;
1993 
1994 handled:
1995 	kfree_skb(skb);
1996 	ret = true;
1997 
1998 out:
1999 	if (primary_if)
2000 		batadv_hardif_put(primary_if);
2001 	if (claim)
2002 		batadv_claim_put(claim);
2003 	return ret;
2004 }
2005 
2006 /**
2007  * batadv_bla_tx() - check packets going into the mesh
2008  * @bat_priv: the bat priv with all the soft interface information
2009  * @skb: the frame to be checked
2010  * @vid: the VLAN ID of the frame
2011  *
2012  * batadv_bla_tx checks if:
2013  *  * a claim was received which has to be processed
2014  *  * the frame is allowed on the mesh
2015  *
2016  * in these cases, the skb is further handled by this function.
2017  *
2018  * This call might reallocate skb data.
2019  *
2020  * Return: true if handled, otherwise it returns false and the caller shall
2021  * further process the skb.
2022  */
2023 bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
2024 		   unsigned short vid)
2025 {
2026 	struct ethhdr *ethhdr;
2027 	struct batadv_bla_claim search_claim, *claim = NULL;
2028 	struct batadv_bla_backbone_gw *backbone_gw;
2029 	struct batadv_hard_iface *primary_if;
2030 	bool client_roamed;
2031 	bool ret = false;
2032 
2033 	primary_if = batadv_primary_if_get_selected(bat_priv);
2034 	if (!primary_if)
2035 		goto out;
2036 
2037 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2038 		goto allow;
2039 
2040 	if (batadv_bla_process_claim(bat_priv, primary_if, skb))
2041 		goto handled;
2042 
2043 	ethhdr = eth_hdr(skb);
2044 
2045 	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
2046 		/* don't allow broadcasts while requests are in flight */
2047 		if (is_multicast_ether_addr(ethhdr->h_dest))
2048 			goto handled;
2049 
2050 	ether_addr_copy(search_claim.addr, ethhdr->h_source);
2051 	search_claim.vid = vid;
2052 
2053 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
2054 
2055 	/* if no claim exists, allow it. */
2056 	if (!claim)
2057 		goto allow;
2058 
2059 	/* check if we are responsible. */
2060 	backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
2061 	client_roamed = batadv_compare_eth(backbone_gw->orig,
2062 					   primary_if->net_dev->dev_addr);
2063 	batadv_backbone_gw_put(backbone_gw);
2064 
2065 	if (client_roamed) {
2066 		/* if yes, the client has roamed and we have
2067 		 * to unclaim it.
2068 		 */
2069 		if (batadv_has_timed_out(claim->lasttime, 100)) {
2070 			/* only unclaim if the last claim entry is
2071 			 * older than 100 ms to make sure we really
2072 			 * have a roaming client here.
2073 			 */
2074 			batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Roaming client %pM detected. Unclaim it.\n",
2075 				   __func__, ethhdr->h_source);
2076 			batadv_handle_unclaim(bat_priv, primary_if,
2077 					      primary_if->net_dev->dev_addr,
2078 					      ethhdr->h_source, vid);
2079 			goto allow;
2080 		} else {
2081 			batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Race for claim %pM detected. Drop packet.\n",
2082 				   __func__, ethhdr->h_source);
2083 			goto handled;
2084 		}
2085 	}
2086 
2087 	/* check if it is a multicast/broadcast frame */
2088 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
2089 		/* drop it. the responsible gateway has forwarded it into
2090 		 * the backbone network.
2091 		 */
2092 		goto handled;
2093 	} else {
2094 		/* we must allow it. at least if we are
2095 		 * responsible for the DESTINATION.
2096 		 */
2097 		goto allow;
2098 	}
2099 allow:
2100 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
2101 	ret = false;
2102 	goto out;
2103 handled:
2104 	ret = true;
2105 out:
2106 	if (primary_if)
2107 		batadv_hardif_put(primary_if);
2108 	if (claim)
2109 		batadv_claim_put(claim);
2110 	return ret;
2111 }
2112 
2113 /**
2114  * batadv_bla_claim_dump_entry() - dump one entry of the claim table
2115  * to a netlink socket
2116  * @msg: buffer for the message
2117  * @portid: netlink port
2118  * @cb: Control block containing additional options
2119  * @primary_if: primary interface
2120  * @claim: entry to dump
2121  *
2122  * Return: 0 or error code.
2123  */
2124 static int
2125 batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid,
2126 			    struct netlink_callback *cb,
2127 			    struct batadv_hard_iface *primary_if,
2128 			    struct batadv_bla_claim *claim)
2129 {
2130 	u8 *primary_addr = primary_if->net_dev->dev_addr;
2131 	u16 backbone_crc;
2132 	bool is_own;
2133 	void *hdr;
2134 	int ret = -EINVAL;
2135 
2136 	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2137 			  &batadv_netlink_family, NLM_F_MULTI,
2138 			  BATADV_CMD_GET_BLA_CLAIM);
2139 	if (!hdr) {
2140 		ret = -ENOBUFS;
2141 		goto out;
2142 	}
2143 
2144 	genl_dump_check_consistent(cb, hdr);
2145 
2146 	is_own = batadv_compare_eth(claim->backbone_gw->orig,
2147 				    primary_addr);
2148 
2149 	spin_lock_bh(&claim->backbone_gw->crc_lock);
2150 	backbone_crc = claim->backbone_gw->crc;
2151 	spin_unlock_bh(&claim->backbone_gw->crc_lock);
2152 
2153 	if (is_own)
2154 		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2155 			genlmsg_cancel(msg, hdr);
2156 			goto out;
2157 		}
2158 
2159 	if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
2160 	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
2161 	    nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2162 		    claim->backbone_gw->orig) ||
2163 	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2164 			backbone_crc)) {
2165 		genlmsg_cancel(msg, hdr);
2166 		goto out;
2167 	}
2168 
2169 	genlmsg_end(msg, hdr);
2170 	ret = 0;
2171 
2172 out:
2173 	return ret;
2174 }
2175 
2176 /**
2177  * batadv_bla_claim_dump_bucket() - dump one bucket of the claim table
2178  * to a netlink socket
2179  * @msg: buffer for the message
2180  * @portid: netlink port
2181  * @cb: Control block containing additional options
2182  * @primary_if: primary interface
2183  * @hash: hash to dump
2184  * @bucket: bucket index to dump
2185  * @idx_skip: How many entries to skip
2186  *
2187  * Return: always 0.
2188  */
2189 static int
2190 batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid,
2191 			     struct netlink_callback *cb,
2192 			     struct batadv_hard_iface *primary_if,
2193 			     struct batadv_hashtable *hash, unsigned int bucket,
2194 			     int *idx_skip)
2195 {
2196 	struct batadv_bla_claim *claim;
2197 	int idx = 0;
2198 	int ret = 0;
2199 
2200 	spin_lock_bh(&hash->list_locks[bucket]);
2201 	cb->seq = atomic_read(&hash->generation) << 1 | 1;
2202 
2203 	hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {
2204 		if (idx++ < *idx_skip)
2205 			continue;
2206 
2207 		ret = batadv_bla_claim_dump_entry(msg, portid, cb,
2208 						  primary_if, claim);
2209 		if (ret) {
2210 			*idx_skip = idx - 1;
2211 			goto unlock;
2212 		}
2213 	}
2214 
2215 	*idx_skip = 0;
2216 unlock:
2217 	spin_unlock_bh(&hash->list_locks[bucket]);
2218 	return ret;
2219 }
2220 
2221 /**
2222  * batadv_bla_claim_dump() - dump claim table to a netlink socket
2223  * @msg: buffer for the message
2224  * @cb: callback structure containing arguments
2225  *
2226  * Return: message length.
2227  */
2228 int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
2229 {
2230 	struct batadv_hard_iface *primary_if = NULL;
2231 	int portid = NETLINK_CB(cb->skb).portid;
2232 	struct net *net = sock_net(cb->skb->sk);
2233 	struct net_device *soft_iface;
2234 	struct batadv_hashtable *hash;
2235 	struct batadv_priv *bat_priv;
2236 	int bucket = cb->args[0];
2237 	int idx = cb->args[1];
2238 	int ifindex;
2239 	int ret = 0;
2240 
2241 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
2242 					     BATADV_ATTR_MESH_IFINDEX);
2243 	if (!ifindex)
2244 		return -EINVAL;
2245 
2246 	soft_iface = dev_get_by_index(net, ifindex);
2247 	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2248 		ret = -ENODEV;
2249 		goto out;
2250 	}
2251 
2252 	bat_priv = netdev_priv(soft_iface);
2253 	hash = bat_priv->bla.claim_hash;
2254 
2255 	primary_if = batadv_primary_if_get_selected(bat_priv);
2256 	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2257 		ret = -ENOENT;
2258 		goto out;
2259 	}
2260 
2261 	while (bucket < hash->size) {
2262 		if (batadv_bla_claim_dump_bucket(msg, portid, cb, primary_if,
2263 						 hash, bucket, &idx))
2264 			break;
2265 		bucket++;
2266 	}
2267 
2268 	cb->args[0] = bucket;
2269 	cb->args[1] = idx;
2270 
2271 	ret = msg->len;
2272 
2273 out:
2274 	if (primary_if)
2275 		batadv_hardif_put(primary_if);
2276 
2277 	if (soft_iface)
2278 		dev_put(soft_iface);
2279 
2280 	return ret;
2281 }
2282 
2283 /**
2284  * batadv_bla_backbone_dump_entry() - dump one entry of the backbone table to a
2285  *  netlink socket
2286  * @msg: buffer for the message
2287  * @portid: netlink port
2288  * @cb: Control block containing additional options
2289  * @primary_if: primary interface
2290  * @backbone_gw: entry to dump
2291  *
2292  * Return: 0 or error code.
2293  */
2294 static int
2295 batadv_bla_backbone_dump_entry(struct sk_buff *msg, u32 portid,
2296 			       struct netlink_callback *cb,
2297 			       struct batadv_hard_iface *primary_if,
2298 			       struct batadv_bla_backbone_gw *backbone_gw)
2299 {
2300 	u8 *primary_addr = primary_if->net_dev->dev_addr;
2301 	u16 backbone_crc;
2302 	bool is_own;
2303 	int msecs;
2304 	void *hdr;
2305 	int ret = -EINVAL;
2306 
2307 	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2308 			  &batadv_netlink_family, NLM_F_MULTI,
2309 			  BATADV_CMD_GET_BLA_BACKBONE);
2310 	if (!hdr) {
2311 		ret = -ENOBUFS;
2312 		goto out;
2313 	}
2314 
2315 	genl_dump_check_consistent(cb, hdr);
2316 
2317 	is_own = batadv_compare_eth(backbone_gw->orig, primary_addr);
2318 
2319 	spin_lock_bh(&backbone_gw->crc_lock);
2320 	backbone_crc = backbone_gw->crc;
2321 	spin_unlock_bh(&backbone_gw->crc_lock);
2322 
2323 	msecs = jiffies_to_msecs(jiffies - backbone_gw->lasttime);
2324 
2325 	if (is_own)
2326 		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2327 			genlmsg_cancel(msg, hdr);
2328 			goto out;
2329 		}
2330 
2331 	if (nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2332 		    backbone_gw->orig) ||
2333 	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, backbone_gw->vid) ||
2334 	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2335 			backbone_crc) ||
2336 	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
2337 		genlmsg_cancel(msg, hdr);
2338 		goto out;
2339 	}
2340 
2341 	genlmsg_end(msg, hdr);
2342 	ret = 0;
2343 
2344 out:
2345 	return ret;
2346 }
2347 
2348 /**
2349  * batadv_bla_backbone_dump_bucket() - dump one bucket of the backbone table to
2350  *  a netlink socket
2351  * @msg: buffer for the message
2352  * @portid: netlink port
2353  * @cb: Control block containing additional options
2354  * @primary_if: primary interface
2355  * @hash: hash to dump
2356  * @bucket: bucket index to dump
2357  * @idx_skip: How many entries to skip
2358  *
2359  * Return: always 0.
2360  */
2361 static int
2362 batadv_bla_backbone_dump_bucket(struct sk_buff *msg, u32 portid,
2363 				struct netlink_callback *cb,
2364 				struct batadv_hard_iface *primary_if,
2365 				struct batadv_hashtable *hash,
2366 				unsigned int bucket, int *idx_skip)
2367 {
2368 	struct batadv_bla_backbone_gw *backbone_gw;
2369 	int idx = 0;
2370 	int ret = 0;
2371 
2372 	spin_lock_bh(&hash->list_locks[bucket]);
2373 	cb->seq = atomic_read(&hash->generation) << 1 | 1;
2374 
2375 	hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {
2376 		if (idx++ < *idx_skip)
2377 			continue;
2378 
2379 		ret = batadv_bla_backbone_dump_entry(msg, portid, cb,
2380 						     primary_if, backbone_gw);
2381 		if (ret) {
2382 			*idx_skip = idx - 1;
2383 			goto unlock;
2384 		}
2385 	}
2386 
2387 	*idx_skip = 0;
2388 unlock:
2389 	spin_unlock_bh(&hash->list_locks[bucket]);
2390 	return ret;
2391 }
2392 
2393 /**
2394  * batadv_bla_backbone_dump() - dump backbone table to a netlink socket
2395  * @msg: buffer for the message
2396  * @cb: callback structure containing arguments
2397  *
2398  * Return: message length.
2399  */
2400 int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb)
2401 {
2402 	struct batadv_hard_iface *primary_if = NULL;
2403 	int portid = NETLINK_CB(cb->skb).portid;
2404 	struct net *net = sock_net(cb->skb->sk);
2405 	struct net_device *soft_iface;
2406 	struct batadv_hashtable *hash;
2407 	struct batadv_priv *bat_priv;
2408 	int bucket = cb->args[0];
2409 	int idx = cb->args[1];
2410 	int ifindex;
2411 	int ret = 0;
2412 
2413 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
2414 					     BATADV_ATTR_MESH_IFINDEX);
2415 	if (!ifindex)
2416 		return -EINVAL;
2417 
2418 	soft_iface = dev_get_by_index(net, ifindex);
2419 	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2420 		ret = -ENODEV;
2421 		goto out;
2422 	}
2423 
2424 	bat_priv = netdev_priv(soft_iface);
2425 	hash = bat_priv->bla.backbone_hash;
2426 
2427 	primary_if = batadv_primary_if_get_selected(bat_priv);
2428 	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2429 		ret = -ENOENT;
2430 		goto out;
2431 	}
2432 
2433 	while (bucket < hash->size) {
2434 		if (batadv_bla_backbone_dump_bucket(msg, portid, cb, primary_if,
2435 						    hash, bucket, &idx))
2436 			break;
2437 		bucket++;
2438 	}
2439 
2440 	cb->args[0] = bucket;
2441 	cb->args[1] = idx;
2442 
2443 	ret = msg->len;
2444 
2445 out:
2446 	if (primary_if)
2447 		batadv_hardif_put(primary_if);
2448 
2449 	if (soft_iface)
2450 		dev_put(soft_iface);
2451 
2452 	return ret;
2453 }
2454 
2455 #ifdef CONFIG_BATMAN_ADV_DAT
2456 /**
2457  * batadv_bla_check_claim() - check if address is claimed
2458  *
2459  * @bat_priv: the bat priv with all the soft interface information
2460  * @addr: mac address of which the claim status is checked
2461  * @vid: the VLAN ID
2462  *
2463  * addr is checked if this address is claimed by the local device itself.
2464  *
2465  * Return: true if bla is disabled or the mac is claimed by the device,
2466  * false if the device addr is already claimed by another gateway
2467  */
2468 bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
2469 			    u8 *addr, unsigned short vid)
2470 {
2471 	struct batadv_bla_claim search_claim;
2472 	struct batadv_bla_claim *claim = NULL;
2473 	struct batadv_hard_iface *primary_if = NULL;
2474 	bool ret = true;
2475 
2476 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2477 		return ret;
2478 
2479 	primary_if = batadv_primary_if_get_selected(bat_priv);
2480 	if (!primary_if)
2481 		return ret;
2482 
2483 	/* First look if the mac address is claimed */
2484 	ether_addr_copy(search_claim.addr, addr);
2485 	search_claim.vid = vid;
2486 
2487 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
2488 
2489 	/* If there is a claim and we are not owner of the claim,
2490 	 * return false.
2491 	 */
2492 	if (claim) {
2493 		if (!batadv_compare_eth(claim->backbone_gw->orig,
2494 					primary_if->net_dev->dev_addr))
2495 			ret = false;
2496 		batadv_claim_put(claim);
2497 	}
2498 
2499 	batadv_hardif_put(primary_if);
2500 	return ret;
2501 }
2502 #endif
2503