1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright (C) B.A.T.M.A.N. contributors:
   3 *
   4 * Simon Wunderlich
   5 */
   6
   7#include "bridge_loop_avoidance.h"
   8#include "main.h"
   9
  10#include <linux/atomic.h>
  11#include <linux/byteorder/generic.h>
  12#include <linux/compiler.h>
 
  13#include <linux/crc16.h>
  14#include <linux/errno.h>
  15#include <linux/etherdevice.h>
  16#include <linux/gfp.h>
  17#include <linux/if_arp.h>
  18#include <linux/if_ether.h>
  19#include <linux/if_vlan.h>
  20#include <linux/jhash.h>
  21#include <linux/jiffies.h>
  22#include <linux/kernel.h>
  23#include <linux/kref.h>
  24#include <linux/list.h>
  25#include <linux/lockdep.h>
  26#include <linux/netdevice.h>
  27#include <linux/netlink.h>
  28#include <linux/rculist.h>
  29#include <linux/rcupdate.h>
  30#include <linux/skbuff.h>
  31#include <linux/slab.h>
  32#include <linux/spinlock.h>
 
  33#include <linux/stddef.h>
  34#include <linux/string.h>
 
  35#include <linux/workqueue.h>
  36#include <net/arp.h>
  37#include <net/genetlink.h>
  38#include <net/netlink.h>
  39#include <net/sock.h>
  40#include <uapi/linux/batadv_packet.h>
  41#include <uapi/linux/batman_adv.h>
  42
  43#include "hard-interface.h"
  44#include "hash.h"
  45#include "log.h"
  46#include "netlink.h"
  47#include "originator.h"
  48#include "soft-interface.h"
  49#include "translation-table.h"
  50
  51static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
  52
  53static void batadv_bla_periodic_work(struct work_struct *work);
  54static void
  55batadv_bla_send_announce(struct batadv_priv *bat_priv,
  56			 struct batadv_bla_backbone_gw *backbone_gw);
  57
  58/**
  59 * batadv_choose_claim() - choose the right bucket for a claim.
  60 * @data: data to hash
  61 * @size: size of the hash table
  62 *
  63 * Return: the hash index of the claim
  64 */
  65static inline u32 batadv_choose_claim(const void *data, u32 size)
  66{
  67	struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
  68	u32 hash = 0;
  69
  70	hash = jhash(&claim->addr, sizeof(claim->addr), hash);
  71	hash = jhash(&claim->vid, sizeof(claim->vid), hash);
  72
  73	return hash % size;
  74}
  75
  76/**
  77 * batadv_choose_backbone_gw() - choose the right bucket for a backbone gateway.
  78 * @data: data to hash
  79 * @size: size of the hash table
  80 *
  81 * Return: the hash index of the backbone gateway
  82 */
  83static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
  84{
  85	const struct batadv_bla_backbone_gw *gw;
  86	u32 hash = 0;
  87
  88	gw = (struct batadv_bla_backbone_gw *)data;
  89	hash = jhash(&gw->orig, sizeof(gw->orig), hash);
  90	hash = jhash(&gw->vid, sizeof(gw->vid), hash);
  91
  92	return hash % size;
  93}
  94
  95/**
  96 * batadv_compare_backbone_gw() - compare address and vid of two backbone gws
  97 * @node: list node of the first entry to compare
  98 * @data2: pointer to the second backbone gateway
  99 *
 100 * Return: true if the backbones have the same data, false otherwise
 101 */
 102static 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 */
 126static 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 */
 148static 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 */
 163static 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 */
 173static 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 */
 198static 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 */
 210static struct batadv_bla_claim *
 211batadv_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 */
 250static struct batadv_bla_backbone_gw *
 251batadv_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 */
 290static void
 291batadv_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 */
 333static void batadv_bla_send_claim(struct batadv_priv *bat_priv, u8 *mac,
 334				  unsigned short vid, int claimtype)
 335{
 336	struct sk_buff *skb;
 337	struct ethhdr *ethhdr;
 338	struct batadv_hard_iface *primary_if;
 339	struct net_device *soft_iface;
 340	u8 *hw_src;
 341	struct batadv_bla_claim_dst local_claim_dest;
 342	__be32 zeroip = 0;
 343
 344	primary_if = batadv_primary_if_get_selected(bat_priv);
 345	if (!primary_if)
 346		return;
 347
 348	memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
 349	       sizeof(local_claim_dest));
 350	local_claim_dest.type = claimtype;
 351
 352	soft_iface = primary_if->soft_iface;
 353
 354	skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
 355			 /* IP DST: 0.0.0.0 */
 356			 zeroip,
 357			 primary_if->soft_iface,
 358			 /* IP SRC: 0.0.0.0 */
 359			 zeroip,
 360			 /* Ethernet DST: Broadcast */
 361			 NULL,
 362			 /* Ethernet SRC/HW SRC:  originator mac */
 363			 primary_if->net_dev->dev_addr,
 364			 /* HW DST: FF:43:05:XX:YY:YY
 365			  * with XX   = claim type
 366			  * and YY:YY = group id
 367			  */
 368			 (u8 *)&local_claim_dest);
 369
 370	if (!skb)
 371		goto out;
 372
 373	ethhdr = (struct ethhdr *)skb->data;
 374	hw_src = (u8 *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
 375
 376	/* now we pretend that the client would have sent this ... */
 377	switch (claimtype) {
 378	case BATADV_CLAIM_TYPE_CLAIM:
 379		/* normal claim frame
 380		 * set Ethernet SRC to the clients mac
 381		 */
 382		ether_addr_copy(ethhdr->h_source, mac);
 383		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 384			   "%s(): CLAIM %pM on vid %d\n", __func__, mac,
 385			   batadv_print_vid(vid));
 386		break;
 387	case BATADV_CLAIM_TYPE_UNCLAIM:
 388		/* unclaim frame
 389		 * set HW SRC to the clients mac
 390		 */
 391		ether_addr_copy(hw_src, mac);
 392		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 393			   "%s(): UNCLAIM %pM on vid %d\n", __func__, mac,
 394			   batadv_print_vid(vid));
 395		break;
 396	case BATADV_CLAIM_TYPE_ANNOUNCE:
 397		/* announcement frame
 398		 * set HW SRC to the special mac containing the crc
 399		 */
 400		ether_addr_copy(hw_src, mac);
 401		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 402			   "%s(): ANNOUNCE of %pM on vid %d\n", __func__,
 403			   ethhdr->h_source, batadv_print_vid(vid));
 404		break;
 405	case BATADV_CLAIM_TYPE_REQUEST:
 406		/* request frame
 407		 * set HW SRC and header destination to the receiving backbone
 408		 * gws mac
 409		 */
 410		ether_addr_copy(hw_src, mac);
 411		ether_addr_copy(ethhdr->h_dest, mac);
 412		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 413			   "%s(): REQUEST of %pM to %pM on vid %d\n", __func__,
 414			   ethhdr->h_source, ethhdr->h_dest,
 415			   batadv_print_vid(vid));
 416		break;
 417	case BATADV_CLAIM_TYPE_LOOPDETECT:
 418		ether_addr_copy(ethhdr->h_source, mac);
 419		batadv_dbg(BATADV_DBG_BLA, bat_priv,
 420			   "%s(): LOOPDETECT of %pM to %pM on vid %d\n",
 421			   __func__, ethhdr->h_source, ethhdr->h_dest,
 422			   batadv_print_vid(vid));
 423
 424		break;
 425	}
 426
 427	if (vid & BATADV_VLAN_HAS_TAG) {
 428		skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
 429				      vid & VLAN_VID_MASK);
 430		if (!skb)
 431			goto out;
 432	}
 433
 434	skb_reset_mac_header(skb);
 435	skb->protocol = eth_type_trans(skb, soft_iface);
 436	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
 437	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
 438			   skb->len + ETH_HLEN);
 439
 440	netif_rx_any_context(skb);
 441out:
 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 */
 453static 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 */
 485static struct batadv_bla_backbone_gw *
 486batadv_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 */
 558static void
 559batadv_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 */
 584static 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 */
 633static 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 */
 657static 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 */
 680static 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
 759claim_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 */
 770static struct batadv_bla_backbone_gw *
 771batadv_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 */
 789static 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
 816free_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 */
 830static 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 */
 889static 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 */
 922static 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 */
 960static bool batadv_handle_claim(struct batadv_priv *bat_priv,
 961				struct batadv_hard_iface *primary_if,
 962				u8 *backbone_addr, u8 *claim_addr,
 963				unsigned short vid)
 964{
 965	struct batadv_bla_backbone_gw *backbone_gw;
 966
 967	/* register the gateway if not yet available, and add the claim. */
 968
 969	backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
 970						 false);
 971
 972	if (unlikely(!backbone_gw))
 973		return true;
 974
 975	/* this must be a CLAIM frame */
 976	batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
 977	if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
 978		batadv_bla_send_claim(bat_priv, claim_addr, vid,
 979				      BATADV_CLAIM_TYPE_CLAIM);
 980
 981	/* TODO: we could call something like tt_local_del() here. */
 982
 983	batadv_backbone_gw_put(backbone_gw);
 984	return true;
 985}
 986
 987/**
 988 * batadv_check_claim_group() - check for claim group membership
 989 * @bat_priv: the bat priv with all the soft interface information
 990 * @primary_if: the primary interface of this batman interface
 991 * @hw_src: the Hardware source in the ARP Header
 992 * @hw_dst: the Hardware destination in the ARP Header
 993 * @ethhdr: pointer to the Ethernet header of the claim frame
 994 *
 995 * checks if it is a claim packet and if it's on the same group.
 996 * This function also applies the group ID of the sender
 997 * if it is in the same mesh.
 998 *
 999 * Return:
1000 *	2  - if it is a claim packet and on the same group
1001 *	1  - if is a claim packet from another group
1002 *	0  - if it is not a claim packet
1003 */
1004static int batadv_check_claim_group(struct batadv_priv *bat_priv,
1005				    struct batadv_hard_iface *primary_if,
1006				    u8 *hw_src, u8 *hw_dst,
1007				    struct ethhdr *ethhdr)
1008{
1009	u8 *backbone_addr;
1010	struct batadv_orig_node *orig_node;
1011	struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
1012
1013	bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1014	bla_dst_own = &bat_priv->bla.claim_dest;
1015
1016	/* if announcement packet, use the source,
1017	 * otherwise assume it is in the hw_src
1018	 */
1019	switch (bla_dst->type) {
1020	case BATADV_CLAIM_TYPE_CLAIM:
1021		backbone_addr = hw_src;
1022		break;
1023	case BATADV_CLAIM_TYPE_REQUEST:
1024	case BATADV_CLAIM_TYPE_ANNOUNCE:
1025	case BATADV_CLAIM_TYPE_UNCLAIM:
1026		backbone_addr = ethhdr->h_source;
1027		break;
1028	default:
1029		return 0;
1030	}
1031
1032	/* don't accept claim frames from ourselves */
1033	if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
1034		return 0;
1035
1036	/* if its already the same group, it is fine. */
1037	if (bla_dst->group == bla_dst_own->group)
1038		return 2;
1039
1040	/* lets see if this originator is in our mesh */
1041	orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
1042
1043	/* don't accept claims from gateways which are not in
1044	 * the same mesh or group.
1045	 */
1046	if (!orig_node)
1047		return 1;
1048
1049	/* if our mesh friends mac is bigger, use it for ourselves. */
1050	if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
1051		batadv_dbg(BATADV_DBG_BLA, bat_priv,
1052			   "taking other backbones claim group: %#.4x\n",
1053			   ntohs(bla_dst->group));
1054		bla_dst_own->group = bla_dst->group;
1055	}
1056
1057	batadv_orig_node_put(orig_node);
1058
1059	return 2;
1060}
1061
1062/**
1063 * batadv_bla_process_claim() - Check if this is a claim frame, and process it
1064 * @bat_priv: the bat priv with all the soft interface information
1065 * @primary_if: the primary hard interface of this batman soft interface
1066 * @skb: the frame to be checked
1067 *
1068 * Return: true if it was a claim frame, otherwise return false to
1069 * tell the callee that it can use the frame on its own.
1070 */
1071static 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 */
1213static 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
1243purge_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 */
1266static 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
1300purge_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);
1308skip:
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 */
1322void 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 */
1381static void
1382batadv_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 */
1395void 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 */
1419static 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	}
1500out:
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 */
1513static struct lock_class_key batadv_claim_hash_lock_class_key;
1514static 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 */
1522int batadv_bla_init(struct batadv_priv *bat_priv)
1523{
1524	int i;
1525	u8 claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
1526	struct batadv_hard_iface *primary_if;
1527	u16 crc;
1528	unsigned long entrytime;
1529
1530	spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
1531
1532	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
1533
1534	/* setting claim destination address */
1535	memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
1536	bat_priv->bla.claim_dest.type = 0;
1537	primary_if = batadv_primary_if_get_selected(bat_priv);
1538	if (primary_if) {
1539		crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
1540		bat_priv->bla.claim_dest.group = htons(crc);
1541		batadv_hardif_put(primary_if);
1542	} else {
1543		bat_priv->bla.claim_dest.group = 0; /* will be set later */
1544	}
1545
1546	/* initialize the duplicate list */
1547	entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
1548	for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
1549		bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
1550	bat_priv->bla.bcast_duplist_curr = 0;
1551
1552	atomic_set(&bat_priv->bla.loopdetect_next,
1553		   BATADV_BLA_LOOPDETECT_PERIODS);
1554
1555	if (bat_priv->bla.claim_hash)
1556		return 0;
1557
1558	bat_priv->bla.claim_hash = batadv_hash_new(128);
1559	bat_priv->bla.backbone_hash = batadv_hash_new(32);
 
1560
1561	if (!bat_priv->bla.claim_hash || !bat_priv->bla.backbone_hash)
 
 
1562		return -ENOMEM;
 
1563
1564	batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
1565				   &batadv_claim_hash_lock_class_key);
1566	batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
1567				   &batadv_backbone_hash_lock_class_key);
1568
1569	batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
1570
1571	INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
1572
1573	queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1574			   msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1575	return 0;
1576}
1577
1578/**
1579 * batadv_bla_check_duplist() - Check if a frame is in the broadcast dup.
1580 * @bat_priv: the bat priv with all the soft interface information
1581 * @skb: contains the multicast packet to be checked
1582 * @payload_ptr: pointer to position inside the head buffer of the skb
1583 *  marking the start of the data to be CRC'ed
1584 * @orig: originator mac address, NULL if unknown
1585 *
1586 * Check if it is on our broadcast list. Another gateway might have sent the
1587 * same packet because it is connected to the same backbone, so we have to
1588 * remove this duplicate.
1589 *
1590 * This is performed by checking the CRC, which will tell us
1591 * with a good chance that it is the same packet. If it is furthermore
1592 * sent by another host, drop it. We allow equal packets from
1593 * the same host however as this might be intended.
1594 *
1595 * Return: true if a packet is in the duplicate list, false otherwise.
1596 */
1597static bool batadv_bla_check_duplist(struct batadv_priv *bat_priv,
1598				     struct sk_buff *skb, u8 *payload_ptr,
1599				     const u8 *orig)
1600{
1601	struct batadv_bcast_duplist_entry *entry;
1602	bool ret = false;
1603	int i, curr;
1604	__be32 crc;
1605
1606	/* calculate the crc ... */
1607	crc = batadv_skb_crc32(skb, payload_ptr);
1608
1609	spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1610
1611	for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1612		curr = (bat_priv->bla.bcast_duplist_curr + i);
1613		curr %= BATADV_DUPLIST_SIZE;
1614		entry = &bat_priv->bla.bcast_duplist[curr];
1615
1616		/* we can stop searching if the entry is too old ;
1617		 * later entries will be even older
1618		 */
1619		if (batadv_has_timed_out(entry->entrytime,
1620					 BATADV_DUPLIST_TIMEOUT))
1621			break;
1622
1623		if (entry->crc != crc)
1624			continue;
1625
1626		/* are the originators both known and not anonymous? */
1627		if (orig && !is_zero_ether_addr(orig) &&
1628		    !is_zero_ether_addr(entry->orig)) {
1629			/* If known, check if the new frame came from
1630			 * the same originator:
1631			 * We are safe to take identical frames from the
1632			 * same orig, if known, as multiplications in
1633			 * the mesh are detected via the (orig, seqno) pair.
1634			 * So we can be a bit more liberal here and allow
1635			 * identical frames from the same orig which the source
1636			 * host might have sent multiple times on purpose.
1637			 */
1638			if (batadv_compare_eth(entry->orig, orig))
1639				continue;
1640		}
1641
1642		/* this entry seems to match: same crc, not too old,
1643		 * and from another gw. therefore return true to forbid it.
1644		 */
1645		ret = true;
1646		goto out;
1647	}
1648	/* not found, add a new entry (overwrite the oldest entry)
1649	 * and allow it, its the first occurrence.
1650	 */
1651	curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
1652	curr %= BATADV_DUPLIST_SIZE;
1653	entry = &bat_priv->bla.bcast_duplist[curr];
1654	entry->crc = crc;
1655	entry->entrytime = jiffies;
1656
1657	/* known originator */
1658	if (orig)
1659		ether_addr_copy(entry->orig, orig);
1660	/* anonymous originator */
1661	else
1662		eth_zero_addr(entry->orig);
1663
1664	bat_priv->bla.bcast_duplist_curr = curr;
1665
1666out:
1667	spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1668
1669	return ret;
1670}
1671
1672/**
1673 * batadv_bla_check_ucast_duplist() - Check if a frame is in the broadcast dup.
1674 * @bat_priv: the bat priv with all the soft interface information
1675 * @skb: contains the multicast packet to be checked, decapsulated from a
1676 *  unicast_packet
1677 *
1678 * Check if it is on our broadcast list. Another gateway might have sent the
1679 * same packet because it is connected to the same backbone, so we have to
1680 * remove this duplicate.
1681 *
1682 * Return: true if a packet is in the duplicate list, false otherwise.
1683 */
1684static bool batadv_bla_check_ucast_duplist(struct batadv_priv *bat_priv,
1685					   struct sk_buff *skb)
1686{
1687	return batadv_bla_check_duplist(bat_priv, skb, (u8 *)skb->data, NULL);
1688}
1689
1690/**
1691 * batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.
1692 * @bat_priv: the bat priv with all the soft interface information
1693 * @skb: contains the bcast_packet to be checked
1694 *
1695 * Check if it is on our broadcast list. Another gateway might have sent the
1696 * same packet because it is connected to the same backbone, so we have to
1697 * remove this duplicate.
1698 *
1699 * Return: true if a packet is in the duplicate list, false otherwise.
1700 */
1701bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
1702				    struct sk_buff *skb)
1703{
1704	struct batadv_bcast_packet *bcast_packet;
1705	u8 *payload_ptr;
1706
1707	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1708	payload_ptr = (u8 *)(bcast_packet + 1);
1709
1710	return batadv_bla_check_duplist(bat_priv, skb, payload_ptr,
1711					bcast_packet->orig);
1712}
1713
1714/**
1715 * batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
1716 *  the VLAN identified by vid.
1717 * @bat_priv: the bat priv with all the soft interface information
1718 * @orig: originator mac address
1719 * @vid: VLAN identifier
1720 *
1721 * Return: true if orig is a backbone for this vid, false otherwise.
1722 */
1723bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1724				    unsigned short vid)
1725{
1726	struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1727	struct hlist_head *head;
1728	struct batadv_bla_backbone_gw *backbone_gw;
1729	int i;
1730
1731	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1732		return false;
1733
1734	if (!hash)
1735		return false;
1736
1737	for (i = 0; i < hash->size; i++) {
1738		head = &hash->table[i];
1739
1740		rcu_read_lock();
1741		hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1742			if (batadv_compare_eth(backbone_gw->orig, orig) &&
1743			    backbone_gw->vid == vid) {
1744				rcu_read_unlock();
1745				return true;
1746			}
1747		}
1748		rcu_read_unlock();
1749	}
1750
1751	return false;
1752}
1753
1754/**
1755 * batadv_bla_is_backbone_gw() - check if originator is a backbone gw for a VLAN
1756 * @skb: the frame to be checked
1757 * @orig_node: the orig_node of the frame
1758 * @hdr_size: maximum length of the frame
1759 *
1760 * Return: true if the orig_node is also a gateway on the soft interface,
1761 * otherwise it returns false.
1762 */
1763bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
1764			       struct batadv_orig_node *orig_node, int hdr_size)
1765{
1766	struct batadv_bla_backbone_gw *backbone_gw;
1767	unsigned short vid;
1768
1769	if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1770		return false;
1771
1772	/* first, find out the vid. */
1773	if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
1774		return false;
1775
1776	vid = batadv_get_vid(skb, hdr_size);
1777
1778	/* see if this originator is a backbone gw for this VLAN */
1779	backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1780						orig_node->orig, vid);
1781	if (!backbone_gw)
1782		return false;
1783
1784	batadv_backbone_gw_put(backbone_gw);
1785	return true;
1786}
1787
1788/**
1789 * batadv_bla_free() - free all bla structures
1790 * @bat_priv: the bat priv with all the soft interface information
1791 *
1792 * for softinterface free or module unload
1793 */
1794void batadv_bla_free(struct batadv_priv *bat_priv)
1795{
1796	struct batadv_hard_iface *primary_if;
1797
1798	cancel_delayed_work_sync(&bat_priv->bla.work);
1799	primary_if = batadv_primary_if_get_selected(bat_priv);
1800
1801	if (bat_priv->bla.claim_hash) {
1802		batadv_bla_purge_claims(bat_priv, primary_if, 1);
1803		batadv_hash_destroy(bat_priv->bla.claim_hash);
1804		bat_priv->bla.claim_hash = NULL;
1805	}
1806	if (bat_priv->bla.backbone_hash) {
1807		batadv_bla_purge_backbone_gw(bat_priv, 1);
1808		batadv_hash_destroy(bat_priv->bla.backbone_hash);
1809		bat_priv->bla.backbone_hash = NULL;
1810	}
1811	if (primary_if)
1812		batadv_hardif_put(primary_if);
1813}
1814
1815/**
1816 * batadv_bla_loopdetect_check() - check and handle a detected loop
1817 * @bat_priv: the bat priv with all the soft interface information
1818 * @skb: the packet to check
1819 * @primary_if: interface where the request came on
1820 * @vid: the VLAN ID of the frame
1821 *
1822 * Checks if this packet is a loop detect frame which has been sent by us,
1823 * throws an uevent and logs the event if that is the case.
1824 *
1825 * Return: true if it is a loop detect frame which is to be dropped, false
1826 * otherwise.
1827 */
1828static bool
1829batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
1830			    struct batadv_hard_iface *primary_if,
1831			    unsigned short vid)
1832{
1833	struct batadv_bla_backbone_gw *backbone_gw;
1834	struct ethhdr *ethhdr;
1835	bool ret;
1836
1837	ethhdr = eth_hdr(skb);
1838
1839	/* Only check for the MAC address and skip more checks here for
1840	 * performance reasons - this function is on the hotpath, after all.
1841	 */
1842	if (!batadv_compare_eth(ethhdr->h_source,
1843				bat_priv->bla.loopdetect_addr))
1844		return false;
1845
1846	/* If the packet came too late, don't forward it on the mesh
1847	 * but don't consider that as loop. It might be a coincidence.
1848	 */
1849	if (batadv_has_timed_out(bat_priv->bla.loopdetect_lasttime,
1850				 BATADV_BLA_LOOPDETECT_TIMEOUT))
1851		return true;
1852
1853	backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
1854						 primary_if->net_dev->dev_addr,
1855						 vid, true);
1856	if (unlikely(!backbone_gw))
1857		return true;
1858
1859	ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work);
1860
1861	/* backbone_gw is unreferenced in the report work function
1862	 * if queue_work() call was successful
1863	 */
1864	if (!ret)
1865		batadv_backbone_gw_put(backbone_gw);
1866
1867	return true;
1868}
1869
1870/**
1871 * batadv_bla_rx() - check packets coming from the mesh.
1872 * @bat_priv: the bat priv with all the soft interface information
1873 * @skb: the frame to be checked
1874 * @vid: the VLAN ID of the frame
1875 * @packet_type: the batman packet type this frame came in
1876 *
1877 * batadv_bla_rx avoidance checks if:
1878 *  * we have to race for a claim
1879 *  * if the frame is allowed on the LAN
1880 *
1881 * In these cases, the skb is further handled by this function
1882 *
1883 * Return: true if handled, otherwise it returns false and the caller shall
1884 * further process the skb.
1885 */
1886bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1887		   unsigned short vid, int packet_type)
1888{
1889	struct batadv_bla_backbone_gw *backbone_gw;
1890	struct ethhdr *ethhdr;
1891	struct batadv_bla_claim search_claim, *claim = NULL;
1892	struct batadv_hard_iface *primary_if;
1893	bool own_claim;
1894	bool ret;
1895
1896	ethhdr = eth_hdr(skb);
1897
1898	primary_if = batadv_primary_if_get_selected(bat_priv);
1899	if (!primary_if)
1900		goto handled;
1901
1902	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1903		goto allow;
1904
1905	if (batadv_bla_loopdetect_check(bat_priv, skb, primary_if, vid))
1906		goto handled;
1907
1908	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1909		/* don't allow multicast packets while requests are in flight */
1910		if (is_multicast_ether_addr(ethhdr->h_dest))
1911			/* Both broadcast flooding or multicast-via-unicasts
1912			 * delivery might send to multiple backbone gateways
1913			 * sharing the same LAN and therefore need to coordinate
1914			 * which backbone gateway forwards into the LAN,
1915			 * by claiming the payload source address.
1916			 *
1917			 * Broadcast flooding and multicast-via-unicasts
1918			 * delivery use the following two batman packet types.
1919			 * Note: explicitly exclude BATADV_UNICAST_4ADDR,
1920			 * as the DHCP gateway feature will send explicitly
1921			 * to only one BLA gateway, so the claiming process
1922			 * should be avoided there.
1923			 */
1924			if (packet_type == BATADV_BCAST ||
1925			    packet_type == BATADV_UNICAST)
1926				goto handled;
1927
1928	/* potential duplicates from foreign BLA backbone gateways via
1929	 * multicast-in-unicast packets
1930	 */
1931	if (is_multicast_ether_addr(ethhdr->h_dest) &&
1932	    packet_type == BATADV_UNICAST &&
1933	    batadv_bla_check_ucast_duplist(bat_priv, skb))
1934		goto handled;
1935
1936	ether_addr_copy(search_claim.addr, ethhdr->h_source);
1937	search_claim.vid = vid;
1938	claim = batadv_claim_hash_find(bat_priv, &search_claim);
1939
1940	if (!claim) {
 
 
1941		/* possible optimization: race for a claim */
1942		/* No claim exists yet, claim it for us!
1943		 */
1944
1945		batadv_dbg(BATADV_DBG_BLA, bat_priv,
1946			   "%s(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
1947			   __func__, ethhdr->h_source,
1948			   batadv_is_my_client(bat_priv,
1949					       ethhdr->h_source, vid) ?
1950			   "yes" : "no");
1951		batadv_handle_claim(bat_priv, primary_if,
1952				    primary_if->net_dev->dev_addr,
1953				    ethhdr->h_source, vid);
1954		goto allow;
1955	}
1956
1957	/* if it is our own claim ... */
1958	backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1959	own_claim = batadv_compare_eth(backbone_gw->orig,
1960				       primary_if->net_dev->dev_addr);
1961	batadv_backbone_gw_put(backbone_gw);
1962
1963	if (own_claim) {
1964		/* ... allow it in any case */
1965		claim->lasttime = jiffies;
1966		goto allow;
1967	}
1968
1969	/* if it is a multicast ... */
1970	if (is_multicast_ether_addr(ethhdr->h_dest) &&
1971	    (packet_type == BATADV_BCAST || packet_type == BATADV_UNICAST)) {
1972		/* ... drop it. the responsible gateway is in charge.
1973		 *
1974		 * We need to check packet type because with the gateway
1975		 * feature, broadcasts (like DHCP requests) may be sent
1976		 * using a unicast 4 address packet type. See comment above.
1977		 */
1978		goto handled;
1979	} else {
1980		/* seems the client considers us as its best gateway.
1981		 * send a claim and update the claim table
1982		 * immediately.
1983		 */
1984		batadv_handle_claim(bat_priv, primary_if,
1985				    primary_if->net_dev->dev_addr,
1986				    ethhdr->h_source, vid);
1987		goto allow;
1988	}
1989allow:
1990	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1991	ret = false;
1992	goto out;
1993
1994handled:
1995	kfree_skb(skb);
1996	ret = true;
1997
1998out:
1999	if (primary_if)
2000		batadv_hardif_put(primary_if);
2001	if (claim)
2002		batadv_claim_put(claim);
2003	return ret;
2004}
2005
2006/**
2007 * batadv_bla_tx() - check packets going into the mesh
2008 * @bat_priv: the bat priv with all the soft interface information
2009 * @skb: the frame to be checked
2010 * @vid: the VLAN ID of the frame
2011 *
2012 * batadv_bla_tx checks if:
2013 *  * a claim was received which has to be processed
2014 *  * the frame is allowed on the mesh
2015 *
2016 * in these cases, the skb is further handled by this function.
2017 *
2018 * This call might reallocate skb data.
2019 *
2020 * Return: true if handled, otherwise it returns false and the caller shall
2021 * further process the skb.
2022 */
2023bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
2024		   unsigned short vid)
2025{
2026	struct ethhdr *ethhdr;
2027	struct batadv_bla_claim search_claim, *claim = NULL;
2028	struct batadv_bla_backbone_gw *backbone_gw;
2029	struct batadv_hard_iface *primary_if;
2030	bool client_roamed;
2031	bool ret = false;
2032
2033	primary_if = batadv_primary_if_get_selected(bat_priv);
2034	if (!primary_if)
2035		goto out;
2036
2037	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2038		goto allow;
2039
2040	if (batadv_bla_process_claim(bat_priv, primary_if, skb))
2041		goto handled;
2042
2043	ethhdr = eth_hdr(skb);
2044
2045	if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
2046		/* don't allow broadcasts while requests are in flight */
2047		if (is_multicast_ether_addr(ethhdr->h_dest))
2048			goto handled;
2049
2050	ether_addr_copy(search_claim.addr, ethhdr->h_source);
2051	search_claim.vid = vid;
2052
2053	claim = batadv_claim_hash_find(bat_priv, &search_claim);
2054
2055	/* if no claim exists, allow it. */
2056	if (!claim)
2057		goto allow;
2058
2059	/* check if we are responsible. */
2060	backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
2061	client_roamed = batadv_compare_eth(backbone_gw->orig,
2062					   primary_if->net_dev->dev_addr);
2063	batadv_backbone_gw_put(backbone_gw);
2064
2065	if (client_roamed) {
2066		/* if yes, the client has roamed and we have
2067		 * to unclaim it.
2068		 */
2069		if (batadv_has_timed_out(claim->lasttime, 100)) {
2070			/* only unclaim if the last claim entry is
2071			 * older than 100 ms to make sure we really
2072			 * have a roaming client here.
2073			 */
2074			batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Roaming client %pM detected. Unclaim it.\n",
2075				   __func__, ethhdr->h_source);
2076			batadv_handle_unclaim(bat_priv, primary_if,
2077					      primary_if->net_dev->dev_addr,
2078					      ethhdr->h_source, vid);
2079			goto allow;
2080		} else {
2081			batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Race for claim %pM detected. Drop packet.\n",
2082				   __func__, ethhdr->h_source);
2083			goto handled;
2084		}
2085	}
2086
2087	/* check if it is a multicast/broadcast frame */
2088	if (is_multicast_ether_addr(ethhdr->h_dest)) {
2089		/* drop it. the responsible gateway has forwarded it into
2090		 * the backbone network.
2091		 */
2092		goto handled;
2093	} else {
2094		/* we must allow it. at least if we are
2095		 * responsible for the DESTINATION.
2096		 */
2097		goto allow;
2098	}
2099allow:
2100	batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
2101	ret = false;
2102	goto out;
2103handled:
2104	ret = true;
2105out:
2106	if (primary_if)
2107		batadv_hardif_put(primary_if);
2108	if (claim)
2109		batadv_claim_put(claim);
2110	return ret;
2111}
2112
2113/**
2114 * batadv_bla_claim_dump_entry() - dump one entry of the claim table
2115 * to a netlink socket
2116 * @msg: buffer for the message
2117 * @portid: netlink port
2118 * @cb: Control block containing additional options
2119 * @primary_if: primary interface
2120 * @claim: entry to dump
2121 *
2122 * Return: 0 or error code.
2123 */
2124static int
2125batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid,
2126			    struct netlink_callback *cb,
2127			    struct batadv_hard_iface *primary_if,
2128			    struct batadv_bla_claim *claim)
2129{
2130	u8 *primary_addr = primary_if->net_dev->dev_addr;
2131	u16 backbone_crc;
2132	bool is_own;
2133	void *hdr;
2134	int ret = -EINVAL;
2135
2136	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2137			  &batadv_netlink_family, NLM_F_MULTI,
2138			  BATADV_CMD_GET_BLA_CLAIM);
2139	if (!hdr) {
2140		ret = -ENOBUFS;
2141		goto out;
2142	}
2143
2144	genl_dump_check_consistent(cb, hdr);
2145
2146	is_own = batadv_compare_eth(claim->backbone_gw->orig,
2147				    primary_addr);
2148
2149	spin_lock_bh(&claim->backbone_gw->crc_lock);
2150	backbone_crc = claim->backbone_gw->crc;
2151	spin_unlock_bh(&claim->backbone_gw->crc_lock);
2152
2153	if (is_own)
2154		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2155			genlmsg_cancel(msg, hdr);
2156			goto out;
2157		}
2158
2159	if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
2160	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
2161	    nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2162		    claim->backbone_gw->orig) ||
2163	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2164			backbone_crc)) {
2165		genlmsg_cancel(msg, hdr);
2166		goto out;
2167	}
2168
2169	genlmsg_end(msg, hdr);
2170	ret = 0;
2171
2172out:
2173	return ret;
2174}
2175
2176/**
2177 * batadv_bla_claim_dump_bucket() - dump one bucket of the claim table
2178 * to a netlink socket
2179 * @msg: buffer for the message
2180 * @portid: netlink port
2181 * @cb: Control block containing additional options
2182 * @primary_if: primary interface
2183 * @hash: hash to dump
2184 * @bucket: bucket index to dump
2185 * @idx_skip: How many entries to skip
2186 *
2187 * Return: always 0.
2188 */
2189static int
2190batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid,
2191			     struct netlink_callback *cb,
2192			     struct batadv_hard_iface *primary_if,
2193			     struct batadv_hashtable *hash, unsigned int bucket,
2194			     int *idx_skip)
2195{
2196	struct batadv_bla_claim *claim;
2197	int idx = 0;
2198	int ret = 0;
2199
2200	spin_lock_bh(&hash->list_locks[bucket]);
2201	cb->seq = atomic_read(&hash->generation) << 1 | 1;
2202
2203	hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {
2204		if (idx++ < *idx_skip)
2205			continue;
2206
2207		ret = batadv_bla_claim_dump_entry(msg, portid, cb,
2208						  primary_if, claim);
2209		if (ret) {
2210			*idx_skip = idx - 1;
2211			goto unlock;
2212		}
2213	}
2214
2215	*idx_skip = 0;
2216unlock:
2217	spin_unlock_bh(&hash->list_locks[bucket]);
2218	return ret;
2219}
2220
2221/**
2222 * batadv_bla_claim_dump() - dump claim table to a netlink socket
2223 * @msg: buffer for the message
2224 * @cb: callback structure containing arguments
2225 *
2226 * Return: message length.
2227 */
2228int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
2229{
2230	struct batadv_hard_iface *primary_if = NULL;
2231	int portid = NETLINK_CB(cb->skb).portid;
2232	struct net *net = sock_net(cb->skb->sk);
2233	struct net_device *soft_iface;
2234	struct batadv_hashtable *hash;
2235	struct batadv_priv *bat_priv;
2236	int bucket = cb->args[0];
2237	int idx = cb->args[1];
2238	int ifindex;
2239	int ret = 0;
2240
2241	ifindex = batadv_netlink_get_ifindex(cb->nlh,
2242					     BATADV_ATTR_MESH_IFINDEX);
2243	if (!ifindex)
2244		return -EINVAL;
2245
2246	soft_iface = dev_get_by_index(net, ifindex);
2247	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2248		ret = -ENODEV;
2249		goto out;
2250	}
2251
2252	bat_priv = netdev_priv(soft_iface);
2253	hash = bat_priv->bla.claim_hash;
2254
2255	primary_if = batadv_primary_if_get_selected(bat_priv);
2256	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2257		ret = -ENOENT;
2258		goto out;
2259	}
2260
2261	while (bucket < hash->size) {
2262		if (batadv_bla_claim_dump_bucket(msg, portid, cb, primary_if,
2263						 hash, bucket, &idx))
2264			break;
2265		bucket++;
2266	}
2267
2268	cb->args[0] = bucket;
2269	cb->args[1] = idx;
2270
2271	ret = msg->len;
2272
2273out:
2274	if (primary_if)
2275		batadv_hardif_put(primary_if);
2276
2277	if (soft_iface)
2278		dev_put(soft_iface);
2279
2280	return ret;
2281}
2282
2283/**
2284 * batadv_bla_backbone_dump_entry() - dump one entry of the backbone table to a
2285 *  netlink socket
2286 * @msg: buffer for the message
2287 * @portid: netlink port
2288 * @cb: Control block containing additional options
2289 * @primary_if: primary interface
2290 * @backbone_gw: entry to dump
2291 *
2292 * Return: 0 or error code.
2293 */
2294static int
2295batadv_bla_backbone_dump_entry(struct sk_buff *msg, u32 portid,
2296			       struct netlink_callback *cb,
2297			       struct batadv_hard_iface *primary_if,
2298			       struct batadv_bla_backbone_gw *backbone_gw)
2299{
2300	u8 *primary_addr = primary_if->net_dev->dev_addr;
2301	u16 backbone_crc;
2302	bool is_own;
2303	int msecs;
2304	void *hdr;
2305	int ret = -EINVAL;
2306
2307	hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2308			  &batadv_netlink_family, NLM_F_MULTI,
2309			  BATADV_CMD_GET_BLA_BACKBONE);
2310	if (!hdr) {
2311		ret = -ENOBUFS;
2312		goto out;
2313	}
2314
2315	genl_dump_check_consistent(cb, hdr);
2316
2317	is_own = batadv_compare_eth(backbone_gw->orig, primary_addr);
2318
2319	spin_lock_bh(&backbone_gw->crc_lock);
2320	backbone_crc = backbone_gw->crc;
2321	spin_unlock_bh(&backbone_gw->crc_lock);
2322
2323	msecs = jiffies_to_msecs(jiffies - backbone_gw->lasttime);
2324
2325	if (is_own)
2326		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2327			genlmsg_cancel(msg, hdr);
2328			goto out;
2329		}
2330
2331	if (nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2332		    backbone_gw->orig) ||
2333	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, backbone_gw->vid) ||
2334	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2335			backbone_crc) ||
2336	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
2337		genlmsg_cancel(msg, hdr);
2338		goto out;
2339	}
2340
2341	genlmsg_end(msg, hdr);
2342	ret = 0;
2343
2344out:
2345	return ret;
2346}
2347
2348/**
2349 * batadv_bla_backbone_dump_bucket() - dump one bucket of the backbone table to
2350 *  a netlink socket
2351 * @msg: buffer for the message
2352 * @portid: netlink port
2353 * @cb: Control block containing additional options
2354 * @primary_if: primary interface
2355 * @hash: hash to dump
2356 * @bucket: bucket index to dump
2357 * @idx_skip: How many entries to skip
2358 *
2359 * Return: always 0.
2360 */
2361static int
2362batadv_bla_backbone_dump_bucket(struct sk_buff *msg, u32 portid,
2363				struct netlink_callback *cb,
2364				struct batadv_hard_iface *primary_if,
2365				struct batadv_hashtable *hash,
2366				unsigned int bucket, int *idx_skip)
2367{
2368	struct batadv_bla_backbone_gw *backbone_gw;
2369	int idx = 0;
2370	int ret = 0;
2371
2372	spin_lock_bh(&hash->list_locks[bucket]);
2373	cb->seq = atomic_read(&hash->generation) << 1 | 1;
2374
2375	hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {
2376		if (idx++ < *idx_skip)
2377			continue;
2378
2379		ret = batadv_bla_backbone_dump_entry(msg, portid, cb,
2380						     primary_if, backbone_gw);
2381		if (ret) {
2382			*idx_skip = idx - 1;
2383			goto unlock;
2384		}
2385	}
2386
2387	*idx_skip = 0;
2388unlock:
2389	spin_unlock_bh(&hash->list_locks[bucket]);
2390	return ret;
2391}
2392
2393/**
2394 * batadv_bla_backbone_dump() - dump backbone table to a netlink socket
2395 * @msg: buffer for the message
2396 * @cb: callback structure containing arguments
2397 *
2398 * Return: message length.
2399 */
2400int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb)
2401{
2402	struct batadv_hard_iface *primary_if = NULL;
2403	int portid = NETLINK_CB(cb->skb).portid;
2404	struct net *net = sock_net(cb->skb->sk);
2405	struct net_device *soft_iface;
2406	struct batadv_hashtable *hash;
2407	struct batadv_priv *bat_priv;
2408	int bucket = cb->args[0];
2409	int idx = cb->args[1];
2410	int ifindex;
2411	int ret = 0;
2412
2413	ifindex = batadv_netlink_get_ifindex(cb->nlh,
2414					     BATADV_ATTR_MESH_IFINDEX);
2415	if (!ifindex)
2416		return -EINVAL;
2417
2418	soft_iface = dev_get_by_index(net, ifindex);
2419	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2420		ret = -ENODEV;
2421		goto out;
2422	}
2423
2424	bat_priv = netdev_priv(soft_iface);
2425	hash = bat_priv->bla.backbone_hash;
2426
2427	primary_if = batadv_primary_if_get_selected(bat_priv);
2428	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2429		ret = -ENOENT;
2430		goto out;
2431	}
2432
2433	while (bucket < hash->size) {
2434		if (batadv_bla_backbone_dump_bucket(msg, portid, cb, primary_if,
2435						    hash, bucket, &idx))
2436			break;
2437		bucket++;
2438	}
2439
2440	cb->args[0] = bucket;
2441	cb->args[1] = idx;
2442
2443	ret = msg->len;
2444
2445out:
2446	if (primary_if)
2447		batadv_hardif_put(primary_if);
2448
2449	if (soft_iface)
2450		dev_put(soft_iface);
2451
2452	return ret;
2453}
2454
2455#ifdef CONFIG_BATMAN_ADV_DAT
2456/**
2457 * batadv_bla_check_claim() - check if address is claimed
2458 *
2459 * @bat_priv: the bat priv with all the soft interface information
2460 * @addr: mac address of which the claim status is checked
2461 * @vid: the VLAN ID
2462 *
2463 * addr is checked if this address is claimed by the local device itself.
2464 *
2465 * Return: true if bla is disabled or the mac is claimed by the device,
2466 * false if the device addr is already claimed by another gateway
2467 */
2468bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
2469			    u8 *addr, unsigned short vid)
2470{
2471	struct batadv_bla_claim search_claim;
2472	struct batadv_bla_claim *claim = NULL;
2473	struct batadv_hard_iface *primary_if = NULL;
2474	bool ret = true;
2475
2476	if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2477		return ret;
2478
2479	primary_if = batadv_primary_if_get_selected(bat_priv);
2480	if (!primary_if)
2481		return ret;
2482
2483	/* First look if the mac address is claimed */
2484	ether_addr_copy(search_claim.addr, addr);
2485	search_claim.vid = vid;
2486
2487	claim = batadv_claim_hash_find(bat_priv, &search_claim);
2488
2489	/* If there is a claim and we are not owner of the claim,
2490	 * return false.
2491	 */
2492	if (claim) {
2493		if (!batadv_compare_eth(claim->backbone_gw->orig,
2494					primary_if->net_dev->dev_addr))
2495			ret = false;
2496		batadv_claim_put(claim);
2497	}
2498
2499	batadv_hardif_put(primary_if);
2500	return ret;
2501}
2502#endif