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