net/batman-adv/bridge_loop_avoidance.c

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