net/batman-adv/bridge_loop_avoidance.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) B.A.T.M.A.N. contributors:
   3  *
   4  * Simon Wunderlich
   5  */
   6
   7 #include "bridge_loop_avoidance.h"
   8 #include "main.h"
   9
  10 #include <linux/atomic.h>
  11 #include <linux/byteorder/generic.h>
  12 #include <linux/compiler.h>
  13 #include <linux/crc16.h>
  14 #include <linux/errno.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/gfp.h>
  17 #include <linux/if_arp.h>
  18 #include <linux/if_ether.h>
  19 #include <linux/if_vlan.h>
  20 #include <linux/jhash.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/kernel.h>
  23 #include <linux/kref.h>
  24 #include <linux/list.h>
  25 #include <linux/lockdep.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/netlink.h>
  28 #include <linux/rculist.h>
  29 #include <linux/rcupdate.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/slab.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/stddef.h>
  34 #include <linux/string.h>
  35 #include <linux/workqueue.h>
  36 #include <net/arp.h>
  37 #include <net/genetlink.h>
  38 #include <net/netlink.h>
  39 #include <net/sock.h>
  40 #include <uapi/linux/batadv_packet.h>
  41 #include <uapi/linux/batman_adv.h>
  42
  43 #include "hard-interface.h"
  44 #include "hash.h"
  45 #include "log.h"
  46 #include "netlink.h"
  47 #include "originator.h"
  48 #include "soft-interface.h"
  49 #include "translation-table.h"
  50
  51 static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
  52
  53 static void batadv_bla_periodic_work(struct work_struct *work);
  54 static void
  55 batadv_bla_send_announce(struct batadv_priv *bat_priv,
  56                          struct batadv_bla_backbone_gw *backbone_gw);
  57
  58 /**
  59  * batadv_choose_claim() - choose the right bucket for a claim.
  60  * @data: data to hash
  61  * @size: size of the hash table
  62  *
  63  * Return: the hash index of the claim
  64  */
  65 static inline u32 batadv_choose_claim(const void *data, u32 size)
  66 {
  67         struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
  68         u32 hash = 0;
  69
  70         hash = jhash(&claim->addr, sizeof(claim->addr), hash);
  71         hash = jhash(&claim->vid, sizeof(claim->vid), hash);
  72
  73         return hash % size;
  74 }
  75
  76 /**
  77  * batadv_choose_backbone_gw() - choose the right bucket for a backbone gateway.
  78  * @data: data to hash
  79  * @size: size of the hash table
  80  *
  81  * Return: the hash index of the backbone gateway
  82  */
  83 static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
  84 {
  85         const struct batadv_bla_backbone_gw *gw;
  86         u32 hash = 0;
  87
  88         gw = (struct batadv_bla_backbone_gw *)data;
  89         hash = jhash(&gw->orig, sizeof(gw->orig), hash);
  90         hash = jhash(&gw->vid, sizeof(gw->vid), hash);
  91
  92         return hash % size;
  93 }
  94
  95 /**
  96  * batadv_compare_backbone_gw() - compare address and vid of two backbone gws
  97  * @node: list node of the first entry to compare
  98  * @data2: pointer to the second backbone gateway
  99  *
 100  * Return: true if the backbones have the same data, false otherwise
 101  */
 102 static bool batadv_compare_backbone_gw(const struct hlist_node *node,
 103                                        const void *data2)
 104 {
 105         const void *data1 = container_of(node, struct batadv_bla_backbone_gw,
 106                                          hash_entry);
 107         const struct batadv_bla_backbone_gw *gw1 = data1;
 108         const struct batadv_bla_backbone_gw *gw2 = data2;
 109
 110         if (!batadv_compare_eth(gw1->orig, gw2->orig))
 111                 return false;
 112
 113         if (gw1->vid != gw2->vid)
 114                 return false;
 115
 116         return true;
 117 }
 118
 119 /**
 120  * batadv_compare_claim() - compare address and vid of two claims
 121  * @node: list node of the first entry to compare
 122  * @data2: pointer to the second claims
 123  *
 124  * Return: true if the claim have the same data, 0 otherwise
 125  */
 126 static bool batadv_compare_claim(const struct hlist_node *node,
 127                                  const void *data2)
 128 {
 129         const void *data1 = container_of(node, struct batadv_bla_claim,
 130                                          hash_entry);
 131         const struct batadv_bla_claim *cl1 = data1;
 132         const struct batadv_bla_claim *cl2 = data2;
 133
 134         if (!batadv_compare_eth(cl1->addr, cl2->addr))
 135                 return false;
 136
 137         if (cl1->vid != cl2->vid)
 138                 return false;
 139
 140         return true;
 141 }
 142
 143 /**
 144  * batadv_backbone_gw_release() - release backbone gw from lists and queue for
 145  *  free after rcu grace period
 146  * @ref: kref pointer of the backbone gw
 147  */
 148 static void batadv_backbone_gw_release(struct kref *ref)
 149 {
 150         struct batadv_bla_backbone_gw *backbone_gw;
 151
 152         backbone_gw = container_of(ref, struct batadv_bla_backbone_gw,
 153                                    refcount);
 154
 155         kfree_rcu(backbone_gw, rcu);
 156 }
 157
 158 /**
 159  * batadv_backbone_gw_put() - decrement the backbone gw refcounter and possibly
 160  *  release it
 161  * @backbone_gw: backbone gateway to be free'd
 162  */
 163 static void batadv_backbone_gw_put(struct batadv_bla_backbone_gw *backbone_gw)
 164 {
 165         kref_put(&backbone_gw->refcount, batadv_backbone_gw_release);
 166 }
 167
 168 /**
 169  * batadv_claim_release() - release claim from lists and queue for free after
 170  *  rcu grace period
 171  * @ref: kref pointer of the claim
 172  */
 173 static void batadv_claim_release(struct kref *ref)
 174 {
 175         struct batadv_bla_claim *claim;
 176         struct batadv_bla_backbone_gw *old_backbone_gw;
 177
 178         claim = container_of(ref, struct batadv_bla_claim, refcount);
 179
 180         spin_lock_bh(&claim->backbone_lock);
 181         old_backbone_gw = claim->backbone_gw;
 182         claim->backbone_gw = NULL;
 183         spin_unlock_bh(&claim->backbone_lock);
 184
 185         spin_lock_bh(&old_backbone_gw->crc_lock);
 186         old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 187         spin_unlock_bh(&old_backbone_gw->crc_lock);
 188
 189         batadv_backbone_gw_put(old_backbone_gw);
 190
 191         kfree_rcu(claim, rcu);
 192 }
 193
 194 /**
 195  * batadv_claim_put() - decrement the claim refcounter and possibly release it
 196  * @claim: claim to be free'd
 197  */
 198 static void batadv_claim_put(struct batadv_bla_claim *claim)
 199 {
 200         kref_put(&claim->refcount, batadv_claim_release);
 201 }
 202
 203 /**
 204  * batadv_claim_hash_find() - looks for a claim in the claim hash
 205  * @bat_priv: the bat priv with all the soft interface information
 206  * @data: search data (may be local/static data)
 207  *
 208  * Return: claim if found or NULL otherwise.
 209  */
 210 static struct batadv_bla_claim *
 211 batadv_claim_hash_find(struct batadv_priv *bat_priv,
 212                        struct batadv_bla_claim *data)
 213 {
 214         struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
 215         struct hlist_head *head;
 216         struct batadv_bla_claim *claim;
 217         struct batadv_bla_claim *claim_tmp = NULL;
 218         int index;
 219
 220         if (!hash)
 221                 return NULL;
 222
 223         index = batadv_choose_claim(data, hash->size);
 224         head = &hash->table[index];
 225
 226         rcu_read_lock();
 227         hlist_for_each_entry_rcu(claim, head, hash_entry) {
 228                 if (!batadv_compare_claim(&claim->hash_entry, data))
 229                         continue;
 230
 231                 if (!kref_get_unless_zero(&claim->refcount))
 232                         continue;
 233
 234                 claim_tmp = claim;
 235                 break;
 236         }
 237         rcu_read_unlock();
 238
 239         return claim_tmp;
 240 }
 241
 242 /**
 243  * batadv_backbone_hash_find() - looks for a backbone gateway in the hash
 244  * @bat_priv: the bat priv with all the soft interface information
 245  * @addr: the address of the originator
 246  * @vid: the VLAN ID
 247  *
 248  * Return: backbone gateway if found or NULL otherwise
 249  */
 250 static struct batadv_bla_backbone_gw *
 251 batadv_backbone_hash_find(struct batadv_priv *bat_priv, u8 *addr,
 252                           unsigned short vid)
 253 {
 254         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
 255         struct hlist_head *head;
 256         struct batadv_bla_backbone_gw search_entry, *backbone_gw;
 257         struct batadv_bla_backbone_gw *backbone_gw_tmp = NULL;
 258         int index;
 259
 260         if (!hash)
 261                 return NULL;
 262
 263         ether_addr_copy(search_entry.orig, addr);
 264         search_entry.vid = vid;
 265
 266         index = batadv_choose_backbone_gw(&search_entry, hash->size);
 267         head = &hash->table[index];
 268
 269         rcu_read_lock();
 270         hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
 271                 if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
 272                                                 &search_entry))
 273                         continue;
 274
 275                 if (!kref_get_unless_zero(&backbone_gw->refcount))
 276                         continue;
 277
 278                 backbone_gw_tmp = backbone_gw;
 279                 break;
 280         }
 281         rcu_read_unlock();
 282
 283         return backbone_gw_tmp;
 284 }
 285
 286 /**
 287  * batadv_bla_del_backbone_claims() - delete all claims for a backbone
 288  * @backbone_gw: backbone gateway where the claims should be removed
 289  */
 290 static void
 291 batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
 292 {
 293         struct batadv_hashtable *hash;
 294         struct hlist_node *node_tmp;
 295         struct hlist_head *head;
 296         struct batadv_bla_claim *claim;
 297         int i;
 298         spinlock_t *list_lock;  /* protects write access to the hash lists */
 299
 300         hash = backbone_gw->bat_priv->bla.claim_hash;
 301         if (!hash)
 302                 return;
 303
 304         for (i = 0; i < hash->size; i++) {
 305                 head = &hash->table[i];
 306                 list_lock = &hash->list_locks[i];
 307
 308                 spin_lock_bh(list_lock);
 309                 hlist_for_each_entry_safe(claim, node_tmp,
 310                                           head, hash_entry) {
 311                         if (claim->backbone_gw != backbone_gw)
 312                                 continue;
 313
 314                         batadv_claim_put(claim);
 315                         hlist_del_rcu(&claim->hash_entry);
 316                 }
 317                 spin_unlock_bh(list_lock);
 318         }
 319
 320         /* all claims gone, initialize CRC */
 321         spin_lock_bh(&backbone_gw->crc_lock);
 322         backbone_gw->crc = BATADV_BLA_CRC_INIT;
 323         spin_unlock_bh(&backbone_gw->crc_lock);
 324 }
 325
 326 /**
 327  * batadv_bla_send_claim() - sends a claim frame according to the provided info
 328  * @bat_priv: the bat priv with all the soft interface information
 329  * @mac: the mac address to be announced within the claim
 330  * @vid: the VLAN ID
 331  * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
 332  */
 333 static void batadv_bla_send_claim(struct batadv_priv *bat_priv, u8 *mac,
 334                                   unsigned short vid, int claimtype)
 335 {
 336         struct sk_buff *skb;
 337         struct ethhdr *ethhdr;
 338         struct batadv_hard_iface *primary_if;
 339         struct net_device *soft_iface;
 340         u8 *hw_src;
 341         struct batadv_bla_claim_dst local_claim_dest;
 342         __be32 zeroip = 0;
 343
 344         primary_if = batadv_primary_if_get_selected(bat_priv);
 345         if (!primary_if)
 346                 return;
 347
 348         memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
 349                sizeof(local_claim_dest));
 350         local_claim_dest.type = claimtype;
 351
 352         soft_iface = primary_if->soft_iface;
 353
 354         skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
 355                          /* IP DST: 0.0.0.0 */
 356                          zeroip,
 357                          primary_if->soft_iface,
 358                          /* IP SRC: 0.0.0.0 */
 359                          zeroip,
 360                          /* Ethernet DST: Broadcast */
 361                          NULL,
 362                          /* Ethernet SRC/HW SRC:  originator mac */
 363                          primary_if->net_dev->dev_addr,
 364                          /* HW DST: FF:43:05:XX:YY:YY
 365                           * with XX   = claim type
 366                           * and YY:YY = group id
 367                           */
 368                          (u8 *)&local_claim_dest);
 369
 370         if (!skb)
 371                 goto out;
 372
 373         ethhdr = (struct ethhdr *)skb->data;
 374         hw_src = (u8 *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
 375
 376         /* now we pretend that the client would have sent this ... */
 377         switch (claimtype) {
 378         case BATADV_CLAIM_TYPE_CLAIM:
 379                 /* normal claim frame
 380                  * set Ethernet SRC to the clients mac
 381                  */
 382                 ether_addr_copy(ethhdr->h_source, mac);
 383                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 384                            "%s(): CLAIM %pM on vid %d\n", __func__, mac,
 385                            batadv_print_vid(vid));
 386                 break;
 387         case BATADV_CLAIM_TYPE_UNCLAIM:
 388                 /* unclaim frame
 389                  * set HW SRC to the clients mac
 390                  */
 391                 ether_addr_copy(hw_src, mac);
 392                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 393                            "%s(): UNCLAIM %pM on vid %d\n", __func__, mac,
 394                            batadv_print_vid(vid));
 395                 break;
 396         case BATADV_CLAIM_TYPE_ANNOUNCE:
 397                 /* announcement frame
 398                  * set HW SRC to the special mac 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_any_context(skb);
 441 out:
 442         if (primary_if)
 443                 batadv_hardif_put(primary_if);
 444 }
 445
 446 /**
 447  * batadv_bla_loopdetect_report() - worker for reporting the loop
 448  * @work: work queue item
 449  *
 450  * Throws an uevent, as the loopdetect check function can't do that itself
 451  * since the kernel may sleep while throwing uevents.
 452  */
 453 static void batadv_bla_loopdetect_report(struct work_struct *work)
 454 {
 455         struct batadv_bla_backbone_gw *backbone_gw;
 456         struct batadv_priv *bat_priv;
 457         char vid_str[6] = { '\0' };
 458
 459         backbone_gw = container_of(work, struct batadv_bla_backbone_gw,
 460                                    report_work);
 461         bat_priv = backbone_gw->bat_priv;
 462
 463         batadv_info(bat_priv->soft_iface,
 464                     "Possible loop on VLAN %d detected which can't be handled by BLA - please check your network setup!\n",
 465                     batadv_print_vid(backbone_gw->vid));
 466         snprintf(vid_str, sizeof(vid_str), "%d",
 467                  batadv_print_vid(backbone_gw->vid));
 468         vid_str[sizeof(vid_str) - 1] = 0;
 469
 470         batadv_throw_uevent(bat_priv, BATADV_UEV_BLA, BATADV_UEV_LOOPDETECT,
 471                             vid_str);
 472
 473         batadv_backbone_gw_put(backbone_gw);
 474 }
 475
 476 /**
 477  * batadv_bla_get_backbone_gw() - finds or creates a backbone gateway
 478  * @bat_priv: the bat priv with all the soft interface information
 479  * @orig: the mac address of the originator
 480  * @vid: the VLAN ID
 481  * @own_backbone: set if the requested backbone is local
 482  *
 483  * Return: the (possibly created) backbone gateway or NULL on error
 484  */
 485 static struct batadv_bla_backbone_gw *
 486 batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, u8 *orig,
 487                            unsigned short vid, bool own_backbone)
 488 {
 489         struct batadv_bla_backbone_gw *entry;
 490         struct batadv_orig_node *orig_node;
 491         int hash_added;
 492
 493         entry = batadv_backbone_hash_find(bat_priv, orig, vid);
 494
 495         if (entry)
 496                 return entry;
 497
 498         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 499                    "%s(): not found (%pM, %d), creating new entry\n", __func__,
 500                    orig, batadv_print_vid(vid));
 501
 502         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 503         if (!entry)
 504                 return NULL;
 505
 506         entry->vid = vid;
 507         entry->lasttime = jiffies;
 508         entry->crc = BATADV_BLA_CRC_INIT;
 509         entry->bat_priv = bat_priv;
 510         spin_lock_init(&entry->crc_lock);
 511         atomic_set(&entry->request_sent, 0);
 512         atomic_set(&entry->wait_periods, 0);
 513         ether_addr_copy(entry->orig, orig);
 514         INIT_WORK(&entry->report_work, batadv_bla_loopdetect_report);
 515         kref_init(&entry->refcount);
 516
 517         kref_get(&entry->refcount);
 518         hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
 519                                      batadv_compare_backbone_gw,
 520                                      batadv_choose_backbone_gw, entry,
 521                                      &entry->hash_entry);
 522
 523         if (unlikely(hash_added != 0)) {
 524                 /* hash failed, free the structure */
 525                 kfree(entry);
 526                 return NULL;
 527         }
 528
 529         /* this is a gateway now, remove any TT entry on this VLAN */
 530         orig_node = batadv_orig_hash_find(bat_priv, orig);
 531         if (orig_node) {
 532                 batadv_tt_global_del_orig(bat_priv, orig_node, vid,
 533                                           "became a backbone gateway");
 534                 batadv_orig_node_put(orig_node);
 535         }
 536
 537         if (own_backbone) {
 538                 batadv_bla_send_announce(bat_priv, entry);
 539
 540                 /* this will be decreased in the worker thread */
 541                 atomic_inc(&entry->request_sent);
 542                 atomic_set(&entry->wait_periods, BATADV_BLA_WAIT_PERIODS);
 543                 atomic_inc(&bat_priv->bla.num_requests);
 544         }
 545
 546         return entry;
 547 }
 548
 549 /**
 550  * batadv_bla_update_own_backbone_gw() - updates the own backbone gw for a VLAN
 551  * @bat_priv: the bat priv with all the soft interface information
 552  * @primary_if: the selected primary interface
 553  * @vid: VLAN identifier
 554  *
 555  * update or add the own backbone gw to make sure we announce
 556  * where we receive other backbone gws
 557  */
 558 static void
 559 batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
 560                                   struct batadv_hard_iface *primary_if,
 561                                   unsigned short vid)
 562 {
 563         struct batadv_bla_backbone_gw *backbone_gw;
 564
 565         backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
 566                                                  primary_if->net_dev->dev_addr,
 567                                                  vid, true);
 568         if (unlikely(!backbone_gw))
 569                 return;
 570
 571         backbone_gw->lasttime = jiffies;
 572         batadv_backbone_gw_put(backbone_gw);
 573 }
 574
 575 /**
 576  * batadv_bla_answer_request() - answer a bla request by sending own claims
 577  * @bat_priv: the bat priv with all the soft interface information
 578  * @primary_if: interface where the request came on
 579  * @vid: the vid where the request came on
 580  *
 581  * Repeat all of our own claims, and finally send an ANNOUNCE frame
 582  * to allow the requester another check if the CRC is correct now.
 583  */
 584 static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
 585                                       struct batadv_hard_iface *primary_if,
 586                                       unsigned short vid)
 587 {
 588         struct hlist_head *head;
 589         struct batadv_hashtable *hash;
 590         struct batadv_bla_claim *claim;
 591         struct batadv_bla_backbone_gw *backbone_gw;
 592         int i;
 593
 594         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 595                    "%s(): received a claim request, send all of our own claims again\n",
 596                    __func__);
 597
 598         backbone_gw = batadv_backbone_hash_find(bat_priv,
 599                                                 primary_if->net_dev->dev_addr,
 600                                                 vid);
 601         if (!backbone_gw)
 602                 return;
 603
 604         hash = bat_priv->bla.claim_hash;
 605         for (i = 0; i < hash->size; i++) {
 606                 head = &hash->table[i];
 607
 608                 rcu_read_lock();
 609                 hlist_for_each_entry_rcu(claim, head, hash_entry) {
 610                         /* only own claims are interesting */
 611                         if (claim->backbone_gw != backbone_gw)
 612                                 continue;
 613
 614                         batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
 615                                               BATADV_CLAIM_TYPE_CLAIM);
 616                 }
 617                 rcu_read_unlock();
 618         }
 619
 620         /* finally, send an announcement frame */
 621         batadv_bla_send_announce(bat_priv, backbone_gw);
 622         batadv_backbone_gw_put(backbone_gw);
 623 }
 624
 625 /**
 626  * batadv_bla_send_request() - send a request to repeat claims
 627  * @backbone_gw: the backbone gateway from whom we are out of sync
 628  *
 629  * When the crc is wrong, ask the backbone gateway for a full table update.
 630  * After the request, it will repeat all of his own claims and finally
 631  * send an announcement claim with which we can check again.
 632  */
 633 static void batadv_bla_send_request(struct batadv_bla_backbone_gw *backbone_gw)
 634 {
 635         /* first, remove all old entries */
 636         batadv_bla_del_backbone_claims(backbone_gw);
 637
 638         batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 639                    "Sending REQUEST to %pM\n", backbone_gw->orig);
 640
 641         /* send request */
 642         batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
 643                               backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
 644
 645         /* no local broadcasts should be sent or received, for now. */
 646         if (!atomic_read(&backbone_gw->request_sent)) {
 647                 atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
 648                 atomic_set(&backbone_gw->request_sent, 1);
 649         }
 650 }
 651
 652 /**
 653  * batadv_bla_send_announce() - Send an announcement frame
 654  * @bat_priv: the bat priv with all the soft interface information
 655  * @backbone_gw: our backbone gateway which should be announced
 656  */
 657 static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
 658                                      struct batadv_bla_backbone_gw *backbone_gw)
 659 {
 660         u8 mac[ETH_ALEN];
 661         __be16 crc;
 662
 663         memcpy(mac, batadv_announce_mac, 4);
 664         spin_lock_bh(&backbone_gw->crc_lock);
 665         crc = htons(backbone_gw->crc);
 666         spin_unlock_bh(&backbone_gw->crc_lock);
 667         memcpy(&mac[4], &crc, 2);
 668
 669         batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
 670                               BATADV_CLAIM_TYPE_ANNOUNCE);
 671 }
 672
 673 /**
 674  * batadv_bla_add_claim() - Adds a claim in the claim hash
 675  * @bat_priv: the bat priv with all the soft interface information
 676  * @mac: the mac address of the claim
 677  * @vid: the VLAN ID of the frame
 678  * @backbone_gw: the backbone gateway which claims it
 679  */
 680 static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
 681                                  const u8 *mac, const unsigned short vid,
 682                                  struct batadv_bla_backbone_gw *backbone_gw)
 683 {
 684         struct batadv_bla_backbone_gw *old_backbone_gw;
 685         struct batadv_bla_claim *claim;
 686         struct batadv_bla_claim search_claim;
 687         bool remove_crc = false;
 688         int hash_added;
 689
 690         ether_addr_copy(search_claim.addr, mac);
 691         search_claim.vid = vid;
 692         claim = batadv_claim_hash_find(bat_priv, &search_claim);
 693
 694         /* create a new claim entry if it does not exist yet. */
 695         if (!claim) {
 696                 claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
 697                 if (!claim)
 698                         return;
 699
 700                 ether_addr_copy(claim->addr, mac);
 701                 spin_lock_init(&claim->backbone_lock);
 702                 claim->vid = vid;
 703                 claim->lasttime = jiffies;
 704                 kref_get(&backbone_gw->refcount);
 705                 claim->backbone_gw = backbone_gw;
 706                 kref_init(&claim->refcount);
 707
 708                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 709                            "%s(): adding new entry %pM, vid %d to hash ...\n",
 710                            __func__, mac, batadv_print_vid(vid));
 711
 712                 kref_get(&claim->refcount);
 713                 hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
 714                                              batadv_compare_claim,
 715                                              batadv_choose_claim, claim,
 716                                              &claim->hash_entry);
 717
 718                 if (unlikely(hash_added != 0)) {
 719                         /* only local changes happened. */
 720                         kfree(claim);
 721                         return;
 722                 }
 723         } else {
 724                 claim->lasttime = jiffies;
 725                 if (claim->backbone_gw == backbone_gw)
 726                         /* no need to register a new backbone */
 727                         goto claim_free_ref;
 728
 729                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 730                            "%s(): changing ownership for %pM, vid %d to gw %pM\n",
 731                            __func__, mac, batadv_print_vid(vid),
 732                            backbone_gw->orig);
 733
 734                 remove_crc = true;
 735         }
 736
 737         /* replace backbone_gw atomically and adjust reference counters */
 738         spin_lock_bh(&claim->backbone_lock);
 739         old_backbone_gw = claim->backbone_gw;
 740         kref_get(&backbone_gw->refcount);
 741         claim->backbone_gw = backbone_gw;
 742         spin_unlock_bh(&claim->backbone_lock);
 743
 744         if (remove_crc) {
 745                 /* remove claim address from old backbone_gw */
 746                 spin_lock_bh(&old_backbone_gw->crc_lock);
 747                 old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 748                 spin_unlock_bh(&old_backbone_gw->crc_lock);
 749         }
 750
 751         batadv_backbone_gw_put(old_backbone_gw);
 752
 753         /* add claim address to new backbone_gw */
 754         spin_lock_bh(&backbone_gw->crc_lock);
 755         backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 756         spin_unlock_bh(&backbone_gw->crc_lock);
 757         backbone_gw->lasttime = jiffies;
 758
 759 claim_free_ref:
 760         batadv_claim_put(claim);
 761 }
 762
 763 /**
 764  * batadv_bla_claim_get_backbone_gw() - Get valid reference for backbone_gw of
 765  *  claim
 766  * @claim: claim whose backbone_gw should be returned
 767  *
 768  * Return: valid reference to claim::backbone_gw
 769  */
 770 static struct batadv_bla_backbone_gw *
 771 batadv_bla_claim_get_backbone_gw(struct batadv_bla_claim *claim)
 772 {
 773         struct batadv_bla_backbone_gw *backbone_gw;
 774
 775         spin_lock_bh(&claim->backbone_lock);
 776         backbone_gw = claim->backbone_gw;
 777         kref_get(&backbone_gw->refcount);
 778         spin_unlock_bh(&claim->backbone_lock);
 779
 780         return backbone_gw;
 781 }
 782
 783 /**
 784  * batadv_bla_del_claim() - delete a claim from the claim hash
 785  * @bat_priv: the bat priv with all the soft interface information
 786  * @mac: mac address of the claim to be removed
 787  * @vid: VLAN id for the claim to be removed
 788  */
 789 static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
 790                                  const u8 *mac, const unsigned short vid)
 791 {
 792         struct batadv_bla_claim search_claim, *claim;
 793         struct batadv_bla_claim *claim_removed_entry;
 794         struct hlist_node *claim_removed_node;
 795
 796         ether_addr_copy(search_claim.addr, mac);
 797         search_claim.vid = vid;
 798         claim = batadv_claim_hash_find(bat_priv, &search_claim);
 799         if (!claim)
 800                 return;
 801
 802         batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__,
 803                    mac, batadv_print_vid(vid));
 804
 805         claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash,
 806                                                 batadv_compare_claim,
 807                                                 batadv_choose_claim, claim);
 808         if (!claim_removed_node)
 809                 goto free_claim;
 810
 811         /* reference from the hash is gone */
 812         claim_removed_entry = hlist_entry(claim_removed_node,
 813                                           struct batadv_bla_claim, hash_entry);
 814         batadv_claim_put(claim_removed_entry);
 815
 816 free_claim:
 817         /* don't need the reference from hash_find() anymore */
 818         batadv_claim_put(claim);
 819 }
 820
 821 /**
 822  * batadv_handle_announce() - check for ANNOUNCE frame
 823  * @bat_priv: the bat priv with all the soft interface information
 824  * @an_addr: announcement mac address (ARP Sender HW address)
 825  * @backbone_addr: originator address of the sender (Ethernet source MAC)
 826  * @vid: the VLAN ID of the frame
 827  *
 828  * Return: true if handled
 829  */
 830 static bool batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
 831                                    u8 *backbone_addr, unsigned short vid)
 832 {
 833         struct batadv_bla_backbone_gw *backbone_gw;
 834         u16 backbone_crc, crc;
 835
 836         if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
 837                 return false;
 838
 839         backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
 840                                                  false);
 841
 842         if (unlikely(!backbone_gw))
 843                 return true;
 844
 845         /* handle as ANNOUNCE frame */
 846         backbone_gw->lasttime = jiffies;
 847         crc = ntohs(*((__force __be16 *)(&an_addr[4])));
 848
 849         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 850                    "%s(): ANNOUNCE vid %d (sent by %pM)... CRC = %#.4x\n",
 851                    __func__, batadv_print_vid(vid), backbone_gw->orig, crc);
 852
 853         spin_lock_bh(&backbone_gw->crc_lock);
 854         backbone_crc = backbone_gw->crc;
 855         spin_unlock_bh(&backbone_gw->crc_lock);
 856
 857         if (backbone_crc != crc) {
 858                 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 859                            "%s(): CRC FAILED for %pM/%d (my = %#.4x, sent = %#.4x)\n",
 860                            __func__, backbone_gw->orig,
 861                            batadv_print_vid(backbone_gw->vid),
 862                            backbone_crc, crc);
 863
 864                 batadv_bla_send_request(backbone_gw);
 865         } else {
 866                 /* if we have sent a request and the crc was OK,
 867                  * we can allow traffic again.
 868                  */
 869                 if (atomic_read(&backbone_gw->request_sent)) {
 870                         atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
 871                         atomic_set(&backbone_gw->request_sent, 0);
 872                 }
 873         }
 874
 875         batadv_backbone_gw_put(backbone_gw);
 876         return true;
 877 }
 878
 879 /**
 880  * batadv_handle_request() - check for REQUEST frame
 881  * @bat_priv: the bat priv with all the soft interface information
 882  * @primary_if: the primary hard interface of this batman soft interface
 883  * @backbone_addr: backbone address to be requested (ARP sender HW MAC)
 884  * @ethhdr: ethernet header of a packet
 885  * @vid: the VLAN ID of the frame
 886  *
 887  * Return: true if handled
 888  */
 889 static bool batadv_handle_request(struct batadv_priv *bat_priv,
 890                                   struct batadv_hard_iface *primary_if,
 891                                   u8 *backbone_addr, struct ethhdr *ethhdr,
 892                                   unsigned short vid)
 893 {
 894         /* check for REQUEST frame */
 895         if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
 896                 return false;
 897
 898         /* sanity check, this should not happen on a normal switch,
 899          * we ignore it in this case.
 900          */
 901         if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
 902                 return true;
 903
 904         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 905                    "%s(): REQUEST vid %d (sent by %pM)...\n",
 906                    __func__, batadv_print_vid(vid), ethhdr->h_source);
 907
 908         batadv_bla_answer_request(bat_priv, primary_if, vid);
 909         return true;
 910 }
 911
 912 /**
 913  * batadv_handle_unclaim() - check for UNCLAIM frame
 914  * @bat_priv: the bat priv with all the soft interface information
 915  * @primary_if: the primary hard interface of this batman soft interface
 916  * @backbone_addr: originator address of the backbone (Ethernet source)
 917  * @claim_addr: Client to be unclaimed (ARP sender HW MAC)
 918  * @vid: the VLAN ID of the frame
 919  *
 920  * Return: true if handled
 921  */
 922 static bool batadv_handle_unclaim(struct batadv_priv *bat_priv,
 923                                   struct batadv_hard_iface *primary_if,
 924                                   u8 *backbone_addr, u8 *claim_addr,
 925                                   unsigned short vid)
 926 {
 927         struct batadv_bla_backbone_gw *backbone_gw;
 928
 929         /* unclaim in any case if it is our own */
 930         if (primary_if && batadv_compare_eth(backbone_addr,
 931                                              primary_if->net_dev->dev_addr))
 932                 batadv_bla_send_claim(bat_priv, claim_addr, vid,
 933                                       BATADV_CLAIM_TYPE_UNCLAIM);
 934
 935         backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
 936
 937         if (!backbone_gw)
 938                 return true;
 939
 940         /* this must be an UNCLAIM frame */
 941         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 942                    "%s(): UNCLAIM %pM on vid %d (sent by %pM)...\n", __func__,
 943                    claim_addr, batadv_print_vid(vid), backbone_gw->orig);
 944
 945         batadv_bla_del_claim(bat_priv, claim_addr, vid);
 946         batadv_backbone_gw_put(backbone_gw);
 947         return true;
 948 }
 949
 950 /**
 951  * batadv_handle_claim() - check for CLAIM frame
 952  * @bat_priv: the bat priv with all the soft interface information
 953  * @primary_if: the primary hard interface of this batman soft interface
 954  * @backbone_addr: originator address of the backbone (Ethernet Source)
 955  * @claim_addr: client mac address to be claimed (ARP sender HW MAC)
 956  * @vid: the VLAN ID of the frame
 957  *
 958  * Return: true if handled
 959  */
 960 static bool batadv_handle_claim(struct batadv_priv *bat_priv,
 961                                 struct batadv_hard_iface *primary_if,
 962                                 u8 *backbone_addr, u8 *claim_addr,
 963                                 unsigned short vid)
 964 {
 965         struct batadv_bla_backbone_gw *backbone_gw;
 966
 967         /* register the gateway if not yet available, and add the claim. */
 968
 969         backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
 970                                                  false);
 971
 972         if (unlikely(!backbone_gw))
 973                 return true;
 974
 975         /* this must be a CLAIM frame */
 976         batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
 977         if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
 978                 batadv_bla_send_claim(bat_priv, claim_addr, vid,
 979                                       BATADV_CLAIM_TYPE_CLAIM);
 980
 981         /* TODO: we could call something like tt_local_del() here. */
 982
 983         batadv_backbone_gw_put(backbone_gw);
 984         return true;
 985 }
 986
 987 /**
 988  * batadv_check_claim_group() - check for claim group membership
 989  * @bat_priv: the bat priv with all the soft interface information
 990  * @primary_if: the primary interface of this batman interface
 991  * @hw_src: the Hardware source in the ARP Header
 992  * @hw_dst: the Hardware destination in the ARP Header
 993  * @ethhdr: pointer to the Ethernet header of the claim frame
 994  *
 995  * checks if it is a claim packet and if it's on the same group.
 996  * This function also applies the group ID of the sender
 997  * if it is in the same mesh.
 998  *
 999  * Return:
1000  *      2  - if it is a claim packet and on the same group
1001  *      1  - if is a claim packet from another group
1002  *      0  - if it is not a claim packet
1003  */
1004 static int batadv_check_claim_group(struct batadv_priv *bat_priv,
1005                                     struct batadv_hard_iface *primary_if,
1006                                     u8 *hw_src, u8 *hw_dst,
1007                                     struct ethhdr *ethhdr)
1008 {
1009         u8 *backbone_addr;
1010         struct batadv_orig_node *orig_node;
1011         struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
1012
1013         bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1014         bla_dst_own = &bat_priv->bla.claim_dest;
1015
1016         /* if announcement packet, use the source,
1017          * otherwise assume it is in the hw_src
1018          */
1019         switch (bla_dst->type) {
1020         case BATADV_CLAIM_TYPE_CLAIM:
1021                 backbone_addr = hw_src;
1022                 break;
1023         case BATADV_CLAIM_TYPE_REQUEST:
1024         case BATADV_CLAIM_TYPE_ANNOUNCE:
1025         case BATADV_CLAIM_TYPE_UNCLAIM:
1026                 backbone_addr = ethhdr->h_source;
1027                 break;
1028         default:
1029                 return 0;
1030         }
1031
1032         /* don't accept claim frames from ourselves */
1033         if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
1034                 return 0;
1035
1036         /* if its already the same group, it is fine. */
1037         if (bla_dst->group == bla_dst_own->group)
1038                 return 2;
1039
1040         /* lets see if this originator is in our mesh */
1041         orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
1042
1043         /* 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_duplist() - Check if a frame is in the broadcast dup.
1580  * @bat_priv: the bat priv with all the soft interface information
1581  * @skb: contains the multicast packet to be checked
1582  * @payload_ptr: pointer to position inside the head buffer of the skb
1583  *  marking the start of the data to be CRC'ed
1584  * @orig: originator mac address, NULL if unknown
1585  *
1586  * Check if it is on our broadcast list. Another gateway might have sent the
1587  * same packet because it is connected to the same backbone, so we have to
1588  * remove this duplicate.
1589  *
1590  * This is performed by checking the CRC, which will tell us
1591  * with a good chance that it is the same packet. If it is furthermore
1592  * sent by another host, drop it. We allow equal packets from
1593  * the same host however as this might be intended.
1594  *
1595  * Return: true if a packet is in the duplicate list, false otherwise.
1596  */
1597 static bool batadv_bla_check_duplist(struct batadv_priv *bat_priv,
1598                                      struct sk_buff *skb, u8 *payload_ptr,
1599                                      const u8 *orig)
1600 {
1601         struct batadv_bcast_duplist_entry *entry;
1602         bool ret = false;
1603         int i, curr;
1604         __be32 crc;
1605
1606         /* calculate the crc ... */
1607         crc = batadv_skb_crc32(skb, payload_ptr);
1608
1609         spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1610
1611         for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1612                 curr = (bat_priv->bla.bcast_duplist_curr + i);
1613                 curr %= BATADV_DUPLIST_SIZE;
1614                 entry = &bat_priv->bla.bcast_duplist[curr];
1615
1616                 /* we can stop searching if the entry is too old ;
1617                  * later entries will be even older
1618                  */
1619                 if (batadv_has_timed_out(entry->entrytime,
1620                                          BATADV_DUPLIST_TIMEOUT))
1621                         break;
1622
1623                 if (entry->crc != crc)
1624                         continue;
1625
1626                 /* are the originators both known and not anonymous? */
1627                 if (orig && !is_zero_ether_addr(orig) &&
1628                     !is_zero_ether_addr(entry->orig)) {
1629                         /* If known, check if the new frame came from
1630                          * the same originator:
1631                          * We are safe to take identical frames from the
1632                          * same orig, if known, as multiplications in
1633                          * the mesh are detected via the (orig, seqno) pair.
1634                          * So we can be a bit more liberal here and allow
1635                          * identical frames from the same orig which the source
1636                          * host might have sent multiple times on purpose.
1637                          */
1638                         if (batadv_compare_eth(entry->orig, orig))
1639                                 continue;
1640                 }
1641
1642                 /* this entry seems to match: same crc, not too old,
1643                  * and from another gw. therefore return true to forbid it.
1644                  */
1645                 ret = true;
1646                 goto out;
1647         }
1648         /* not found, add a new entry (overwrite the oldest entry)
1649          * and allow it, its the first occurrence.
1650          */
1651         curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
1652         curr %= BATADV_DUPLIST_SIZE;
1653         entry = &bat_priv->bla.bcast_duplist[curr];
1654         entry->crc = crc;
1655         entry->entrytime = jiffies;
1656
1657         /* known originator */
1658         if (orig)
1659                 ether_addr_copy(entry->orig, orig);
1660         /* anonymous originator */
1661         else
1662                 eth_zero_addr(entry->orig);
1663
1664         bat_priv->bla.bcast_duplist_curr = curr;
1665
1666 out:
1667         spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1668
1669         return ret;
1670 }
1671
1672 /**
1673  * batadv_bla_check_ucast_duplist() - Check if a frame is in the broadcast dup.
1674  * @bat_priv: the bat priv with all the soft interface information
1675  * @skb: contains the multicast packet to be checked, decapsulated from a
1676  *  unicast_packet
1677  *
1678  * Check if it is on our broadcast list. Another gateway might have sent the
1679  * same packet because it is connected to the same backbone, so we have to
1680  * remove this duplicate.
1681  *
1682  * Return: true if a packet is in the duplicate list, false otherwise.
1683  */
1684 static bool batadv_bla_check_ucast_duplist(struct batadv_priv *bat_priv,
1685                                            struct sk_buff *skb)
1686 {
1687         return batadv_bla_check_duplist(bat_priv, skb, (u8 *)skb->data, NULL);
1688 }
1689
1690 /**
1691  * batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.
1692  * @bat_priv: the bat priv with all the soft interface information
1693  * @skb: contains the bcast_packet to be checked
1694  *
1695  * Check if it is on our broadcast list. Another gateway might have sent the
1696  * same packet because it is connected to the same backbone, so we have to
1697  * remove this duplicate.
1698  *
1699  * Return: true if a packet is in the duplicate list, false otherwise.
1700  */
1701 bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
1702                                     struct sk_buff *skb)
1703 {
1704         struct batadv_bcast_packet *bcast_packet;
1705         u8 *payload_ptr;
1706
1707         bcast_packet = (struct batadv_bcast_packet *)skb->data;
1708         payload_ptr = (u8 *)(bcast_packet + 1);
1709
1710         return batadv_bla_check_duplist(bat_priv, skb, payload_ptr,
1711                                         bcast_packet->orig);
1712 }
1713
1714 /**
1715  * batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
1716  *  the VLAN identified by vid.
1717  * @bat_priv: the bat priv with all the soft interface information
1718  * @orig: originator mac address
1719  * @vid: VLAN identifier
1720  *
1721  * Return: true if orig is a backbone for this vid, false otherwise.
1722  */
1723 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1724                                     unsigned short vid)
1725 {
1726         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1727         struct hlist_head *head;
1728         struct batadv_bla_backbone_gw *backbone_gw;
1729         int i;
1730
1731         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1732                 return false;
1733
1734         if (!hash)
1735                 return false;
1736
1737         for (i = 0; i < hash->size; i++) {
1738                 head = &hash->table[i];
1739
1740                 rcu_read_lock();
1741                 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1742                         if (batadv_compare_eth(backbone_gw->orig, orig) &&
1743                             backbone_gw->vid == vid) {
1744                                 rcu_read_unlock();
1745                                 return true;
1746                         }
1747                 }
1748                 rcu_read_unlock();
1749         }
1750
1751         return false;
1752 }
1753
1754 /**
1755  * batadv_bla_is_backbone_gw() - check if originator is a backbone gw for a VLAN
1756  * @skb: the frame to be checked
1757  * @orig_node: the orig_node of the frame
1758  * @hdr_size: maximum length of the frame
1759  *
1760  * Return: true if the orig_node is also a gateway on the soft interface,
1761  * otherwise it returns false.
1762  */
1763 bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
1764                                struct batadv_orig_node *orig_node, int hdr_size)
1765 {
1766         struct batadv_bla_backbone_gw *backbone_gw;
1767         unsigned short vid;
1768
1769         if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1770                 return false;
1771
1772         /* first, find out the vid. */
1773         if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
1774                 return false;
1775
1776         vid = batadv_get_vid(skb, hdr_size);
1777
1778         /* see if this originator is a backbone gw for this VLAN */
1779         backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1780                                                 orig_node->orig, vid);
1781         if (!backbone_gw)
1782                 return false;
1783
1784         batadv_backbone_gw_put(backbone_gw);
1785         return true;
1786 }
1787
1788 /**
1789  * batadv_bla_free() - free all bla structures
1790  * @bat_priv: the bat priv with all the soft interface information
1791  *
1792  * for softinterface free or module unload
1793  */
1794 void batadv_bla_free(struct batadv_priv *bat_priv)
1795 {
1796         struct batadv_hard_iface *primary_if;
1797
1798         cancel_delayed_work_sync(&bat_priv->bla.work);
1799         primary_if = batadv_primary_if_get_selected(bat_priv);
1800
1801         if (bat_priv->bla.claim_hash) {
1802                 batadv_bla_purge_claims(bat_priv, primary_if, 1);
1803                 batadv_hash_destroy(bat_priv->bla.claim_hash);
1804                 bat_priv->bla.claim_hash = NULL;
1805         }
1806         if (bat_priv->bla.backbone_hash) {
1807                 batadv_bla_purge_backbone_gw(bat_priv, 1);
1808                 batadv_hash_destroy(bat_priv->bla.backbone_hash);
1809                 bat_priv->bla.backbone_hash = NULL;
1810         }
1811         if (primary_if)
1812                 batadv_hardif_put(primary_if);
1813 }
1814
1815 /**
1816  * batadv_bla_loopdetect_check() - check and handle a detected loop
1817  * @bat_priv: the bat priv with all the soft interface information
1818  * @skb: the packet to check
1819  * @primary_if: interface where the request came on
1820  * @vid: the VLAN ID of the frame
1821  *
1822  * Checks if this packet is a loop detect frame which has been sent by us,
1823  * throws an uevent and logs the event if that is the case.
1824  *
1825  * Return: true if it is a loop detect frame which is to be dropped, false
1826  * otherwise.
1827  */
1828 static bool
1829 batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
1830                             struct batadv_hard_iface *primary_if,
1831                             unsigned short vid)
1832 {
1833         struct batadv_bla_backbone_gw *backbone_gw;
1834         struct ethhdr *ethhdr;
1835         bool ret;
1836
1837         ethhdr = eth_hdr(skb);
1838
1839         /* Only check for the MAC address and skip more checks here for
1840          * performance reasons - this function is on the hotpath, after all.
1841          */
1842         if (!batadv_compare_eth(ethhdr->h_source,
1843                                 bat_priv->bla.loopdetect_addr))
1844                 return false;
1845
1846         /* If the packet came too late, don't forward it on the mesh
1847          * but don't consider that as loop. It might be a coincidence.
1848          */
1849         if (batadv_has_timed_out(bat_priv->bla.loopdetect_lasttime,
1850                                  BATADV_BLA_LOOPDETECT_TIMEOUT))
1851                 return true;
1852
1853         backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
1854                                                  primary_if->net_dev->dev_addr,
1855                                                  vid, true);
1856         if (unlikely(!backbone_gw))
1857                 return true;
1858
1859         ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work);
1860
1861         /* backbone_gw is unreferenced in the report work function
1862          * if queue_work() call was successful
1863          */
1864         if (!ret)
1865                 batadv_backbone_gw_put(backbone_gw);
1866
1867         return true;
1868 }
1869
1870 /**
1871  * batadv_bla_rx() - check packets coming from the mesh.
1872  * @bat_priv: the bat priv with all the soft interface information
1873  * @skb: the frame to be checked
1874  * @vid: the VLAN ID of the frame
1875  * @packet_type: the batman packet type this frame came in
1876  *
1877  * batadv_bla_rx avoidance checks if:
1878  *  * we have to race for a claim
1879  *  * if the frame is allowed on the LAN
1880  *
1881  * In these cases, the skb is further handled by this function
1882  *
1883  * Return: true if handled, otherwise it returns false and the caller shall
1884  * further process the skb.
1885  */
1886 bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1887                    unsigned short vid, int packet_type)
1888 {
1889         struct batadv_bla_backbone_gw *backbone_gw;
1890         struct ethhdr *ethhdr;
1891         struct batadv_bla_claim search_claim, *claim = NULL;
1892         struct batadv_hard_iface *primary_if;
1893         bool own_claim;
1894         bool ret;
1895
1896         ethhdr = eth_hdr(skb);
1897
1898         primary_if = batadv_primary_if_get_selected(bat_priv);
1899         if (!primary_if)
1900                 goto handled;
1901
1902         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1903                 goto allow;
1904
1905         if (batadv_bla_loopdetect_check(bat_priv, skb, primary_if, vid))
1906                 goto handled;
1907
1908         if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1909                 /* don't allow multicast packets while requests are in flight */
1910                 if (is_multicast_ether_addr(ethhdr->h_dest))
1911                         /* Both broadcast flooding or multicast-via-unicasts
1912                          * delivery might send to multiple backbone gateways
1913                          * sharing the same LAN and therefore need to coordinate
1914                          * which backbone gateway forwards into the LAN,
1915                          * by claiming the payload source address.
1916                          *
1917                          * Broadcast flooding and multicast-via-unicasts
1918                          * delivery use the following two batman packet types.
1919                          * Note: explicitly exclude BATADV_UNICAST_4ADDR,
1920                          * as the DHCP gateway feature will send explicitly
1921                          * to only one BLA gateway, so the claiming process
1922                          * should be avoided there.
1923                          */
1924                         if (packet_type == BATADV_BCAST ||
1925                             packet_type == BATADV_UNICAST)
1926                                 goto handled;
1927
1928         /* potential duplicates from foreign BLA backbone gateways via
1929          * multicast-in-unicast packets
1930          */
1931         if (is_multicast_ether_addr(ethhdr->h_dest) &&
1932             packet_type == BATADV_UNICAST &&
1933             batadv_bla_check_ucast_duplist(bat_priv, skb))
1934                 goto handled;
1935
1936         ether_addr_copy(search_claim.addr, ethhdr->h_source);
1937         search_claim.vid = vid;
1938         claim = batadv_claim_hash_find(bat_priv, &search_claim);
1939
1940         if (!claim) {
1941                 /* possible optimization: race for a claim */
1942                 /* No claim exists yet, claim it for us!
1943                  */
1944
1945                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1946                            "%s(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
1947                            __func__, ethhdr->h_source,
1948                            batadv_is_my_client(bat_priv,
1949                                                ethhdr->h_source, vid) ?
1950                            "yes" : "no");
1951                 batadv_handle_claim(bat_priv, primary_if,
1952                                     primary_if->net_dev->dev_addr,
1953                                     ethhdr->h_source, vid);
1954                 goto allow;
1955         }
1956
1957         /* if it is our own claim ... */
1958         backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
1959         own_claim = batadv_compare_eth(backbone_gw->orig,
1960                                        primary_if->net_dev->dev_addr);
1961         batadv_backbone_gw_put(backbone_gw);
1962
1963         if (own_claim) {
1964                 /* ... allow it in any case */
1965                 claim->lasttime = jiffies;
1966                 goto allow;
1967         }
1968
1969         /* if it is a multicast ... */
1970         if (is_multicast_ether_addr(ethhdr->h_dest) &&
1971             (packet_type == BATADV_BCAST || packet_type == BATADV_UNICAST)) {
1972                 /* ... drop it. the responsible gateway is in charge.
1973                  *
1974                  * We need to check packet type because with the gateway
1975                  * feature, broadcasts (like DHCP requests) may be sent
1976                  * using a unicast 4 address packet type. See comment above.
1977                  */
1978                 goto handled;
1979         } else {
1980                 /* seems the client considers us as its best gateway.
1981                  * send a claim and update the claim table
1982                  * immediately.
1983                  */
1984                 batadv_handle_claim(bat_priv, primary_if,
1985                                     primary_if->net_dev->dev_addr,
1986                                     ethhdr->h_source, vid);
1987                 goto allow;
1988         }
1989 allow:
1990         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1991         ret = false;
1992         goto out;
1993
1994 handled:
1995         kfree_skb(skb);
1996         ret = true;
1997
1998 out:
1999         if (primary_if)
2000                 batadv_hardif_put(primary_if);
2001         if (claim)
2002                 batadv_claim_put(claim);
2003         return ret;
2004 }
2005
2006 /**
2007  * batadv_bla_tx() - check packets going into the mesh
2008  * @bat_priv: the bat priv with all the soft interface information
2009  * @skb: the frame to be checked
2010  * @vid: the VLAN ID of the frame
2011  *
2012  * batadv_bla_tx checks if:
2013  *  * a claim was received which has to be processed
2014  *  * the frame is allowed on the mesh
2015  *
2016  * in these cases, the skb is further handled by this function.
2017  *
2018  * This call might reallocate skb data.
2019  *
2020  * Return: true if handled, otherwise it returns false and the caller shall
2021  * further process the skb.
2022  */
2023 bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
2024                    unsigned short vid)
2025 {
2026         struct ethhdr *ethhdr;
2027         struct batadv_bla_claim search_claim, *claim = NULL;
2028         struct batadv_bla_backbone_gw *backbone_gw;
2029         struct batadv_hard_iface *primary_if;
2030         bool client_roamed;
2031         bool ret = false;
2032
2033         primary_if = batadv_primary_if_get_selected(bat_priv);
2034         if (!primary_if)
2035                 goto out;
2036
2037         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2038                 goto allow;
2039
2040         if (batadv_bla_process_claim(bat_priv, primary_if, skb))
2041                 goto handled;
2042
2043         ethhdr = eth_hdr(skb);
2044
2045         if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
2046                 /* don't allow broadcasts while requests are in flight */
2047                 if (is_multicast_ether_addr(ethhdr->h_dest))
2048                         goto handled;
2049
2050         ether_addr_copy(search_claim.addr, ethhdr->h_source);
2051         search_claim.vid = vid;
2052
2053         claim = batadv_claim_hash_find(bat_priv, &search_claim);
2054
2055         /* if no claim exists, allow it. */
2056         if (!claim)
2057                 goto allow;
2058
2059         /* check if we are responsible. */
2060         backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
2061         client_roamed = batadv_compare_eth(backbone_gw->orig,
2062                                            primary_if->net_dev->dev_addr);
2063         batadv_backbone_gw_put(backbone_gw);
2064
2065         if (client_roamed) {
2066                 /* if yes, the client has roamed and we have
2067                  * to unclaim it.
2068                  */
2069                 if (batadv_has_timed_out(claim->lasttime, 100)) {
2070                         /* only unclaim if the last claim entry is
2071                          * older than 100 ms to make sure we really
2072                          * have a roaming client here.
2073                          */
2074                         batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Roaming client %pM detected. Unclaim it.\n",
2075                                    __func__, ethhdr->h_source);
2076                         batadv_handle_unclaim(bat_priv, primary_if,
2077                                               primary_if->net_dev->dev_addr,
2078                                               ethhdr->h_source, vid);
2079                         goto allow;
2080                 } else {
2081                         batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Race for claim %pM detected. Drop packet.\n",
2082                                    __func__, ethhdr->h_source);
2083                         goto handled;
2084                 }
2085         }
2086
2087         /* check if it is a multicast/broadcast frame */
2088         if (is_multicast_ether_addr(ethhdr->h_dest)) {
2089                 /* drop it. the responsible gateway has forwarded it into
2090                  * the backbone network.
2091                  */
2092                 goto handled;
2093         } else {
2094                 /* we must allow it. at least if we are
2095                  * responsible for the DESTINATION.
2096                  */
2097                 goto allow;
2098         }
2099 allow:
2100         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
2101         ret = false;
2102         goto out;
2103 handled:
2104         ret = true;
2105 out:
2106         if (primary_if)
2107                 batadv_hardif_put(primary_if);
2108         if (claim)
2109                 batadv_claim_put(claim);
2110         return ret;
2111 }
2112
2113 /**
2114  * batadv_bla_claim_dump_entry() - dump one entry of the claim table
2115  * to a netlink socket
2116  * @msg: buffer for the message
2117  * @portid: netlink port
2118  * @cb: Control block containing additional options
2119  * @primary_if: primary interface
2120  * @claim: entry to dump
2121  *
2122  * Return: 0 or error code.
2123  */
2124 static int
2125 batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid,
2126                             struct netlink_callback *cb,
2127                             struct batadv_hard_iface *primary_if,
2128                             struct batadv_bla_claim *claim)
2129 {
2130         u8 *primary_addr = primary_if->net_dev->dev_addr;
2131         u16 backbone_crc;
2132         bool is_own;
2133         void *hdr;
2134         int ret = -EINVAL;
2135
2136         hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2137                           &batadv_netlink_family, NLM_F_MULTI,
2138                           BATADV_CMD_GET_BLA_CLAIM);
2139         if (!hdr) {
2140                 ret = -ENOBUFS;
2141                 goto out;
2142         }
2143
2144         genl_dump_check_consistent(cb, hdr);
2145
2146         is_own = batadv_compare_eth(claim->backbone_gw->orig,
2147                                     primary_addr);
2148
2149         spin_lock_bh(&claim->backbone_gw->crc_lock);
2150         backbone_crc = claim->backbone_gw->crc;
2151         spin_unlock_bh(&claim->backbone_gw->crc_lock);
2152
2153         if (is_own)
2154                 if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2155                         genlmsg_cancel(msg, hdr);
2156                         goto out;
2157                 }
2158
2159         if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
2160             nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
2161             nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2162                     claim->backbone_gw->orig) ||
2163             nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2164                         backbone_crc)) {
2165                 genlmsg_cancel(msg, hdr);
2166                 goto out;
2167         }
2168
2169         genlmsg_end(msg, hdr);
2170         ret = 0;
2171
2172 out:
2173         return ret;
2174 }
2175
2176 /**
2177  * batadv_bla_claim_dump_bucket() - dump one bucket of the claim table
2178  * to a netlink socket
2179  * @msg: buffer for the message
2180  * @portid: netlink port
2181  * @cb: Control block containing additional options
2182  * @primary_if: primary interface
2183  * @hash: hash to dump
2184  * @bucket: bucket index to dump
2185  * @idx_skip: How many entries to skip
2186  *
2187  * Return: always 0.
2188  */
2189 static int
2190 batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid,
2191                              struct netlink_callback *cb,
2192                              struct batadv_hard_iface *primary_if,
2193                              struct batadv_hashtable *hash, unsigned int bucket,
2194                              int *idx_skip)
2195 {
2196         struct batadv_bla_claim *claim;
2197         int idx = 0;
2198         int ret = 0;
2199
2200         spin_lock_bh(&hash->list_locks[bucket]);
2201         cb->seq = atomic_read(&hash->generation) << 1 | 1;
2202
2203         hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {
2204                 if (idx++ < *idx_skip)
2205                         continue;
2206
2207                 ret = batadv_bla_claim_dump_entry(msg, portid, cb,
2208                                                   primary_if, claim);
2209                 if (ret) {
2210                         *idx_skip = idx - 1;
2211                         goto unlock;
2212                 }
2213         }
2214
2215         *idx_skip = 0;
2216 unlock:
2217         spin_unlock_bh(&hash->list_locks[bucket]);
2218         return ret;
2219 }
2220
2221 /**
2222  * batadv_bla_claim_dump() - dump claim table to a netlink socket
2223  * @msg: buffer for the message
2224  * @cb: callback structure containing arguments
2225  *
2226  * Return: message length.
2227  */
2228 int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
2229 {
2230         struct batadv_hard_iface *primary_if = NULL;
2231         int portid = NETLINK_CB(cb->skb).portid;
2232         struct net *net = sock_net(cb->skb->sk);
2233         struct net_device *soft_iface;
2234         struct batadv_hashtable *hash;
2235         struct batadv_priv *bat_priv;
2236         int bucket = cb->args[0];
2237         int idx = cb->args[1];
2238         int ifindex;
2239         int ret = 0;
2240
2241         ifindex = batadv_netlink_get_ifindex(cb->nlh,
2242                                              BATADV_ATTR_MESH_IFINDEX);
2243         if (!ifindex)
2244                 return -EINVAL;
2245
2246         soft_iface = dev_get_by_index(net, ifindex);
2247         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2248                 ret = -ENODEV;
2249                 goto out;
2250         }
2251
2252         bat_priv = netdev_priv(soft_iface);
2253         hash = bat_priv->bla.claim_hash;
2254
2255         primary_if = batadv_primary_if_get_selected(bat_priv);
2256         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2257                 ret = -ENOENT;
2258                 goto out;
2259         }
2260
2261         while (bucket < hash->size) {
2262                 if (batadv_bla_claim_dump_bucket(msg, portid, cb, primary_if,
2263                                                  hash, bucket, &idx))
2264                         break;
2265                 bucket++;
2266         }
2267
2268         cb->args[0] = bucket;
2269         cb->args[1] = idx;
2270
2271         ret = msg->len;
2272
2273 out:
2274         if (primary_if)
2275                 batadv_hardif_put(primary_if);
2276
2277         if (soft_iface)
2278                 dev_put(soft_iface);
2279
2280         return ret;
2281 }
2282
2283 /**
2284  * batadv_bla_backbone_dump_entry() - dump one entry of the backbone table to a
2285  *  netlink socket
2286  * @msg: buffer for the message
2287  * @portid: netlink port
2288  * @cb: Control block containing additional options
2289  * @primary_if: primary interface
2290  * @backbone_gw: entry to dump
2291  *
2292  * Return: 0 or error code.
2293  */
2294 static int
2295 batadv_bla_backbone_dump_entry(struct sk_buff *msg, u32 portid,
2296                                struct netlink_callback *cb,
2297                                struct batadv_hard_iface *primary_if,
2298                                struct batadv_bla_backbone_gw *backbone_gw)
2299 {
2300         u8 *primary_addr = primary_if->net_dev->dev_addr;
2301         u16 backbone_crc;
2302         bool is_own;
2303         int msecs;
2304         void *hdr;
2305         int ret = -EINVAL;
2306
2307         hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2308                           &batadv_netlink_family, NLM_F_MULTI,
2309                           BATADV_CMD_GET_BLA_BACKBONE);
2310         if (!hdr) {
2311                 ret = -ENOBUFS;
2312                 goto out;
2313         }
2314
2315         genl_dump_check_consistent(cb, hdr);
2316
2317         is_own = batadv_compare_eth(backbone_gw->orig, primary_addr);
2318
2319         spin_lock_bh(&backbone_gw->crc_lock);
2320         backbone_crc = backbone_gw->crc;
2321         spin_unlock_bh(&backbone_gw->crc_lock);
2322
2323         msecs = jiffies_to_msecs(jiffies - backbone_gw->lasttime);
2324
2325         if (is_own)
2326                 if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2327                         genlmsg_cancel(msg, hdr);
2328                         goto out;
2329                 }
2330
2331         if (nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2332                     backbone_gw->orig) ||
2333             nla_put_u16(msg, BATADV_ATTR_BLA_VID, backbone_gw->vid) ||
2334             nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2335                         backbone_crc) ||
2336             nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
2337                 genlmsg_cancel(msg, hdr);
2338                 goto out;
2339         }
2340
2341         genlmsg_end(msg, hdr);
2342         ret = 0;
2343
2344 out:
2345         return ret;
2346 }
2347
2348 /**
2349  * batadv_bla_backbone_dump_bucket() - dump one bucket of the backbone table to
2350  *  a netlink socket
2351  * @msg: buffer for the message
2352  * @portid: netlink port
2353  * @cb: Control block containing additional options
2354  * @primary_if: primary interface
2355  * @hash: hash to dump
2356  * @bucket: bucket index to dump
2357  * @idx_skip: How many entries to skip
2358  *
2359  * Return: always 0.
2360  */
2361 static int
2362 batadv_bla_backbone_dump_bucket(struct sk_buff *msg, u32 portid,
2363                                 struct netlink_callback *cb,
2364                                 struct batadv_hard_iface *primary_if,
2365                                 struct batadv_hashtable *hash,
2366                                 unsigned int bucket, int *idx_skip)
2367 {
2368         struct batadv_bla_backbone_gw *backbone_gw;
2369         int idx = 0;
2370         int ret = 0;
2371
2372         spin_lock_bh(&hash->list_locks[bucket]);
2373         cb->seq = atomic_read(&hash->generation) << 1 | 1;
2374
2375         hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {
2376                 if (idx++ < *idx_skip)
2377                         continue;
2378
2379                 ret = batadv_bla_backbone_dump_entry(msg, portid, cb,
2380                                                      primary_if, backbone_gw);
2381                 if (ret) {
2382                         *idx_skip = idx - 1;
2383                         goto unlock;
2384                 }
2385         }
2386
2387         *idx_skip = 0;
2388 unlock:
2389         spin_unlock_bh(&hash->list_locks[bucket]);
2390         return ret;
2391 }
2392
2393 /**
2394  * batadv_bla_backbone_dump() - dump backbone table to a netlink socket
2395  * @msg: buffer for the message
2396  * @cb: callback structure containing arguments
2397  *
2398  * Return: message length.
2399  */
2400 int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb)
2401 {
2402         struct batadv_hard_iface *primary_if = NULL;
2403         int portid = NETLINK_CB(cb->skb).portid;
2404         struct net *net = sock_net(cb->skb->sk);
2405         struct net_device *soft_iface;
2406         struct batadv_hashtable *hash;
2407         struct batadv_priv *bat_priv;
2408         int bucket = cb->args[0];
2409         int idx = cb->args[1];
2410         int ifindex;
2411         int ret = 0;
2412
2413         ifindex = batadv_netlink_get_ifindex(cb->nlh,
2414                                              BATADV_ATTR_MESH_IFINDEX);
2415         if (!ifindex)
2416                 return -EINVAL;
2417
2418         soft_iface = dev_get_by_index(net, ifindex);
2419         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2420                 ret = -ENODEV;
2421                 goto out;
2422         }
2423
2424         bat_priv = netdev_priv(soft_iface);
2425         hash = bat_priv->bla.backbone_hash;
2426
2427         primary_if = batadv_primary_if_get_selected(bat_priv);
2428         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2429                 ret = -ENOENT;
2430                 goto out;
2431         }
2432
2433         while (bucket < hash->size) {
2434                 if (batadv_bla_backbone_dump_bucket(msg, portid, cb, primary_if,
2435                                                     hash, bucket, &idx))
2436                         break;
2437                 bucket++;
2438         }
2439
2440         cb->args[0] = bucket;
2441         cb->args[1] = idx;
2442
2443         ret = msg->len;
2444
2445 out:
2446         if (primary_if)
2447                 batadv_hardif_put(primary_if);
2448
2449         if (soft_iface)
2450                 dev_put(soft_iface);
2451
2452         return ret;
2453 }
2454
2455 #ifdef CONFIG_BATMAN_ADV_DAT
2456 /**
2457  * batadv_bla_check_claim() - check if address is claimed
2458  *
2459  * @bat_priv: the bat priv with all the soft interface information
2460  * @addr: mac address of which the claim status is checked
2461  * @vid: the VLAN ID
2462  *
2463  * addr is checked if this address is claimed by the local device itself.
2464  *
2465  * Return: true if bla is disabled or the mac is claimed by the device,
2466  * false if the device addr is already claimed by another gateway
2467  */
2468 bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
2469                             u8 *addr, unsigned short vid)
2470 {
2471         struct batadv_bla_claim search_claim;
2472         struct batadv_bla_claim *claim = NULL;
2473         struct batadv_hard_iface *primary_if = NULL;
2474         bool ret = true;
2475
2476         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
2477                 return ret;
2478
2479         primary_if = batadv_primary_if_get_selected(bat_priv);
2480         if (!primary_if)
2481                 return ret;
2482
2483         /* First look if the mac address is claimed */
2484         ether_addr_copy(search_claim.addr, addr);
2485         search_claim.vid = vid;
2486
2487         claim = batadv_claim_hash_find(bat_priv, &search_claim);
2488
2489         /* If there is a claim and we are not owner of the claim,
2490          * return false.
2491          */
2492         if (claim) {
2493                 if (!batadv_compare_eth(claim->backbone_gw->orig,
2494                                         primary_if->net_dev->dev_addr))
2495                         ret = false;
2496                 batadv_claim_put(claim);
2497         }
2498
2499         batadv_hardif_put(primary_if);
2500         return ret;
2501 }
2502 #endif