1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2011-2020  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/seq_file.h>
31 #include <linux/skbuff.h>
32 #include <linux/slab.h>
33 #include <linux/spinlock.h>
34 #include <linux/stddef.h>
35 #include <linux/string.h>
36 #include <linux/workqueue.h>
37 #include <net/arp.h>
38 #include <net/genetlink.h>
39 #include <net/netlink.h>
40 #include <net/sock.h>
41 #include <uapi/linux/batadv_packet.h>
42 #include <uapi/linux/batman_adv.h>
43 
44 #include "hard-interface.h"
45 #include "hash.h"
46 #include "log.h"
47 #include "netlink.h"
48 #include "originator.h"
49 #include "soft-interface.h"
50 #include "translation-table.h"
51 
52 static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
53 
54 static void batadv_bla_periodic_work(struct work_struct *work);
55 static void
56 batadv_bla_send_announce(struct batadv_priv *bat_priv,
57 			 struct batadv_bla_backbone_gw *backbone_gw);
58 
59 /**
60  * batadv_choose_claim() - choose the right bucket for a claim.
61  * @data: data to hash
62  * @size: size of the hash table
63  *
64  * Return: the hash index of the claim
65  */
66 static inline u32 batadv_choose_claim(const void *data, u32 size)
67 {
68 	struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
69 	u32 hash = 0;
70 
71 	hash = jhash(&claim->addr, sizeof(claim->addr), hash);
72 	hash = jhash(&claim->vid, sizeof(claim->vid), hash);
73 
74 	return hash % size;
75 }
76 
77 /**
78  * batadv_choose_backbone_gw() - choose the right bucket for a backbone gateway.
79  * @data: data to hash
80  * @size: size of the hash table
81  *
82  * Return: the hash index of the backbone gateway
83  */
84 static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
85 {
86 	const struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
87 	u32 hash = 0;
88 
89 	hash = jhash(&claim->addr, sizeof(claim->addr), hash);
90 	hash = jhash(&claim->vid, sizeof(claim->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 containg 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(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 its 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 	/* dont 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_bcast_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 bcast_packet to be checked
1582  *
1583  * check if it is on our broadcast list. Another gateway might
1584  * have sent the same packet because it is connected to the same backbone,
1585  * so we have to remove this duplicate.
1586  *
1587  * This is performed by checking the CRC, which will tell us
1588  * with a good chance that it is the same packet. If it is furthermore
1589  * sent by another host, drop it. We allow equal packets from
1590  * the same host however as this might be intended.
1591  *
1592  * Return: true if a packet is in the duplicate list, false otherwise.
1593  */
1594 bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
1595 				    struct sk_buff *skb)
1596 {
1597 	int i, curr;
1598 	__be32 crc;
1599 	struct batadv_bcast_packet *bcast_packet;
1600 	struct batadv_bcast_duplist_entry *entry;
1601 	bool ret = false;
1602 
1603 	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1604 
1605 	/* calculate the crc ... */
1606 	crc = batadv_skb_crc32(skb, (u8 *)(bcast_packet + 1));
1607 
1608 	spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1609 
1610 	for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1611 		curr = (bat_priv->bla.bcast_duplist_curr + i);
1612 		curr %= BATADV_DUPLIST_SIZE;
1613 		entry = &bat_priv->bla.bcast_duplist[curr];
1614 
1615 		/* we can stop searching if the entry is too old ;
1616 		 * later entries will be even older
1617 		 */
1618 		if (batadv_has_timed_out(entry->entrytime,
1619 					 BATADV_DUPLIST_TIMEOUT))
1620 			break;
1621 
1622 		if (entry->crc != crc)
1623 			continue;
1624 
1625 		if (batadv_compare_eth(entry->orig, bcast_packet->orig))
1626 			continue;
1627 
1628 		/* this entry seems to match: same crc, not too old,
1629 		 * and from another gw. therefore return true to forbid it.
1630 		 */
1631 		ret = true;
1632 		goto out;
1633 	}
1634 	/* not found, add a new entry (overwrite the oldest entry)
1635 	 * and allow it, its the first occurrence.
1636 	 */
1637 	curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
1638 	curr %= BATADV_DUPLIST_SIZE;
1639 	entry = &bat_priv->bla.bcast_duplist[curr];
1640 	entry->crc = crc;
1641 	entry->entrytime = jiffies;
1642 	ether_addr_copy(entry->orig, bcast_packet->orig);
1643 	bat_priv->bla.bcast_duplist_curr = curr;
1644 
1645 out:
1646 	spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1647 
1648 	return ret;
1649 }
1650 
1651 /**
1652  * batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
1653  *  the VLAN identified by vid.
1654  * @bat_priv: the bat priv with all the soft interface information
1655  * @orig: originator mac address
1656  * @vid: VLAN identifier
1657  *
1658  * Return: true if orig is a backbone for this vid, false otherwise.
1659  */
1660 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1661 				    unsigned short vid)
1662 {
1663 	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1664 	struct hlist_head *head;
1665 	struct batadv_bla_backbone_gw *backbone_gw;
1666 	int i;
1667 
1668 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1669 		return false;
1670 
1671 	if (!hash)
1672 		return false;
1673 
1674 	for (i = 0; i < hash->size; i++) {
1675 		head = &hash->table[i];
1676 
1677 		rcu_read_lock();
1678 		hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1679 			if (batadv_compare_eth(backbone_gw->orig, orig) &&
1680 			    backbone_gw->vid == vid) {
1681 				rcu_read_unlock();
1682 				return true;
1683 			}
1684 		}
1685 		rcu_read_unlock();
1686 	}
1687 
1688 	return false;
1689 }
1690 
1691 /**
1692  * batadv_bla_is_backbone_gw() - check if originator is a backbone gw for a VLAN
1693  * @skb: the frame to be checked
1694  * @orig_node: the orig_node of the frame
1695  * @hdr_size: maximum length of the frame
1696  *
1697  * Return: true if the orig_node is also a gateway on the soft interface,
1698  * otherwise it returns false.
1699  */
1700 bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
1701 			       struct batadv_orig_node *orig_node, int hdr_size)
1702 {
1703 	struct batadv_bla_backbone_gw *backbone_gw;
1704 	unsigned short vid;
1705 
1706 	if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1707 		return false;
1708 
1709 	/* first, find out the vid. */
1710 	if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
1711 		return false;
1712 
1713 	vid = batadv_get_vid(skb, hdr_size);
1714 
1715 	/* see if this originator is a backbone gw for this VLAN */
1716 	backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1717 						orig_node->orig, vid);
1718 	if (!backbone_gw)
1719 		return false;
1720 
1721 	batadv_backbone_gw_put(backbone_gw);
1722 	return true;
1723 }
1724 
1725 /**
1726  * batadv_bla_free() - free all bla structures
1727  * @bat_priv: the bat priv with all the soft interface information
1728  *
1729  * for softinterface free or module unload
1730  */
1731 void batadv_bla_free(struct batadv_priv *bat_priv)
1732 {
1733 	struct batadv_hard_iface *primary_if;
1734 
1735 	cancel_delayed_work_sync(&bat_priv->bla.work);
1736 	primary_if = batadv_primary_if_get_selected(bat_priv);
1737 
1738 	if (bat_priv->bla.claim_hash) {
1739 		batadv_bla_purge_claims(bat_priv, primary_if, 1);
1740 		batadv_hash_destroy(bat_priv->bla.claim_hash);
1741 		bat_priv->bla.claim_hash = NULL;
1742 	}
1743 	if (bat_priv->bla.backbone_hash) {
1744 		batadv_bla_purge_backbone_gw(bat_priv, 1);
1745 		batadv_hash_destroy(bat_priv->bla.backbone_hash);
1746 		bat_priv->bla.backbone_hash = NULL;
1747 	}
1748 	if (primary_if)
1749 		batadv_hardif_put(primary_if);
1750 }
1751 
1752 /**
1753  * batadv_bla_loopdetect_check() - check and handle a detected loop
1754  * @bat_priv: the bat priv with all the soft interface information
1755  * @skb: the packet to check
1756  * @primary_if: interface where the request came on
1757  * @vid: the VLAN ID of the frame
1758  *
1759  * Checks if this packet is a loop detect frame which has been sent by us,
1760  * throw an uevent and log the event if that is the case.
1761  *
1762  * Return: true if it is a loop detect frame which is to be dropped, false
1763  * otherwise.
1764  */
1765 static bool
1766 batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
1767 			    struct batadv_hard_iface *primary_if,
1768 			    unsigned short vid)
1769 {
1770 	struct batadv_bla_backbone_gw *backbone_gw;
1771 	struct ethhdr *ethhdr;
1772 	bool ret;
1773 
1774 	ethhdr = eth_hdr(skb);
1775 
1776 	/* Only check for the MAC address and skip more checks here for
1777 	 * performance reasons - this function is on the hotpath, after all.
1778 	 */
1779 	if (!batadv_compare_eth(ethhdr->h_source,
1780 				bat_priv->bla.loopdetect_addr))
1781 		return false;
1782 
1783 	/* If the packet came too late, don't forward it on the mesh
1784 	 * but don't consider that as loop. It might be a coincidence.
1785 	 */
1786 	if (batadv_has_timed_out(bat_priv->bla.loopdetect_lasttime,
1787 				 BATADV_BLA_LOOPDETECT_TIMEOUT))
1788 		return true;
1789 
1790 	backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
1791 						 primary_if->net_dev->dev_addr,
1792 						 vid, true);
1793 	if (unlikely(!backbone_gw))
1794 		return true;
1795 
1796 	ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work);
1797 
1798 	/* backbone_gw is unreferenced in the report work function function
1799 	 * if queue_work() call was successful
1800 	 */
1801 	if (!ret)
1802 		batadv_backbone_gw_put(backbone_gw);
1803 
1804 	return true;
1805 }
1806 
1807 /**
1808  * batadv_bla_rx() - check packets coming from the mesh.
1809  * @bat_priv: the bat priv with all the soft interface information
1810  * @skb: the frame to be checked
1811  * @vid: the VLAN ID of the frame
1812  * @is_bcast: the packet came in a broadcast packet type.
1813  *
1814  * batadv_bla_rx avoidance checks if:
1815  *  * we have to race for a claim
1816  *  * if the frame is allowed on the LAN
1817  *
1818  * in these cases, the skb is further handled by this function
1819  *
1820  * Return: true if handled, otherwise it returns false and the caller shall
1821  * further process the skb.
1822  */
1823 bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1824 		   unsigned short vid, bool is_bcast)
1825 {
1826 	struct batadv_bla_backbone_gw *backbone_gw;
1827 	struct ethhdr *ethhdr;
1828 	struct batadv_bla_claim search_claim, *claim = NULL;
1829 	struct batadv_hard_iface *primary_if;
1830 	bool own_claim;
1831 	bool ret;
1832 
1833 	ethhdr = eth_hdr(skb);
1834 
1835 	primary_if = batadv_primary_if_get_selected(bat_priv);
1836 	if (!primary_if)
1837 		goto handled;
1838 
1839 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1840 		goto allow;
1841 
1842 	if (batadv_bla_loopdetect_check(bat_priv, skb, primary_if, vid))
1843 		goto handled;
1844 
1845 	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1846 		/* don't allow broadcasts while requests are in flight */
1847 		if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast)
1848 			goto handled;
1849 
1850 	ether_addr_copy(search_claim.addr, ethhdr->h_source);
1851 	search_claim.vid = vid;
1852 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
1853 
1854 	if (!claim) {
1855 		/* possible optimization: race for a claim */
1856 		/* No claim exists yet, claim it for us!
1857 		 */
1858 
1859 		batadv_dbg(BATADV_DBG_BLA, bat_priv,
1860 			   "%s(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
1861 			   __func__, ethhdr->h_source,
1862 			   batadv_is_my_client(bat_priv,
1863 					       ethhdr->h_source, vid) ?
1864 			   "yes" : "no");
1865 		batadv_handle_claim(bat_priv, primary_if,
1866 				    primary_if->net_dev->dev_addr,
1867 				    ethhdr->h_source, vid);
1868 		goto allow;
1869 	}
1870 
1871 	/* if it is our own claim ... */
1872 	backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1873 	own_claim = batadv_compare_eth(backbone_gw->orig,
1874 				       primary_if->net_dev->dev_addr);
1875 	batadv_backbone_gw_put(backbone_gw);
1876 
1877 	if (own_claim) {
1878 		/* ... allow it in any case */
1879 		claim->lasttime = jiffies;
1880 		goto allow;
1881 	}
1882 
1883 	/* if it is a broadcast ... */
1884 	if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast) {
1885 		/* ... drop it. the responsible gateway is in charge.
1886 		 *
1887 		 * We need to check is_bcast because with the gateway
1888 		 * feature, broadcasts (like DHCP requests) may be sent
1889 		 * using a unicast packet type.
1890 		 */
1891 		goto handled;
1892 	} else {
1893 		/* seems the client considers us as its best gateway.
1894 		 * send a claim and update the claim table
1895 		 * immediately.
1896 		 */
1897 		batadv_handle_claim(bat_priv, primary_if,
1898 				    primary_if->net_dev->dev_addr,
1899 				    ethhdr->h_source, vid);
1900 		goto allow;
1901 	}
1902 allow:
1903 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1904 	ret = false;
1905 	goto out;
1906 
1907 handled:
1908 	kfree_skb(skb);
1909 	ret = true;
1910 
1911 out:
1912 	if (primary_if)
1913 		batadv_hardif_put(primary_if);
1914 	if (claim)
1915 		batadv_claim_put(claim);
1916 	return ret;
1917 }
1918 
1919 /**
1920  * batadv_bla_tx() - check packets going into the mesh
1921  * @bat_priv: the bat priv with all the soft interface information
1922  * @skb: the frame to be checked
1923  * @vid: the VLAN ID of the frame
1924  *
1925  * batadv_bla_tx checks if:
1926  *  * a claim was received which has to be processed
1927  *  * the frame is allowed on the mesh
1928  *
1929  * in these cases, the skb is further handled by this function.
1930  *
1931  * This call might reallocate skb data.
1932  *
1933  * Return: true if handled, otherwise it returns false and the caller shall
1934  * further process the skb.
1935  */
1936 bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1937 		   unsigned short vid)
1938 {
1939 	struct ethhdr *ethhdr;
1940 	struct batadv_bla_claim search_claim, *claim = NULL;
1941 	struct batadv_bla_backbone_gw *backbone_gw;
1942 	struct batadv_hard_iface *primary_if;
1943 	bool client_roamed;
1944 	bool ret = false;
1945 
1946 	primary_if = batadv_primary_if_get_selected(bat_priv);
1947 	if (!primary_if)
1948 		goto out;
1949 
1950 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1951 		goto allow;
1952 
1953 	if (batadv_bla_process_claim(bat_priv, primary_if, skb))
1954 		goto handled;
1955 
1956 	ethhdr = eth_hdr(skb);
1957 
1958 	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1959 		/* don't allow broadcasts while requests are in flight */
1960 		if (is_multicast_ether_addr(ethhdr->h_dest))
1961 			goto handled;
1962 
1963 	ether_addr_copy(search_claim.addr, ethhdr->h_source);
1964 	search_claim.vid = vid;
1965 
1966 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
1967 
1968 	/* if no claim exists, allow it. */
1969 	if (!claim)
1970 		goto allow;
1971 
1972 	/* check if we are responsible. */
1973 	backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1974 	client_roamed = batadv_compare_eth(backbone_gw->orig,
1975 					   primary_if->net_dev->dev_addr);
1976 	batadv_backbone_gw_put(backbone_gw);
1977 
1978 	if (client_roamed) {
1979 		/* if yes, the client has roamed and we have
1980 		 * to unclaim it.
1981 		 */
1982 		if (batadv_has_timed_out(claim->lasttime, 100)) {
1983 			/* only unclaim if the last claim entry is
1984 			 * older than 100 ms to make sure we really
1985 			 * have a roaming client here.
1986 			 */
1987 			batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Roaming client %pM detected. Unclaim it.\n",
1988 				   __func__, ethhdr->h_source);
1989 			batadv_handle_unclaim(bat_priv, primary_if,
1990 					      primary_if->net_dev->dev_addr,
1991 					      ethhdr->h_source, vid);
1992 			goto allow;
1993 		} else {
1994 			batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Race for claim %pM detected. Drop packet.\n",
1995 				   __func__, ethhdr->h_source);
1996 			goto handled;
1997 		}
1998 	}
1999 
2000 	/* check if it is a multicast/broadcast frame */
2001 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
2002 		/* drop it. the responsible gateway has forwarded it into
2003 		 * the backbone network.
2004 		 */
2005 		goto handled;
2006 	} else {
2007 		/* we must allow it. at least if we are
2008 		 * responsible for the DESTINATION.
2009 		 */
2010 		goto allow;
2011 	}
2012 allow:
2013 	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
2014 	ret = false;
2015 	goto out;
2016 handled:
2017 	ret = true;
2018 out:
2019 	if (primary_if)
2020 		batadv_hardif_put(primary_if);
2021 	if (claim)
2022 		batadv_claim_put(claim);
2023 	return ret;
2024 }
2025 
2026 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2027 /**
2028  * batadv_bla_claim_table_seq_print_text() - print the claim table in a seq file
2029  * @seq: seq file to print on
2030  * @offset: not used
2031  *
2032  * Return: always 0
2033  */
2034 int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
2035 {
2036 	struct net_device *net_dev = (struct net_device *)seq->private;
2037 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
2038 	struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
2039 	struct batadv_bla_backbone_gw *backbone_gw;
2040 	struct batadv_bla_claim *claim;
2041 	struct batadv_hard_iface *primary_if;
2042 	struct hlist_head *head;
2043 	u16 backbone_crc;
2044 	u32 i;
2045 	bool is_own;
2046 	u8 *primary_addr;
2047 
2048 	primary_if = batadv_seq_print_text_primary_if_get(seq);
2049 	if (!primary_if)
2050 		goto out;
2051 
2052 	primary_addr = primary_if->net_dev->dev_addr;
2053 	seq_printf(seq,
2054 		   "Claims announced for the mesh %s (orig %pM, group id %#.4x)\n",
2055 		   net_dev->name, primary_addr,
2056 		   ntohs(bat_priv->bla.claim_dest.group));
2057 	seq_puts(seq,
2058 		 "   Client               VID      Originator        [o] (CRC   )\n");
2059 	for (i = 0; i < hash->size; i++) {
2060 		head = &hash->table[i];
2061 
2062 		rcu_read_lock();
2063 		hlist_for_each_entry_rcu(claim, head, hash_entry) {
2064 			backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
2065 
2066 			is_own = batadv_compare_eth(backbone_gw->orig,
2067 						    primary_addr);
2068 
2069 			spin_lock_bh(&backbone_gw->crc_lock);
2070 			backbone_crc = backbone_gw->crc;
2071 			spin_unlock_bh(&backbone_gw->crc_lock);
2072 			seq_printf(seq, " * %pM on %5d by %pM [%c] (%#.4x)\n",
2073 				   claim->addr, batadv_print_vid(claim->vid),
2074 				   backbone_gw->orig,
2075 				   (is_own ? 'x' : ' '),
2076 				   backbone_crc);
2077 
2078 			batadv_backbone_gw_put(backbone_gw);
2079 		}
2080 		rcu_read_unlock();
2081 	}
2082 out:
2083 	if (primary_if)
2084 		batadv_hardif_put(primary_if);
2085 	return 0;
2086 }
2087 #endif
2088 
2089 /**
2090  * batadv_bla_claim_dump_entry() - dump one entry of the claim table
2091  * to a netlink socket
2092  * @msg: buffer for the message
2093  * @portid: netlink port
2094  * @cb: Control block containing additional options
2095  * @primary_if: primary interface
2096  * @claim: entry to dump
2097  *
2098  * Return: 0 or error code.
2099  */
2100 static int
2101 batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid,
2102 			    struct netlink_callback *cb,
2103 			    struct batadv_hard_iface *primary_if,
2104 			    struct batadv_bla_claim *claim)
2105 {
2106 	u8 *primary_addr = primary_if->net_dev->dev_addr;
2107 	u16 backbone_crc;
2108 	bool is_own;
2109 	void *hdr;
2110 	int ret = -EINVAL;
2111 
2112 	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2113 			  &batadv_netlink_family, NLM_F_MULTI,
2114 			  BATADV_CMD_GET_BLA_CLAIM);
2115 	if (!hdr) {
2116 		ret = -ENOBUFS;
2117 		goto out;
2118 	}
2119 
2120 	genl_dump_check_consistent(cb, hdr);
2121 
2122 	is_own = batadv_compare_eth(claim->backbone_gw->orig,
2123 				    primary_addr);
2124 
2125 	spin_lock_bh(&claim->backbone_gw->crc_lock);
2126 	backbone_crc = claim->backbone_gw->crc;
2127 	spin_unlock_bh(&claim->backbone_gw->crc_lock);
2128 
2129 	if (is_own)
2130 		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2131 			genlmsg_cancel(msg, hdr);
2132 			goto out;
2133 		}
2134 
2135 	if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
2136 	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
2137 	    nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2138 		    claim->backbone_gw->orig) ||
2139 	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2140 			backbone_crc)) {
2141 		genlmsg_cancel(msg, hdr);
2142 		goto out;
2143 	}
2144 
2145 	genlmsg_end(msg, hdr);
2146 	ret = 0;
2147 
2148 out:
2149 	return ret;
2150 }
2151 
2152 /**
2153  * batadv_bla_claim_dump_bucket() - dump one bucket of the claim table
2154  * to a netlink socket
2155  * @msg: buffer for the message
2156  * @portid: netlink port
2157  * @cb: Control block containing additional options
2158  * @primary_if: primary interface
2159  * @hash: hash to dump
2160  * @bucket: bucket index to dump
2161  * @idx_skip: How many entries to skip
2162  *
2163  * Return: always 0.
2164  */
2165 static int
2166 batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid,
2167 			     struct netlink_callback *cb,
2168 			     struct batadv_hard_iface *primary_if,
2169 			     struct batadv_hashtable *hash, unsigned int bucket,
2170 			     int *idx_skip)
2171 {
2172 	struct batadv_bla_claim *claim;
2173 	int idx = 0;
2174 	int ret = 0;
2175 
2176 	spin_lock_bh(&hash->list_locks[bucket]);
2177 	cb->seq = atomic_read(&hash->generation) << 1 | 1;
2178 
2179 	hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {
2180 		if (idx++ < *idx_skip)
2181 			continue;
2182 
2183 		ret = batadv_bla_claim_dump_entry(msg, portid, cb,
2184 						  primary_if, claim);
2185 		if (ret) {
2186 			*idx_skip = idx - 1;
2187 			goto unlock;
2188 		}
2189 	}
2190 
2191 	*idx_skip = 0;
2192 unlock:
2193 	spin_unlock_bh(&hash->list_locks[bucket]);
2194 	return ret;
2195 }
2196 
2197 /**
2198  * batadv_bla_claim_dump() - dump claim table to a netlink socket
2199  * @msg: buffer for the message
2200  * @cb: callback structure containing arguments
2201  *
2202  * Return: message length.
2203  */
2204 int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
2205 {
2206 	struct batadv_hard_iface *primary_if = NULL;
2207 	int portid = NETLINK_CB(cb->skb).portid;
2208 	struct net *net = sock_net(cb->skb->sk);
2209 	struct net_device *soft_iface;
2210 	struct batadv_hashtable *hash;
2211 	struct batadv_priv *bat_priv;
2212 	int bucket = cb->args[0];
2213 	int idx = cb->args[1];
2214 	int ifindex;
2215 	int ret = 0;
2216 
2217 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
2218 					     BATADV_ATTR_MESH_IFINDEX);
2219 	if (!ifindex)
2220 		return -EINVAL;
2221 
2222 	soft_iface = dev_get_by_index(net, ifindex);
2223 	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2224 		ret = -ENODEV;
2225 		goto out;
2226 	}
2227 
2228 	bat_priv = netdev_priv(soft_iface);
2229 	hash = bat_priv->bla.claim_hash;
2230 
2231 	primary_if = batadv_primary_if_get_selected(bat_priv);
2232 	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2233 		ret = -ENOENT;
2234 		goto out;
2235 	}
2236 
2237 	while (bucket < hash->size) {
2238 		if (batadv_bla_claim_dump_bucket(msg, portid, cb, primary_if,
2239 						 hash, bucket, &idx))
2240 			break;
2241 		bucket++;
2242 	}
2243 
2244 	cb->args[0] = bucket;
2245 	cb->args[1] = idx;
2246 
2247 	ret = msg->len;
2248 
2249 out:
2250 	if (primary_if)
2251 		batadv_hardif_put(primary_if);
2252 
2253 	if (soft_iface)
2254 		dev_put(soft_iface);
2255 
2256 	return ret;
2257 }
2258 
2259 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2260 /**
2261  * batadv_bla_backbone_table_seq_print_text() - print the backbone table in a
2262  *  seq file
2263  * @seq: seq file to print on
2264  * @offset: not used
2265  *
2266  * Return: always 0
2267  */
2268 int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq, void *offset)
2269 {
2270 	struct net_device *net_dev = (struct net_device *)seq->private;
2271 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
2272 	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
2273 	struct batadv_bla_backbone_gw *backbone_gw;
2274 	struct batadv_hard_iface *primary_if;
2275 	struct hlist_head *head;
2276 	int secs, msecs;
2277 	u16 backbone_crc;
2278 	u32 i;
2279 	bool is_own;
2280 	u8 *primary_addr;
2281 
2282 	primary_if = batadv_seq_print_text_primary_if_get(seq);
2283 	if (!primary_if)
2284 		goto out;
2285 
2286 	primary_addr = primary_if->net_dev->dev_addr;
2287 	seq_printf(seq,
2288 		   "Backbones announced for the mesh %s (orig %pM, group id %#.4x)\n",
2289 		   net_dev->name, primary_addr,
2290 		   ntohs(bat_priv->bla.claim_dest.group));
2291 	seq_puts(seq, "   Originator           VID   last seen (CRC   )\n");
2292 	for (i = 0; i < hash->size; i++) {
2293 		head = &hash->table[i];
2294 
2295 		rcu_read_lock();
2296 		hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
2297 			msecs = jiffies_to_msecs(jiffies -
2298 						 backbone_gw->lasttime);
2299 			secs = msecs / 1000;
2300 			msecs = msecs % 1000;
2301 
2302 			is_own = batadv_compare_eth(backbone_gw->orig,
2303 						    primary_addr);
2304 			if (is_own)
2305 				continue;
2306 
2307 			spin_lock_bh(&backbone_gw->crc_lock);
2308 			backbone_crc = backbone_gw->crc;
2309 			spin_unlock_bh(&backbone_gw->crc_lock);
2310 
2311 			seq_printf(seq, " * %pM on %5d %4i.%03is (%#.4x)\n",
2312 				   backbone_gw->orig,
2313 				   batadv_print_vid(backbone_gw->vid), secs,
2314 				   msecs, backbone_crc);
2315 		}
2316 		rcu_read_unlock();
2317 	}
2318 out:
2319 	if (primary_if)
2320 		batadv_hardif_put(primary_if);
2321 	return 0;
2322 }
2323 #endif
2324 
2325 /**
2326  * batadv_bla_backbone_dump_entry() - dump one entry of the backbone table to a
2327  *  netlink socket
2328  * @msg: buffer for the message
2329  * @portid: netlink port
2330  * @cb: Control block containing additional options
2331  * @primary_if: primary interface
2332  * @backbone_gw: entry to dump
2333  *
2334  * Return: 0 or error code.
2335  */
2336 static int
2337 batadv_bla_backbone_dump_entry(struct sk_buff *msg, u32 portid,
2338 			       struct netlink_callback *cb,
2339 			       struct batadv_hard_iface *primary_if,
2340 			       struct batadv_bla_backbone_gw *backbone_gw)
2341 {
2342 	u8 *primary_addr = primary_if->net_dev->dev_addr;
2343 	u16 backbone_crc;
2344 	bool is_own;
2345 	int msecs;
2346 	void *hdr;
2347 	int ret = -EINVAL;
2348 
2349 	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2350 			  &batadv_netlink_family, NLM_F_MULTI,
2351 			  BATADV_CMD_GET_BLA_BACKBONE);
2352 	if (!hdr) {
2353 		ret = -ENOBUFS;
2354 		goto out;
2355 	}
2356 
2357 	genl_dump_check_consistent(cb, hdr);
2358 
2359 	is_own = batadv_compare_eth(backbone_gw->orig, primary_addr);
2360 
2361 	spin_lock_bh(&backbone_gw->crc_lock);
2362 	backbone_crc = backbone_gw->crc;
2363 	spin_unlock_bh(&backbone_gw->crc_lock);
2364 
2365 	msecs = jiffies_to_msecs(jiffies - backbone_gw->lasttime);
2366 
2367 	if (is_own)
2368 		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2369 			genlmsg_cancel(msg, hdr);
2370 			goto out;
2371 		}
2372 
2373 	if (nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2374 		    backbone_gw->orig) ||
2375 	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, backbone_gw->vid) ||
2376 	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2377 			backbone_crc) ||
2378 	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
2379 		genlmsg_cancel(msg, hdr);
2380 		goto out;
2381 	}
2382 
2383 	genlmsg_end(msg, hdr);
2384 	ret = 0;
2385 
2386 out:
2387 	return ret;
2388 }
2389 
2390 /**
2391  * batadv_bla_backbone_dump_bucket() - dump one bucket of the backbone table to
2392  *  a netlink socket
2393  * @msg: buffer for the message
2394  * @portid: netlink port
2395  * @cb: Control block containing additional options
2396  * @primary_if: primary interface
2397  * @hash: hash to dump
2398  * @bucket: bucket index to dump
2399  * @idx_skip: How many entries to skip
2400  *
2401  * Return: always 0.
2402  */
2403 static int
2404 batadv_bla_backbone_dump_bucket(struct sk_buff *msg, u32 portid,
2405 				struct netlink_callback *cb,
2406 				struct batadv_hard_iface *primary_if,
2407 				struct batadv_hashtable *hash,
2408 				unsigned int bucket, int *idx_skip)
2409 {
2410 	struct batadv_bla_backbone_gw *backbone_gw;
2411 	int idx = 0;
2412 	int ret = 0;
2413 
2414 	spin_lock_bh(&hash->list_locks[bucket]);
2415 	cb->seq = atomic_read(&hash->generation) << 1 | 1;
2416 
2417 	hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {
2418 		if (idx++ < *idx_skip)
2419 			continue;
2420 
2421 		ret = batadv_bla_backbone_dump_entry(msg, portid, cb,
2422 						     primary_if, backbone_gw);
2423 		if (ret) {
2424 			*idx_skip = idx - 1;
2425 			goto unlock;
2426 		}
2427 	}
2428 
2429 	*idx_skip = 0;
2430 unlock:
2431 	spin_unlock_bh(&hash->list_locks[bucket]);
2432 	return ret;
2433 }
2434 
2435 /**
2436  * batadv_bla_backbone_dump() - dump backbone table to a netlink socket
2437  * @msg: buffer for the message
2438  * @cb: callback structure containing arguments
2439  *
2440  * Return: message length.
2441  */
2442 int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb)
2443 {
2444 	struct batadv_hard_iface *primary_if = NULL;
2445 	int portid = NETLINK_CB(cb->skb).portid;
2446 	struct net *net = sock_net(cb->skb->sk);
2447 	struct net_device *soft_iface;
2448 	struct batadv_hashtable *hash;
2449 	struct batadv_priv *bat_priv;
2450 	int bucket = cb->args[0];
2451 	int idx = cb->args[1];
2452 	int ifindex;
2453 	int ret = 0;
2454 
2455 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
2456 					     BATADV_ATTR_MESH_IFINDEX);
2457 	if (!ifindex)
2458 		return -EINVAL;
2459 
2460 	soft_iface = dev_get_by_index(net, ifindex);
2461 	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2462 		ret = -ENODEV;
2463 		goto out;
2464 	}
2465 
2466 	bat_priv = netdev_priv(soft_iface);
2467 	hash = bat_priv->bla.backbone_hash;
2468 
2469 	primary_if = batadv_primary_if_get_selected(bat_priv);
2470 	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2471 		ret = -ENOENT;
2472 		goto out;
2473 	}
2474 
2475 	while (bucket < hash->size) {
2476 		if (batadv_bla_backbone_dump_bucket(msg, portid, cb, primary_if,
2477 						    hash, bucket, &idx))
2478 			break;
2479 		bucket++;
2480 	}
2481 
2482 	cb->args[0] = bucket;
2483 	cb->args[1] = idx;
2484 
2485 	ret = msg->len;
2486 
2487 out:
2488 	if (primary_if)
2489 		batadv_hardif_put(primary_if);
2490 
2491 	if (soft_iface)
2492 		dev_put(soft_iface);
2493 
2494 	return ret;
2495 }
2496 
2497 #ifdef CONFIG_BATMAN_ADV_DAT
2498 /**
2499  * batadv_bla_check_claim() - check if address is claimed
2500  *
2501  * @bat_priv: the bat priv with all the soft interface information
2502  * @addr: mac address of which the claim status is checked
2503  * @vid: the VLAN ID
2504  *
2505  * addr is checked if this address is claimed by the local device itself.
2506  *
2507  * Return: true if bla is disabled or the mac is claimed by the device,
2508  * false if the device addr is already claimed by another gateway
2509  */
2510 bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
2511 			    u8 *addr, unsigned short vid)
2512 {
2513 	struct batadv_bla_claim search_claim;
2514 	struct batadv_bla_claim *claim = NULL;
2515 	struct batadv_hard_iface *primary_if = NULL;
2516 	bool ret = true;
2517 
2518 	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2519 		return ret;
2520 
2521 	primary_if = batadv_primary_if_get_selected(bat_priv);
2522 	if (!primary_if)
2523 		return ret;
2524 
2525 	/* First look if the mac address is claimed */
2526 	ether_addr_copy(search_claim.addr, addr);
2527 	search_claim.vid = vid;
2528 
2529 	claim = batadv_claim_hash_find(bat_priv, &search_claim);
2530 
2531 	/* If there is a claim and we are not owner of the claim,
2532 	 * return false.
2533 	 */
2534 	if (claim) {
2535 		if (!batadv_compare_eth(claim->backbone_gw->orig,
2536 					primary_if->net_dev->dev_addr))
2537 			ret = false;
2538 		batadv_claim_put(claim);
2539 	}
2540 
2541 	batadv_hardif_put(primary_if);
2542 	return ret;
2543 }
2544 #endif
2545