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