net/batman-adv/translation-table.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2007-2018  B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner, Simon Wunderlich, Antonio Quartulli
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "translation-table.h"
  20 #include "main.h"
  21
  22 #include <linux/atomic.h>
  23 #include <linux/bitops.h>
  24 #include <linux/build_bug.h>
  25 #include <linux/byteorder/generic.h>
  26 #include <linux/cache.h>
  27 #include <linux/compiler.h>
  28 #include <linux/crc32c.h>
  29 #include <linux/errno.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/gfp.h>
  32 #include <linux/if_ether.h>
  33 #include <linux/init.h>
  34 #include <linux/jhash.h>
  35 #include <linux/jiffies.h>
  36 #include <linux/kernel.h>
  37 #include <linux/kref.h>
  38 #include <linux/list.h>
  39 #include <linux/lockdep.h>
  40 #include <linux/net.h>
  41 #include <linux/netdevice.h>
  42 #include <linux/netlink.h>
  43 #include <linux/rculist.h>
  44 #include <linux/rcupdate.h>
  45 #include <linux/seq_file.h>
  46 #include <linux/skbuff.h>
  47 #include <linux/slab.h>
  48 #include <linux/spinlock.h>
  49 #include <linux/stddef.h>
  50 #include <linux/string.h>
  51 #include <linux/workqueue.h>
  52 #include <net/genetlink.h>
  53 #include <net/netlink.h>
  54 #include <net/sock.h>
  55 #include <uapi/linux/batadv_packet.h>
  56 #include <uapi/linux/batman_adv.h>
  57
  58 #include "bridge_loop_avoidance.h"
  59 #include "hard-interface.h"
  60 #include "hash.h"
  61 #include "log.h"
  62 #include "netlink.h"
  63 #include "originator.h"
  64 #include "soft-interface.h"
  65 #include "tvlv.h"
  66
  67 static struct kmem_cache *batadv_tl_cache __read_mostly;
  68 static struct kmem_cache *batadv_tg_cache __read_mostly;
  69 static struct kmem_cache *batadv_tt_orig_cache __read_mostly;
  70 static struct kmem_cache *batadv_tt_change_cache __read_mostly;
  71 static struct kmem_cache *batadv_tt_req_cache __read_mostly;
  72 static struct kmem_cache *batadv_tt_roam_cache __read_mostly;
  73
  74 /* hash class keys */
  75 static struct lock_class_key batadv_tt_local_hash_lock_class_key;
  76 static struct lock_class_key batadv_tt_global_hash_lock_class_key;
  77
  78 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
  79                                  unsigned short vid,
  80                                  struct batadv_orig_node *orig_node);
  81 static void batadv_tt_purge(struct work_struct *work);
  82 static void
  83 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);
  84 static void batadv_tt_global_del(struct batadv_priv *bat_priv,
  85                                  struct batadv_orig_node *orig_node,
  86                                  const unsigned char *addr,
  87                                  unsigned short vid, const char *message,
  88                                  bool roaming);
  89
  90 /**
  91  * batadv_compare_tt() - check if two TT entries are the same
  92  * @node: the list element pointer of the first TT entry
  93  * @data2: pointer to the tt_common_entry of the second TT entry
  94  *
  95  * Compare the MAC address and the VLAN ID of the two TT entries and check if
  96  * they are the same TT client.
  97  * Return: true if the two TT clients are the same, false otherwise
  98  */
  99 static bool batadv_compare_tt(const struct hlist_node *node, const void *data2)
 100 {
 101         const void *data1 = container_of(node, struct batadv_tt_common_entry,
 102                                          hash_entry);
 103         const struct batadv_tt_common_entry *tt1 = data1;
 104         const struct batadv_tt_common_entry *tt2 = data2;
 105
 106         return (tt1->vid == tt2->vid) && batadv_compare_eth(data1, data2);
 107 }
 108
 109 /**
 110  * batadv_choose_tt() - return the index of the tt entry in the hash table
 111  * @data: pointer to the tt_common_entry object to map
 112  * @size: the size of the hash table
 113  *
 114  * Return: the hash index where the object represented by 'data' should be
 115  * stored at.
 116  */
 117 static inline u32 batadv_choose_tt(const void *data, u32 size)
 118 {
 119         struct batadv_tt_common_entry *tt;
 120         u32 hash = 0;
 121
 122         tt = (struct batadv_tt_common_entry *)data;
 123         hash = jhash(&tt->addr, ETH_ALEN, hash);
 124         hash = jhash(&tt->vid, sizeof(tt->vid), hash);
 125
 126         return hash % size;
 127 }
 128
 129 /**
 130  * batadv_tt_hash_find() - look for a client in the given hash table
 131  * @hash: the hash table to search
 132  * @addr: the mac address of the client to look for
 133  * @vid: VLAN identifier
 134  *
 135  * Return: a pointer to the tt_common struct belonging to the searched client if
 136  * found, NULL otherwise.
 137  */
 138 static struct batadv_tt_common_entry *
 139 batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,
 140                     unsigned short vid)
 141 {
 142         struct hlist_head *head;
 143         struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;
 144         u32 index;
 145
 146         if (!hash)
 147                 return NULL;
 148
 149         ether_addr_copy(to_search.addr, addr);
 150         to_search.vid = vid;
 151
 152         index = batadv_choose_tt(&to_search, hash->size);
 153         head = &hash->table[index];
 154
 155         rcu_read_lock();
 156         hlist_for_each_entry_rcu(tt, head, hash_entry) {
 157                 if (!batadv_compare_eth(tt, addr))
 158                         continue;
 159
 160                 if (tt->vid != vid)
 161                         continue;
 162
 163                 if (!kref_get_unless_zero(&tt->refcount))
 164                         continue;
 165
 166                 tt_tmp = tt;
 167                 break;
 168         }
 169         rcu_read_unlock();
 170
 171         return tt_tmp;
 172 }
 173
 174 /**
 175  * batadv_tt_local_hash_find() - search the local table for a given client
 176  * @bat_priv: the bat priv with all the soft interface information
 177  * @addr: the mac address of the client to look for
 178  * @vid: VLAN identifier
 179  *
 180  * Return: a pointer to the corresponding tt_local_entry struct if the client is
 181  * found, NULL otherwise.
 182  */
 183 static struct batadv_tt_local_entry *
 184 batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
 185                           unsigned short vid)
 186 {
 187         struct batadv_tt_common_entry *tt_common_entry;
 188         struct batadv_tt_local_entry *tt_local_entry = NULL;
 189
 190         tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
 191                                               vid);
 192         if (tt_common_entry)
 193                 tt_local_entry = container_of(tt_common_entry,
 194                                               struct batadv_tt_local_entry,
 195                                               common);
 196         return tt_local_entry;
 197 }
 198
 199 /**
 200  * batadv_tt_global_hash_find() - search the global table for a given client
 201  * @bat_priv: the bat priv with all the soft interface information
 202  * @addr: the mac address of the client to look for
 203  * @vid: VLAN identifier
 204  *
 205  * Return: a pointer to the corresponding tt_global_entry struct if the client
 206  * is found, NULL otherwise.
 207  */
 208 static struct batadv_tt_global_entry *
 209 batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
 210                            unsigned short vid)
 211 {
 212         struct batadv_tt_common_entry *tt_common_entry;
 213         struct batadv_tt_global_entry *tt_global_entry = NULL;
 214
 215         tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
 216                                               vid);
 217         if (tt_common_entry)
 218                 tt_global_entry = container_of(tt_common_entry,
 219                                                struct batadv_tt_global_entry,
 220                                                common);
 221         return tt_global_entry;
 222 }
 223
 224 /**
 225  * batadv_tt_local_entry_free_rcu() - free the tt_local_entry
 226  * @rcu: rcu pointer of the tt_local_entry
 227  */
 228 static void batadv_tt_local_entry_free_rcu(struct rcu_head *rcu)
 229 {
 230         struct batadv_tt_local_entry *tt_local_entry;
 231
 232         tt_local_entry = container_of(rcu, struct batadv_tt_local_entry,
 233                                       common.rcu);
 234
 235         kmem_cache_free(batadv_tl_cache, tt_local_entry);
 236 }
 237
 238 /**
 239  * batadv_tt_local_entry_release() - release tt_local_entry from lists and queue
 240  *  for free after rcu grace period
 241  * @ref: kref pointer of the nc_node
 242  */
 243 static void batadv_tt_local_entry_release(struct kref *ref)
 244 {
 245         struct batadv_tt_local_entry *tt_local_entry;
 246
 247         tt_local_entry = container_of(ref, struct batadv_tt_local_entry,
 248                                       common.refcount);
 249
 250         batadv_softif_vlan_put(tt_local_entry->vlan);
 251
 252         call_rcu(&tt_local_entry->common.rcu, batadv_tt_local_entry_free_rcu);
 253 }
 254
 255 /**
 256  * batadv_tt_local_entry_put() - decrement the tt_local_entry refcounter and
 257  *  possibly release it
 258  * @tt_local_entry: tt_local_entry to be free'd
 259  */
 260 static void
 261 batadv_tt_local_entry_put(struct batadv_tt_local_entry *tt_local_entry)
 262 {
 263         kref_put(&tt_local_entry->common.refcount,
 264                  batadv_tt_local_entry_release);
 265 }
 266
 267 /**
 268  * batadv_tt_global_entry_free_rcu() - free the tt_global_entry
 269  * @rcu: rcu pointer of the tt_global_entry
 270  */
 271 static void batadv_tt_global_entry_free_rcu(struct rcu_head *rcu)
 272 {
 273         struct batadv_tt_global_entry *tt_global_entry;
 274
 275         tt_global_entry = container_of(rcu, struct batadv_tt_global_entry,
 276                                        common.rcu);
 277
 278         kmem_cache_free(batadv_tg_cache, tt_global_entry);
 279 }
 280
 281 /**
 282  * batadv_tt_global_entry_release() - release tt_global_entry from lists and
 283  *  queue for free after rcu grace period
 284  * @ref: kref pointer of the nc_node
 285  */
 286 static void batadv_tt_global_entry_release(struct kref *ref)
 287 {
 288         struct batadv_tt_global_entry *tt_global_entry;
 289
 290         tt_global_entry = container_of(ref, struct batadv_tt_global_entry,
 291                                        common.refcount);
 292
 293         batadv_tt_global_del_orig_list(tt_global_entry);
 294
 295         call_rcu(&tt_global_entry->common.rcu, batadv_tt_global_entry_free_rcu);
 296 }
 297
 298 /**
 299  * batadv_tt_global_entry_put() - decrement the tt_global_entry refcounter and
 300  *  possibly release it
 301  * @tt_global_entry: tt_global_entry to be free'd
 302  */
 303 static void
 304 batadv_tt_global_entry_put(struct batadv_tt_global_entry *tt_global_entry)
 305 {
 306         kref_put(&tt_global_entry->common.refcount,
 307                  batadv_tt_global_entry_release);
 308 }
 309
 310 /**
 311  * batadv_tt_global_hash_count() - count the number of orig entries
 312  * @bat_priv: the bat priv with all the soft interface information
 313  * @addr: the mac address of the client to count entries for
 314  * @vid: VLAN identifier
 315  *
 316  * Return: the number of originators advertising the given address/data
 317  * (excluding ourself).
 318  */
 319 int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
 320                                 const u8 *addr, unsigned short vid)
 321 {
 322         struct batadv_tt_global_entry *tt_global_entry;
 323         int count;
 324
 325         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
 326         if (!tt_global_entry)
 327                 return 0;
 328
 329         count = atomic_read(&tt_global_entry->orig_list_count);
 330         batadv_tt_global_entry_put(tt_global_entry);
 331
 332         return count;
 333 }
 334
 335 /**
 336  * batadv_tt_local_size_mod() - change the size by v of the local table
 337  *  identified by vid
 338  * @bat_priv: the bat priv with all the soft interface information
 339  * @vid: the VLAN identifier of the sub-table to change
 340  * @v: the amount to sum to the local table size
 341  */
 342 static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,
 343                                      unsigned short vid, int v)
 344 {
 345         struct batadv_softif_vlan *vlan;
 346
 347         vlan = batadv_softif_vlan_get(bat_priv, vid);
 348         if (!vlan)
 349                 return;
 350
 351         atomic_add(v, &vlan->tt.num_entries);
 352
 353         batadv_softif_vlan_put(vlan);
 354 }
 355
 356 /**
 357  * batadv_tt_local_size_inc() - increase by one the local table size for the
 358  *  given vid
 359  * @bat_priv: the bat priv with all the soft interface information
 360  * @vid: the VLAN identifier
 361  */
 362 static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,
 363                                      unsigned short vid)
 364 {
 365         batadv_tt_local_size_mod(bat_priv, vid, 1);
 366 }
 367
 368 /**
 369  * batadv_tt_local_size_dec() - decrease by one the local table size for the
 370  *  given vid
 371  * @bat_priv: the bat priv with all the soft interface information
 372  * @vid: the VLAN identifier
 373  */
 374 static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,
 375                                      unsigned short vid)
 376 {
 377         batadv_tt_local_size_mod(bat_priv, vid, -1);
 378 }
 379
 380 /**
 381  * batadv_tt_global_size_mod() - change the size by v of the global table
 382  *  for orig_node identified by vid
 383  * @orig_node: the originator for which the table has to be modified
 384  * @vid: the VLAN identifier
 385  * @v: the amount to sum to the global table size
 386  */
 387 static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,
 388                                       unsigned short vid, int v)
 389 {
 390         struct batadv_orig_node_vlan *vlan;
 391
 392         vlan = batadv_orig_node_vlan_new(orig_node, vid);
 393         if (!vlan)
 394                 return;
 395
 396         if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {
 397                 spin_lock_bh(&orig_node->vlan_list_lock);
 398                 if (!hlist_unhashed(&vlan->list)) {
 399                         hlist_del_init_rcu(&vlan->list);
 400                         batadv_orig_node_vlan_put(vlan);
 401                 }
 402                 spin_unlock_bh(&orig_node->vlan_list_lock);
 403         }
 404
 405         batadv_orig_node_vlan_put(vlan);
 406 }
 407
 408 /**
 409  * batadv_tt_global_size_inc() - increase by one the global table size for the
 410  *  given vid
 411  * @orig_node: the originator which global table size has to be decreased
 412  * @vid: the vlan identifier
 413  */
 414 static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,
 415                                       unsigned short vid)
 416 {
 417         batadv_tt_global_size_mod(orig_node, vid, 1);
 418 }
 419
 420 /**
 421  * batadv_tt_global_size_dec() - decrease by one the global table size for the
 422  *  given vid
 423  * @orig_node: the originator which global table size has to be decreased
 424  * @vid: the vlan identifier
 425  */
 426 static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,
 427                                       unsigned short vid)
 428 {
 429         batadv_tt_global_size_mod(orig_node, vid, -1);
 430 }
 431
 432 /**
 433  * batadv_tt_orig_list_entry_free_rcu() - free the orig_entry
 434  * @rcu: rcu pointer of the orig_entry
 435  */
 436 static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
 437 {
 438         struct batadv_tt_orig_list_entry *orig_entry;
 439
 440         orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);
 441
 442         kmem_cache_free(batadv_tt_orig_cache, orig_entry);
 443 }
 444
 445 /**
 446  * batadv_tt_orig_list_entry_release() - release tt orig entry from lists and
 447  *  queue for free after rcu grace period
 448  * @ref: kref pointer of the tt orig entry
 449  */
 450 static void batadv_tt_orig_list_entry_release(struct kref *ref)
 451 {
 452         struct batadv_tt_orig_list_entry *orig_entry;
 453
 454         orig_entry = container_of(ref, struct batadv_tt_orig_list_entry,
 455                                   refcount);
 456
 457         batadv_orig_node_put(orig_entry->orig_node);
 458         call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);
 459 }
 460
 461 /**
 462  * batadv_tt_orig_list_entry_put() - decrement the tt orig entry refcounter and
 463  *  possibly release it
 464  * @orig_entry: tt orig entry to be free'd
 465  */
 466 static void
 467 batadv_tt_orig_list_entry_put(struct batadv_tt_orig_list_entry *orig_entry)
 468 {
 469         kref_put(&orig_entry->refcount, batadv_tt_orig_list_entry_release);
 470 }
 471
 472 /**
 473  * batadv_tt_local_event() - store a local TT event (ADD/DEL)
 474  * @bat_priv: the bat priv with all the soft interface information
 475  * @tt_local_entry: the TT entry involved in the event
 476  * @event_flags: flags to store in the event structure
 477  */
 478 static void batadv_tt_local_event(struct batadv_priv *bat_priv,
 479                                   struct batadv_tt_local_entry *tt_local_entry,
 480                                   u8 event_flags)
 481 {
 482         struct batadv_tt_change_node *tt_change_node, *entry, *safe;
 483         struct batadv_tt_common_entry *common = &tt_local_entry->common;
 484         u8 flags = common->flags | event_flags;
 485         bool event_removed = false;
 486         bool del_op_requested, del_op_entry;
 487
 488         tt_change_node = kmem_cache_alloc(batadv_tt_change_cache, GFP_ATOMIC);
 489         if (!tt_change_node)
 490                 return;
 491
 492         tt_change_node->change.flags = flags;
 493         memset(tt_change_node->change.reserved, 0,
 494                sizeof(tt_change_node->change.reserved));
 495         ether_addr_copy(tt_change_node->change.addr, common->addr);
 496         tt_change_node->change.vid = htons(common->vid);
 497
 498         del_op_requested = flags & BATADV_TT_CLIENT_DEL;
 499
 500         /* check for ADD+DEL or DEL+ADD events */
 501         spin_lock_bh(&bat_priv->tt.changes_list_lock);
 502         list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
 503                                  list) {
 504                 if (!batadv_compare_eth(entry->change.addr, common->addr))
 505                         continue;
 506
 507                 /* DEL+ADD in the same orig interval have no effect and can be
 508                  * removed to avoid silly behaviour on the receiver side. The
 509                  * other way around (ADD+DEL) can happen in case of roaming of
 510                  * a client still in the NEW state. Roaming of NEW clients is
 511                  * now possible due to automatically recognition of "temporary"
 512                  * clients
 513                  */
 514                 del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
 515                 if (!del_op_requested && del_op_entry)
 516                         goto del;
 517                 if (del_op_requested && !del_op_entry)
 518                         goto del;
 519
 520                 /* this is a second add in the same originator interval. It
 521                  * means that flags have been changed: update them!
 522                  */
 523                 if (!del_op_requested && !del_op_entry)
 524                         entry->change.flags = flags;
 525
 526                 continue;
 527 del:
 528                 list_del(&entry->list);
 529                 kmem_cache_free(batadv_tt_change_cache, entry);
 530                 kmem_cache_free(batadv_tt_change_cache, tt_change_node);
 531                 event_removed = true;
 532                 goto unlock;
 533         }
 534
 535         /* track the change in the OGMinterval list */
 536         list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);
 537
 538 unlock:
 539         spin_unlock_bh(&bat_priv->tt.changes_list_lock);
 540
 541         if (event_removed)
 542                 atomic_dec(&bat_priv->tt.local_changes);
 543         else
 544                 atomic_inc(&bat_priv->tt.local_changes);
 545 }
 546
 547 /**
 548  * batadv_tt_len() - compute length in bytes of given number of tt changes
 549  * @changes_num: number of tt changes
 550  *
 551  * Return: computed length in bytes.
 552  */
 553 static int batadv_tt_len(int changes_num)
 554 {
 555         return changes_num * sizeof(struct batadv_tvlv_tt_change);
 556 }
 557
 558 /**
 559  * batadv_tt_entries() - compute the number of entries fitting in tt_len bytes
 560  * @tt_len: available space
 561  *
 562  * Return: the number of entries.
 563  */
 564 static u16 batadv_tt_entries(u16 tt_len)
 565 {
 566         return tt_len / batadv_tt_len(1);
 567 }
 568
 569 /**
 570  * batadv_tt_local_table_transmit_size() - calculates the local translation
 571  *  table size when transmitted over the air
 572  * @bat_priv: the bat priv with all the soft interface information
 573  *
 574  * Return: local translation table size in bytes.
 575  */
 576 static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
 577 {
 578         u16 num_vlan = 0;
 579         u16 tt_local_entries = 0;
 580         struct batadv_softif_vlan *vlan;
 581         int hdr_size;
 582
 583         rcu_read_lock();
 584         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
 585                 num_vlan++;
 586                 tt_local_entries += atomic_read(&vlan->tt.num_entries);
 587         }
 588         rcu_read_unlock();
 589
 590         /* header size of tvlv encapsulated tt response payload */
 591         hdr_size = sizeof(struct batadv_unicast_tvlv_packet);
 592         hdr_size += sizeof(struct batadv_tvlv_hdr);
 593         hdr_size += sizeof(struct batadv_tvlv_tt_data);
 594         hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);
 595
 596         return hdr_size + batadv_tt_len(tt_local_entries);
 597 }
 598
 599 static int batadv_tt_local_init(struct batadv_priv *bat_priv)
 600 {
 601         if (bat_priv->tt.local_hash)
 602                 return 0;
 603
 604         bat_priv->tt.local_hash = batadv_hash_new(1024);
 605
 606         if (!bat_priv->tt.local_hash)
 607                 return -ENOMEM;
 608
 609         batadv_hash_set_lock_class(bat_priv->tt.local_hash,
 610                                    &batadv_tt_local_hash_lock_class_key);
 611
 612         return 0;
 613 }
 614
 615 static void batadv_tt_global_free(struct batadv_priv *bat_priv,
 616                                   struct batadv_tt_global_entry *tt_global,
 617                                   const char *message)
 618 {
 619         batadv_dbg(BATADV_DBG_TT, bat_priv,
 620                    "Deleting global tt entry %pM (vid: %d): %s\n",
 621                    tt_global->common.addr,
 622                    batadv_print_vid(tt_global->common.vid), message);
 623
 624         batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
 625                            batadv_choose_tt, &tt_global->common);
 626         batadv_tt_global_entry_put(tt_global);
 627 }
 628
 629 /**
 630  * batadv_tt_local_add() - add a new client to the local table or update an
 631  *  existing client
 632  * @soft_iface: netdev struct of the mesh interface
 633  * @addr: the mac address of the client to add
 634  * @vid: VLAN identifier
 635  * @ifindex: index of the interface where the client is connected to (useful to
 636  *  identify wireless clients)
 637  * @mark: the value contained in the skb->mark field of the received packet (if
 638  *  any)
 639  *
 640  * Return: true if the client was successfully added, false otherwise.
 641  */
 642 bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,
 643                          unsigned short vid, int ifindex, u32 mark)
 644 {
 645         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 646         struct batadv_tt_local_entry *tt_local;
 647         struct batadv_tt_global_entry *tt_global = NULL;
 648         struct net *net = dev_net(soft_iface);
 649         struct batadv_softif_vlan *vlan;
 650         struct net_device *in_dev = NULL;
 651         struct batadv_hard_iface *in_hardif = NULL;
 652         struct hlist_head *head;
 653         struct batadv_tt_orig_list_entry *orig_entry;
 654         int hash_added, table_size, packet_size_max;
 655         bool ret = false;
 656         bool roamed_back = false;
 657         u8 remote_flags;
 658         u32 match_mark;
 659
 660         if (ifindex != BATADV_NULL_IFINDEX)
 661                 in_dev = dev_get_by_index(net, ifindex);
 662
 663         if (in_dev)
 664                 in_hardif = batadv_hardif_get_by_netdev(in_dev);
 665
 666         tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);
 667
 668         if (!is_multicast_ether_addr(addr))
 669                 tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);
 670
 671         if (tt_local) {
 672                 tt_local->last_seen = jiffies;
 673                 if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
 674                         batadv_dbg(BATADV_DBG_TT, bat_priv,
 675                                    "Re-adding pending client %pM (vid: %d)\n",
 676                                    addr, batadv_print_vid(vid));
 677                         /* whatever the reason why the PENDING flag was set,
 678                          * this is a client which was enqueued to be removed in
 679                          * this orig_interval. Since it popped up again, the
 680                          * flag can be reset like it was never enqueued
 681                          */
 682                         tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;
 683                         goto add_event;
 684                 }
 685
 686                 if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {
 687                         batadv_dbg(BATADV_DBG_TT, bat_priv,
 688                                    "Roaming client %pM (vid: %d) came back to its original location\n",
 689                                    addr, batadv_print_vid(vid));
 690                         /* the ROAM flag is set because this client roamed away
 691                          * and the node got a roaming_advertisement message. Now
 692                          * that the client popped up again at its original
 693                          * location such flag can be unset
 694                          */
 695                         tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;
 696                         roamed_back = true;
 697                 }
 698                 goto check_roaming;
 699         }
 700
 701         /* Ignore the client if we cannot send it in a full table response. */
 702         table_size = batadv_tt_local_table_transmit_size(bat_priv);
 703         table_size += batadv_tt_len(1);
 704         packet_size_max = atomic_read(&bat_priv->packet_size_max);
 705         if (table_size > packet_size_max) {
 706                 net_ratelimited_function(batadv_info, soft_iface,
 707                                          "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",
 708                                          table_size, packet_size_max, addr);
 709                 goto out;
 710         }
 711
 712         tt_local = kmem_cache_alloc(batadv_tl_cache, GFP_ATOMIC);
 713         if (!tt_local)
 714                 goto out;
 715
 716         /* increase the refcounter of the related vlan */
 717         vlan = batadv_softif_vlan_get(bat_priv, vid);
 718         if (!vlan) {
 719                 net_ratelimited_function(batadv_info, soft_iface,
 720                                          "adding TT local entry %pM to non-existent VLAN %d\n",
 721                                          addr, batadv_print_vid(vid));
 722                 kmem_cache_free(batadv_tl_cache, tt_local);
 723                 tt_local = NULL;
 724                 goto out;
 725         }
 726
 727         batadv_dbg(BATADV_DBG_TT, bat_priv,
 728                    "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",
 729                    addr, batadv_print_vid(vid),
 730                    (u8)atomic_read(&bat_priv->tt.vn));
 731
 732         ether_addr_copy(tt_local->common.addr, addr);
 733         /* The local entry has to be marked as NEW to avoid to send it in
 734          * a full table response going out before the next ttvn increment
 735          * (consistency check)
 736          */
 737         tt_local->common.flags = BATADV_TT_CLIENT_NEW;
 738         tt_local->common.vid = vid;
 739         if (batadv_is_wifi_hardif(in_hardif))
 740                 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
 741         kref_init(&tt_local->common.refcount);
 742         tt_local->last_seen = jiffies;
 743         tt_local->common.added_at = tt_local->last_seen;
 744         tt_local->vlan = vlan;
 745
 746         /* the batman interface mac and multicast addresses should never be
 747          * purged
 748          */
 749         if (batadv_compare_eth(addr, soft_iface->dev_addr) ||
 750             is_multicast_ether_addr(addr))
 751                 tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;
 752
 753         kref_get(&tt_local->common.refcount);
 754         hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
 755                                      batadv_choose_tt, &tt_local->common,
 756                                      &tt_local->common.hash_entry);
 757
 758         if (unlikely(hash_added != 0)) {
 759                 /* remove the reference for the hash */
 760                 batadv_tt_local_entry_put(tt_local);
 761                 goto out;
 762         }
 763
 764 add_event:
 765         batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
 766
 767 check_roaming:
 768         /* Check whether it is a roaming, but don't do anything if the roaming
 769          * process has already been handled
 770          */
 771         if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {
 772                 /* These node are probably going to update their tt table */
 773                 head = &tt_global->orig_list;
 774                 rcu_read_lock();
 775                 hlist_for_each_entry_rcu(orig_entry, head, list) {
 776                         batadv_send_roam_adv(bat_priv, tt_global->common.addr,
 777                                              tt_global->common.vid,
 778                                              orig_entry->orig_node);
 779                 }
 780                 rcu_read_unlock();
 781                 if (roamed_back) {
 782                         batadv_tt_global_free(bat_priv, tt_global,
 783                                               "Roaming canceled");
 784                         tt_global = NULL;
 785                 } else {
 786                         /* The global entry has to be marked as ROAMING and
 787                          * has to be kept for consistency purpose
 788                          */
 789                         tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;
 790                         tt_global->roam_at = jiffies;
 791                 }
 792         }
 793
 794         /* store the current remote flags before altering them. This helps
 795          * understanding is flags are changing or not
 796          */
 797         remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;
 798
 799         if (batadv_is_wifi_hardif(in_hardif))
 800                 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
 801         else
 802                 tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;
 803
 804         /* check the mark in the skb: if it's equal to the configured
 805          * isolation_mark, it means the packet is coming from an isolated
 806          * non-mesh client
 807          */
 808         match_mark = (mark & bat_priv->isolation_mark_mask);
 809         if (bat_priv->isolation_mark_mask &&
 810             match_mark == bat_priv->isolation_mark)
 811                 tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;
 812         else
 813                 tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;
 814
 815         /* if any "dynamic" flag has been modified, resend an ADD event for this
 816          * entry so that all the nodes can get the new flags
 817          */
 818         if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))
 819                 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
 820
 821         ret = true;
 822 out:
 823         if (in_hardif)
 824                 batadv_hardif_put(in_hardif);
 825         if (in_dev)
 826                 dev_put(in_dev);
 827         if (tt_local)
 828                 batadv_tt_local_entry_put(tt_local);
 829         if (tt_global)
 830                 batadv_tt_global_entry_put(tt_global);
 831         return ret;
 832 }
 833
 834 /**
 835  * batadv_tt_prepare_tvlv_global_data() - prepare the TVLV TT header to send
 836  *  within a TT Response directed to another node
 837  * @orig_node: originator for which the TT data has to be prepared
 838  * @tt_data: uninitialised pointer to the address of the TVLV buffer
 839  * @tt_change: uninitialised pointer to the address of the area where the TT
 840  *  changed can be stored
 841  * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
 842  *  function reserves the amount of space needed to send the entire global TT
 843  *  table. In case of success the value is updated with the real amount of
 844  *  reserved bytes
 845  * Allocate the needed amount of memory for the entire TT TVLV and write its
 846  * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
 847  * objects, one per active VLAN served by the originator node.
 848  *
 849  * Return: the size of the allocated buffer or 0 in case of failure.
 850  */
 851 static u16
 852 batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,
 853                                    struct batadv_tvlv_tt_data **tt_data,
 854                                    struct batadv_tvlv_tt_change **tt_change,
 855                                    s32 *tt_len)
 856 {
 857         u16 num_vlan = 0;
 858         u16 num_entries = 0;
 859         u16 change_offset;
 860         u16 tvlv_len;
 861         struct batadv_tvlv_tt_vlan_data *tt_vlan;
 862         struct batadv_orig_node_vlan *vlan;
 863         u8 *tt_change_ptr;
 864
 865         spin_lock_bh(&orig_node->vlan_list_lock);
 866         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
 867                 num_vlan++;
 868                 num_entries += atomic_read(&vlan->tt.num_entries);
 869         }
 870
 871         change_offset = sizeof(**tt_data);
 872         change_offset += num_vlan * sizeof(*tt_vlan);
 873
 874         /* if tt_len is negative, allocate the space needed by the full table */
 875         if (*tt_len < 0)
 876                 *tt_len = batadv_tt_len(num_entries);
 877
 878         tvlv_len = *tt_len;
 879         tvlv_len += change_offset;
 880
 881         *tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
 882         if (!*tt_data) {
 883                 *tt_len = 0;
 884                 goto out;
 885         }
 886
 887         (*tt_data)->flags = BATADV_NO_FLAGS;
 888         (*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);
 889         (*tt_data)->num_vlan = htons(num_vlan);
 890
 891         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
 892         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
 893                 tt_vlan->vid = htons(vlan->vid);
 894                 tt_vlan->crc = htonl(vlan->tt.crc);
 895
 896                 tt_vlan++;
 897         }
 898
 899         tt_change_ptr = (u8 *)*tt_data + change_offset;
 900         *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
 901
 902 out:
 903         spin_unlock_bh(&orig_node->vlan_list_lock);
 904         return tvlv_len;
 905 }
 906
 907 /**
 908  * batadv_tt_prepare_tvlv_local_data() - allocate and prepare the TT TVLV for
 909  *  this node
 910  * @bat_priv: the bat priv with all the soft interface information
 911  * @tt_data: uninitialised pointer to the address of the TVLV buffer
 912  * @tt_change: uninitialised pointer to the address of the area where the TT
 913  *  changes can be stored
 914  * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
 915  *  function reserves the amount of space needed to send the entire local TT
 916  *  table. In case of success the value is updated with the real amount of
 917  *  reserved bytes
 918  *
 919  * Allocate the needed amount of memory for the entire TT TVLV and write its
 920  * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
 921  * objects, one per active VLAN.
 922  *
 923  * Return: the size of the allocated buffer or 0 in case of failure.
 924  */
 925 static u16
 926 batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,
 927                                   struct batadv_tvlv_tt_data **tt_data,
 928                                   struct batadv_tvlv_tt_change **tt_change,
 929                                   s32 *tt_len)
 930 {
 931         struct batadv_tvlv_tt_vlan_data *tt_vlan;
 932         struct batadv_softif_vlan *vlan;
 933         u16 num_vlan = 0;
 934         u16 vlan_entries = 0;
 935         u16 total_entries = 0;
 936         u16 tvlv_len;
 937         u8 *tt_change_ptr;
 938         int change_offset;
 939
 940         spin_lock_bh(&bat_priv->softif_vlan_list_lock);
 941         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
 942                 vlan_entries = atomic_read(&vlan->tt.num_entries);
 943                 if (vlan_entries < 1)
 944                         continue;
 945
 946                 num_vlan++;
 947                 total_entries += vlan_entries;
 948         }
 949
 950         change_offset = sizeof(**tt_data);
 951         change_offset += num_vlan * sizeof(*tt_vlan);
 952
 953         /* if tt_len is negative, allocate the space needed by the full table */
 954         if (*tt_len < 0)
 955                 *tt_len = batadv_tt_len(total_entries);
 956
 957         tvlv_len = *tt_len;
 958         tvlv_len += change_offset;
 959
 960         *tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
 961         if (!*tt_data) {
 962                 tvlv_len = 0;
 963                 goto out;
 964         }
 965
 966         (*tt_data)->flags = BATADV_NO_FLAGS;
 967         (*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);
 968         (*tt_data)->num_vlan = htons(num_vlan);
 969
 970         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
 971         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
 972                 vlan_entries = atomic_read(&vlan->tt.num_entries);
 973                 if (vlan_entries < 1)
 974                         continue;
 975
 976                 tt_vlan->vid = htons(vlan->vid);
 977                 tt_vlan->crc = htonl(vlan->tt.crc);
 978
 979                 tt_vlan++;
 980         }
 981
 982         tt_change_ptr = (u8 *)*tt_data + change_offset;
 983         *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
 984
 985 out:
 986         spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 987         return tvlv_len;
 988 }
 989
 990 /**
 991  * batadv_tt_tvlv_container_update() - update the translation table tvlv
 992  *  container after local tt changes have been committed
 993  * @bat_priv: the bat priv with all the soft interface information
 994  */
 995 static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)
 996 {
 997         struct batadv_tt_change_node *entry, *safe;
 998         struct batadv_tvlv_tt_data *tt_data;
 999         struct batadv_tvlv_tt_change *tt_change;
1000         int tt_diff_len, tt_change_len = 0;
1001         int tt_diff_entries_num = 0;
1002         int tt_diff_entries_count = 0;
1003         u16 tvlv_len;
1004
1005         tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
1006         tt_diff_len = batadv_tt_len(tt_diff_entries_num);
1007
1008         /* if we have too many changes for one packet don't send any
1009          * and wait for the tt table request which will be fragmented
1010          */
1011         if (tt_diff_len > bat_priv->soft_iface->mtu)
1012                 tt_diff_len = 0;
1013
1014         tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
1015                                                      &tt_change, &tt_diff_len);
1016         if (!tvlv_len)
1017                 return;
1018
1019         tt_data->flags = BATADV_TT_OGM_DIFF;
1020
1021         if (tt_diff_len == 0)
1022                 goto container_register;
1023
1024         spin_lock_bh(&bat_priv->tt.changes_list_lock);
1025         atomic_set(&bat_priv->tt.local_changes, 0);
1026
1027         list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1028                                  list) {
1029                 if (tt_diff_entries_count < tt_diff_entries_num) {
1030                         memcpy(tt_change + tt_diff_entries_count,
1031                                &entry->change,
1032                                sizeof(struct batadv_tvlv_tt_change));
1033                         tt_diff_entries_count++;
1034                 }
1035                 list_del(&entry->list);
1036                 kmem_cache_free(batadv_tt_change_cache, entry);
1037         }
1038         spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1039
1040         /* Keep the buffer for possible tt_request */
1041         spin_lock_bh(&bat_priv->tt.last_changeset_lock);
1042         kfree(bat_priv->tt.last_changeset);
1043         bat_priv->tt.last_changeset_len = 0;
1044         bat_priv->tt.last_changeset = NULL;
1045         tt_change_len = batadv_tt_len(tt_diff_entries_count);
1046         /* check whether this new OGM has no changes due to size problems */
1047         if (tt_diff_entries_count > 0) {
1048                 /* if kmalloc() fails we will reply with the full table
1049                  * instead of providing the diff
1050                  */
1051                 bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);
1052                 if (bat_priv->tt.last_changeset) {
1053                         memcpy(bat_priv->tt.last_changeset,
1054                                tt_change, tt_change_len);
1055                         bat_priv->tt.last_changeset_len = tt_diff_len;
1056                 }
1057         }
1058         spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
1059
1060 container_register:
1061         batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,
1062                                        tvlv_len);
1063         kfree(tt_data);
1064 }
1065
1066 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
1067
1068 /**
1069  * batadv_tt_local_seq_print_text() - Print the local tt table in a seq file
1070  * @seq: seq file to print on
1071  * @offset: not used
1072  *
1073  * Return: always 0
1074  */
1075 int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
1076 {
1077         struct net_device *net_dev = (struct net_device *)seq->private;
1078         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1079         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1080         struct batadv_tt_common_entry *tt_common_entry;
1081         struct batadv_tt_local_entry *tt_local;
1082         struct batadv_hard_iface *primary_if;
1083         struct hlist_head *head;
1084         u32 i;
1085         int last_seen_secs;
1086         int last_seen_msecs;
1087         unsigned long last_seen_jiffies;
1088         bool no_purge;
1089         u16 np_flag = BATADV_TT_CLIENT_NOPURGE;
1090
1091         primary_if = batadv_seq_print_text_primary_if_get(seq);
1092         if (!primary_if)
1093                 goto out;
1094
1095         seq_printf(seq,
1096                    "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
1097                    net_dev->name, (u8)atomic_read(&bat_priv->tt.vn));
1098         seq_puts(seq,
1099                  "       Client         VID Flags    Last seen (CRC       )\n");
1100
1101         for (i = 0; i < hash->size; i++) {
1102                 head = &hash->table[i];
1103
1104                 rcu_read_lock();
1105                 hlist_for_each_entry_rcu(tt_common_entry,
1106                                          head, hash_entry) {
1107                         tt_local = container_of(tt_common_entry,
1108                                                 struct batadv_tt_local_entry,
1109                                                 common);
1110                         last_seen_jiffies = jiffies - tt_local->last_seen;
1111                         last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
1112                         last_seen_secs = last_seen_msecs / 1000;
1113                         last_seen_msecs = last_seen_msecs % 1000;
1114
1115                         no_purge = tt_common_entry->flags & np_flag;
1116                         seq_printf(seq,
1117                                    " * %pM %4i [%c%c%c%c%c%c] %3u.%03u   (%#.8x)\n",
1118                                    tt_common_entry->addr,
1119                                    batadv_print_vid(tt_common_entry->vid),
1120                                    ((tt_common_entry->flags &
1121                                      BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
1122                                    no_purge ? 'P' : '.',
1123                                    ((tt_common_entry->flags &
1124                                      BATADV_TT_CLIENT_NEW) ? 'N' : '.'),
1125                                    ((tt_common_entry->flags &
1126                                      BATADV_TT_CLIENT_PENDING) ? 'X' : '.'),
1127                                    ((tt_common_entry->flags &
1128                                      BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
1129                                    ((tt_common_entry->flags &
1130                                      BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1131                                    no_purge ? 0 : last_seen_secs,
1132                                    no_purge ? 0 : last_seen_msecs,
1133                                    tt_local->vlan->tt.crc);
1134                 }
1135                 rcu_read_unlock();
1136         }
1137 out:
1138         if (primary_if)
1139                 batadv_hardif_put(primary_if);
1140         return 0;
1141 }
1142 #endif
1143
1144 /**
1145  * batadv_tt_local_dump_entry() - Dump one TT local entry into a message
1146  * @msg :Netlink message to dump into
1147  * @portid: Port making netlink request
1148  * @seq: Sequence number of netlink message
1149  * @bat_priv: The bat priv with all the soft interface information
1150  * @common: tt local & tt global common data
1151  *
1152  * Return: Error code, or 0 on success
1153  */
1154 static int
1155 batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
1156                            struct batadv_priv *bat_priv,
1157                            struct batadv_tt_common_entry *common)
1158 {
1159         void *hdr;
1160         struct batadv_softif_vlan *vlan;
1161         struct batadv_tt_local_entry *local;
1162         unsigned int last_seen_msecs;
1163         u32 crc;
1164
1165         local = container_of(common, struct batadv_tt_local_entry, common);
1166         last_seen_msecs = jiffies_to_msecs(jiffies - local->last_seen);
1167
1168         vlan = batadv_softif_vlan_get(bat_priv, common->vid);
1169         if (!vlan)
1170                 return 0;
1171
1172         crc = vlan->tt.crc;
1173
1174         batadv_softif_vlan_put(vlan);
1175
1176         hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
1177                           NLM_F_MULTI,
1178                           BATADV_CMD_GET_TRANSTABLE_LOCAL);
1179         if (!hdr)
1180                 return -ENOBUFS;
1181
1182         if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) ||
1183             nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
1184             nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) ||
1185             nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, common->flags))
1186                 goto nla_put_failure;
1187
1188         if (!(common->flags & BATADV_TT_CLIENT_NOPURGE) &&
1189             nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, last_seen_msecs))
1190                 goto nla_put_failure;
1191
1192         genlmsg_end(msg, hdr);
1193         return 0;
1194
1195  nla_put_failure:
1196         genlmsg_cancel(msg, hdr);
1197         return -EMSGSIZE;
1198 }
1199
1200 /**
1201  * batadv_tt_local_dump_bucket() - Dump one TT local bucket into a message
1202  * @msg: Netlink message to dump into
1203  * @portid: Port making netlink request
1204  * @seq: Sequence number of netlink message
1205  * @bat_priv: The bat priv with all the soft interface information
1206  * @head: Pointer to the list containing the local tt entries
1207  * @idx_s: Number of entries to skip
1208  *
1209  * Return: Error code, or 0 on success
1210  */
1211 static int
1212 batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
1213                             struct batadv_priv *bat_priv,
1214                             struct hlist_head *head, int *idx_s)
1215 {
1216         struct batadv_tt_common_entry *common;
1217         int idx = 0;
1218
1219         rcu_read_lock();
1220         hlist_for_each_entry_rcu(common, head, hash_entry) {
1221                 if (idx++ < *idx_s)
1222                         continue;
1223
1224                 if (batadv_tt_local_dump_entry(msg, portid, seq, bat_priv,
1225                                                common)) {
1226                         rcu_read_unlock();
1227                         *idx_s = idx - 1;
1228                         return -EMSGSIZE;
1229                 }
1230         }
1231         rcu_read_unlock();
1232
1233         *idx_s = 0;
1234         return 0;
1235 }
1236
1237 /**
1238  * batadv_tt_local_dump() - Dump TT local entries into a message
1239  * @msg: Netlink message to dump into
1240  * @cb: Parameters from query
1241  *
1242  * Return: Error code, or 0 on success
1243  */
1244 int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb)
1245 {
1246         struct net *net = sock_net(cb->skb->sk);
1247         struct net_device *soft_iface;
1248         struct batadv_priv *bat_priv;
1249         struct batadv_hard_iface *primary_if = NULL;
1250         struct batadv_hashtable *hash;
1251         struct hlist_head *head;
1252         int ret;
1253         int ifindex;
1254         int bucket = cb->args[0];
1255         int idx = cb->args[1];
1256         int portid = NETLINK_CB(cb->skb).portid;
1257
1258         ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
1259         if (!ifindex)
1260                 return -EINVAL;
1261
1262         soft_iface = dev_get_by_index(net, ifindex);
1263         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1264                 ret = -ENODEV;
1265                 goto out;
1266         }
1267
1268         bat_priv = netdev_priv(soft_iface);
1269
1270         primary_if = batadv_primary_if_get_selected(bat_priv);
1271         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
1272                 ret = -ENOENT;
1273                 goto out;
1274         }
1275
1276         hash = bat_priv->tt.local_hash;
1277
1278         while (bucket < hash->size) {
1279                 head = &hash->table[bucket];
1280
1281                 if (batadv_tt_local_dump_bucket(msg, portid, cb->nlh->nlmsg_seq,
1282                                                 bat_priv, head, &idx))
1283                         break;
1284
1285                 bucket++;
1286         }
1287
1288         ret = msg->len;
1289
1290  out:
1291         if (primary_if)
1292                 batadv_hardif_put(primary_if);
1293         if (soft_iface)
1294                 dev_put(soft_iface);
1295
1296         cb->args[0] = bucket;
1297         cb->args[1] = idx;
1298
1299         return ret;
1300 }
1301
1302 static void
1303 batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
1304                             struct batadv_tt_local_entry *tt_local_entry,
1305                             u16 flags, const char *message)
1306 {
1307         batadv_tt_local_event(bat_priv, tt_local_entry, flags);
1308
1309         /* The local client has to be marked as "pending to be removed" but has
1310          * to be kept in the table in order to send it in a full table
1311          * response issued before the net ttvn increment (consistency check)
1312          */
1313         tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
1314
1315         batadv_dbg(BATADV_DBG_TT, bat_priv,
1316                    "Local tt entry (%pM, vid: %d) pending to be removed: %s\n",
1317                    tt_local_entry->common.addr,
1318                    batadv_print_vid(tt_local_entry->common.vid), message);
1319 }
1320
1321 /**
1322  * batadv_tt_local_remove() - logically remove an entry from the local table
1323  * @bat_priv: the bat priv with all the soft interface information
1324  * @addr: the MAC address of the client to remove
1325  * @vid: VLAN identifier
1326  * @message: message to append to the log on deletion
1327  * @roaming: true if the deletion is due to a roaming event
1328  *
1329  * Return: the flags assigned to the local entry before being deleted
1330  */
1331 u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,
1332                            unsigned short vid, const char *message,
1333                            bool roaming)
1334 {
1335         struct batadv_tt_local_entry *tt_local_entry;
1336         u16 flags, curr_flags = BATADV_NO_FLAGS;
1337         void *tt_entry_exists;
1338
1339         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
1340         if (!tt_local_entry)
1341                 goto out;
1342
1343         curr_flags = tt_local_entry->common.flags;
1344
1345         flags = BATADV_TT_CLIENT_DEL;
1346         /* if this global entry addition is due to a roaming, the node has to
1347          * mark the local entry as "roamed" in order to correctly reroute
1348          * packets later
1349          */
1350         if (roaming) {
1351                 flags |= BATADV_TT_CLIENT_ROAM;
1352                 /* mark the local client as ROAMed */
1353                 tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1354         }
1355
1356         if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {
1357                 batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,
1358                                             message);
1359                 goto out;
1360         }
1361         /* if this client has been added right now, it is possible to
1362          * immediately purge it
1363          */
1364         batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
1365
1366         tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash,
1367                                              batadv_compare_tt,
1368                                              batadv_choose_tt,
1369                                              &tt_local_entry->common);
1370         if (!tt_entry_exists)
1371                 goto out;
1372
1373         /* extra call to free the local tt entry */
1374         batadv_tt_local_entry_put(tt_local_entry);
1375
1376 out:
1377         if (tt_local_entry)
1378                 batadv_tt_local_entry_put(tt_local_entry);
1379
1380         return curr_flags;
1381 }
1382
1383 /**
1384  * batadv_tt_local_purge_list() - purge inactive tt local entries
1385  * @bat_priv: the bat priv with all the soft interface information
1386  * @head: pointer to the list containing the local tt entries
1387  * @timeout: parameter deciding whether a given tt local entry is considered
1388  *  inactive or not
1389  */
1390 static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
1391                                        struct hlist_head *head,
1392                                        int timeout)
1393 {
1394         struct batadv_tt_local_entry *tt_local_entry;
1395         struct batadv_tt_common_entry *tt_common_entry;
1396         struct hlist_node *node_tmp;
1397
1398         hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
1399                                   hash_entry) {
1400                 tt_local_entry = container_of(tt_common_entry,
1401                                               struct batadv_tt_local_entry,
1402                                               common);
1403                 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
1404                         continue;
1405
1406                 /* entry already marked for deletion */
1407                 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
1408                         continue;
1409
1410                 if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))
1411                         continue;
1412
1413                 batadv_tt_local_set_pending(bat_priv, tt_local_entry,
1414                                             BATADV_TT_CLIENT_DEL, "timed out");
1415         }
1416 }
1417
1418 /**
1419  * batadv_tt_local_purge() - purge inactive tt local entries
1420  * @bat_priv: the bat priv with all the soft interface information
1421  * @timeout: parameter deciding whether a given tt local entry is considered
1422  *  inactive or not
1423  */
1424 static void batadv_tt_local_purge(struct batadv_priv *bat_priv,
1425                                   int timeout)
1426 {
1427         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1428         struct hlist_head *head;
1429         spinlock_t *list_lock; /* protects write access to the hash lists */
1430         u32 i;
1431
1432         for (i = 0; i < hash->size; i++) {
1433                 head = &hash->table[i];
1434                 list_lock = &hash->list_locks[i];
1435
1436                 spin_lock_bh(list_lock);
1437                 batadv_tt_local_purge_list(bat_priv, head, timeout);
1438                 spin_unlock_bh(list_lock);
1439         }
1440 }
1441
1442 static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
1443 {
1444         struct batadv_hashtable *hash;
1445         spinlock_t *list_lock; /* protects write access to the hash lists */
1446         struct batadv_tt_common_entry *tt_common_entry;
1447         struct batadv_tt_local_entry *tt_local;
1448         struct hlist_node *node_tmp;
1449         struct hlist_head *head;
1450         u32 i;
1451
1452         if (!bat_priv->tt.local_hash)
1453                 return;
1454
1455         hash = bat_priv->tt.local_hash;
1456
1457         for (i = 0; i < hash->size; i++) {
1458                 head = &hash->table[i];
1459                 list_lock = &hash->list_locks[i];
1460
1461                 spin_lock_bh(list_lock);
1462                 hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1463                                           head, hash_entry) {
1464                         hlist_del_rcu(&tt_common_entry->hash_entry);
1465                         tt_local = container_of(tt_common_entry,
1466                                                 struct batadv_tt_local_entry,
1467                                                 common);
1468
1469                         batadv_tt_local_entry_put(tt_local);
1470                 }
1471                 spin_unlock_bh(list_lock);
1472         }
1473
1474         batadv_hash_destroy(hash);
1475
1476         bat_priv->tt.local_hash = NULL;
1477 }
1478
1479 static int batadv_tt_global_init(struct batadv_priv *bat_priv)
1480 {
1481         if (bat_priv->tt.global_hash)
1482                 return 0;
1483
1484         bat_priv->tt.global_hash = batadv_hash_new(1024);
1485
1486         if (!bat_priv->tt.global_hash)
1487                 return -ENOMEM;
1488
1489         batadv_hash_set_lock_class(bat_priv->tt.global_hash,
1490                                    &batadv_tt_global_hash_lock_class_key);
1491
1492         return 0;
1493 }
1494
1495 static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
1496 {
1497         struct batadv_tt_change_node *entry, *safe;
1498
1499         spin_lock_bh(&bat_priv->tt.changes_list_lock);
1500
1501         list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1502                                  list) {
1503                 list_del(&entry->list);
1504                 kmem_cache_free(batadv_tt_change_cache, entry);
1505         }
1506
1507         atomic_set(&bat_priv->tt.local_changes, 0);
1508         spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1509 }
1510
1511 /**
1512  * batadv_tt_global_orig_entry_find() - find a TT orig_list_entry
1513  * @entry: the TT global entry where the orig_list_entry has to be
1514  *  extracted from
1515  * @orig_node: the originator for which the orig_list_entry has to be found
1516  *
1517  * retrieve the orig_tt_list_entry belonging to orig_node from the
1518  * batadv_tt_global_entry list
1519  *
1520  * Return: it with an increased refcounter, NULL if not found
1521  */
1522 static struct batadv_tt_orig_list_entry *
1523 batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
1524                                  const struct batadv_orig_node *orig_node)
1525 {
1526         struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
1527         const struct hlist_head *head;
1528
1529         rcu_read_lock();
1530         head = &entry->orig_list;
1531         hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
1532                 if (tmp_orig_entry->orig_node != orig_node)
1533                         continue;
1534                 if (!kref_get_unless_zero(&tmp_orig_entry->refcount))
1535                         continue;
1536
1537                 orig_entry = tmp_orig_entry;
1538                 break;
1539         }
1540         rcu_read_unlock();
1541
1542         return orig_entry;
1543 }
1544
1545 /**
1546  * batadv_tt_global_entry_has_orig() - check if a TT global entry is also
1547  *  handled by a given originator
1548  * @entry: the TT global entry to check
1549  * @orig_node: the originator to search in the list
1550  * @flags: a pointer to store TT flags for the given @entry received
1551  *  from @orig_node
1552  *
1553  * find out if an orig_node is already in the list of a tt_global_entry.
1554  *
1555  * Return: true if found, false otherwise
1556  */
1557 static bool
1558 batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
1559                                 const struct batadv_orig_node *orig_node,
1560                                 u8 *flags)
1561 {
1562         struct batadv_tt_orig_list_entry *orig_entry;
1563         bool found = false;
1564
1565         orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);
1566         if (orig_entry) {
1567                 found = true;
1568
1569                 if (flags)
1570                         *flags = orig_entry->flags;
1571
1572                 batadv_tt_orig_list_entry_put(orig_entry);
1573         }
1574
1575         return found;
1576 }
1577
1578 /**
1579  * batadv_tt_global_sync_flags() - update TT sync flags
1580  * @tt_global: the TT global entry to update sync flags in
1581  *
1582  * Updates the sync flag bits in the tt_global flag attribute with a logical
1583  * OR of all sync flags from any of its TT orig entries.
1584  */
1585 static void
1586 batadv_tt_global_sync_flags(struct batadv_tt_global_entry *tt_global)
1587 {
1588         struct batadv_tt_orig_list_entry *orig_entry;
1589         const struct hlist_head *head;
1590         u16 flags = BATADV_NO_FLAGS;
1591
1592         rcu_read_lock();
1593         head = &tt_global->orig_list;
1594         hlist_for_each_entry_rcu(orig_entry, head, list)
1595                 flags |= orig_entry->flags;
1596         rcu_read_unlock();
1597
1598         flags |= tt_global->common.flags & (~BATADV_TT_SYNC_MASK);
1599         tt_global->common.flags = flags;
1600 }
1601
1602 /**
1603  * batadv_tt_global_orig_entry_add() - add or update a TT orig entry
1604  * @tt_global: the TT global entry to add an orig entry in
1605  * @orig_node: the originator to add an orig entry for
1606  * @ttvn: translation table version number of this changeset
1607  * @flags: TT sync flags
1608  */
1609 static void
1610 batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
1611                                 struct batadv_orig_node *orig_node, int ttvn,
1612                                 u8 flags)
1613 {
1614         struct batadv_tt_orig_list_entry *orig_entry;
1615
1616         spin_lock_bh(&tt_global->list_lock);
1617
1618         orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);
1619         if (orig_entry) {
1620                 /* refresh the ttvn: the current value could be a bogus one that
1621                  * was added during a "temporary client detection"
1622                  */
1623                 orig_entry->ttvn = ttvn;
1624                 orig_entry->flags = flags;
1625                 goto sync_flags;
1626         }
1627
1628         orig_entry = kmem_cache_zalloc(batadv_tt_orig_cache, GFP_ATOMIC);
1629         if (!orig_entry)
1630                 goto out;
1631
1632         INIT_HLIST_NODE(&orig_entry->list);
1633         kref_get(&orig_node->refcount);
1634         batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
1635         orig_entry->orig_node = orig_node;
1636         orig_entry->ttvn = ttvn;
1637         orig_entry->flags = flags;
1638         kref_init(&orig_entry->refcount);
1639
1640         kref_get(&orig_entry->refcount);
1641         hlist_add_head_rcu(&orig_entry->list,
1642                            &tt_global->orig_list);
1643         atomic_inc(&tt_global->orig_list_count);
1644
1645 sync_flags:
1646         batadv_tt_global_sync_flags(tt_global);
1647 out:
1648         if (orig_entry)
1649                 batadv_tt_orig_list_entry_put(orig_entry);
1650
1651         spin_unlock_bh(&tt_global->list_lock);
1652 }
1653
1654 /**
1655  * batadv_tt_global_add() - add a new TT global entry or update an existing one
1656  * @bat_priv: the bat priv with all the soft interface information
1657  * @orig_node: the originator announcing the client
1658  * @tt_addr: the mac address of the non-mesh client
1659  * @vid: VLAN identifier
1660  * @flags: TT flags that have to be set for this non-mesh client
1661  * @ttvn: the tt version number ever announcing this non-mesh client
1662  *
1663  * Add a new TT global entry for the given originator. If the entry already
1664  * exists add a new reference to the given originator (a global entry can have
1665  * references to multiple originators) and adjust the flags attribute to reflect
1666  * the function argument.
1667  * If a TT local entry exists for this non-mesh client remove it.
1668  *
1669  * The caller must hold orig_node refcount.
1670  *
1671  * Return: true if the new entry has been added, false otherwise
1672  */
1673 static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
1674                                  struct batadv_orig_node *orig_node,
1675                                  const unsigned char *tt_addr,
1676                                  unsigned short vid, u16 flags, u8 ttvn)
1677 {
1678         struct batadv_tt_global_entry *tt_global_entry;
1679         struct batadv_tt_local_entry *tt_local_entry;
1680         bool ret = false;
1681         int hash_added;
1682         struct batadv_tt_common_entry *common;
1683         u16 local_flags;
1684
1685         /* ignore global entries from backbone nodes */
1686         if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
1687                 return true;
1688
1689         tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);
1690         tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);
1691
1692         /* if the node already has a local client for this entry, it has to wait
1693          * for a roaming advertisement instead of manually messing up the global
1694          * table
1695          */
1696         if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&
1697             !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))
1698                 goto out;
1699
1700         if (!tt_global_entry) {
1701                 tt_global_entry = kmem_cache_zalloc(batadv_tg_cache,
1702                                                     GFP_ATOMIC);
1703                 if (!tt_global_entry)
1704                         goto out;
1705
1706                 common = &tt_global_entry->common;
1707                 ether_addr_copy(common->addr, tt_addr);
1708                 common->vid = vid;
1709
1710                 if (!is_multicast_ether_addr(common->addr))
1711                         common->flags = flags & (~BATADV_TT_SYNC_MASK);
1712
1713                 tt_global_entry->roam_at = 0;
1714                 /* node must store current time in case of roaming. This is
1715                  * needed to purge this entry out on timeout (if nobody claims
1716                  * it)
1717                  */
1718                 if (flags & BATADV_TT_CLIENT_ROAM)
1719                         tt_global_entry->roam_at = jiffies;
1720                 kref_init(&common->refcount);
1721                 common->added_at = jiffies;
1722
1723                 INIT_HLIST_HEAD(&tt_global_entry->orig_list);
1724                 atomic_set(&tt_global_entry->orig_list_count, 0);
1725                 spin_lock_init(&tt_global_entry->list_lock);
1726
1727                 kref_get(&common->refcount);
1728                 hash_added = batadv_hash_add(bat_priv->tt.global_hash,
1729                                              batadv_compare_tt,
1730                                              batadv_choose_tt, common,
1731                                              &common->hash_entry);
1732
1733                 if (unlikely(hash_added != 0)) {
1734                         /* remove the reference for the hash */
1735                         batadv_tt_global_entry_put(tt_global_entry);
1736                         goto out_remove;
1737                 }
1738         } else {
1739                 common = &tt_global_entry->common;
1740                 /* If there is already a global entry, we can use this one for
1741                  * our processing.
1742                  * But if we are trying to add a temporary client then here are
1743                  * two options at this point:
1744                  * 1) the global client is not a temporary client: the global
1745                  *    client has to be left as it is, temporary information
1746                  *    should never override any already known client state
1747                  * 2) the global client is a temporary client: purge the
1748                  *    originator list and add the new one orig_entry
1749                  */
1750                 if (flags & BATADV_TT_CLIENT_TEMP) {
1751                         if (!(common->flags & BATADV_TT_CLIENT_TEMP))
1752                                 goto out;
1753                         if (batadv_tt_global_entry_has_orig(tt_global_entry,
1754                                                             orig_node, NULL))
1755                                 goto out_remove;
1756                         batadv_tt_global_del_orig_list(tt_global_entry);
1757                         goto add_orig_entry;
1758                 }
1759
1760                 /* if the client was temporary added before receiving the first
1761                  * OGM announcing it, we have to clear the TEMP flag. Also,
1762                  * remove the previous temporary orig node and re-add it
1763                  * if required. If the orig entry changed, the new one which
1764                  * is a non-temporary entry is preferred.
1765                  */
1766                 if (common->flags & BATADV_TT_CLIENT_TEMP) {
1767                         batadv_tt_global_del_orig_list(tt_global_entry);
1768                         common->flags &= ~BATADV_TT_CLIENT_TEMP;
1769                 }
1770
1771                 /* the change can carry possible "attribute" flags like the
1772                  * TT_CLIENT_TEMP, therefore they have to be copied in the
1773                  * client entry
1774                  */
1775                 if (!is_multicast_ether_addr(common->addr))
1776                         common->flags |= flags & (~BATADV_TT_SYNC_MASK);
1777
1778                 /* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
1779                  * one originator left in the list and we previously received a
1780                  * delete + roaming change for this originator.
1781                  *
1782                  * We should first delete the old originator before adding the
1783                  * new one.
1784                  */
1785                 if (common->flags & BATADV_TT_CLIENT_ROAM) {
1786                         batadv_tt_global_del_orig_list(tt_global_entry);
1787                         common->flags &= ~BATADV_TT_CLIENT_ROAM;
1788                         tt_global_entry->roam_at = 0;
1789                 }
1790         }
1791 add_orig_entry:
1792         /* add the new orig_entry (if needed) or update it */
1793         batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn,
1794                                         flags & BATADV_TT_SYNC_MASK);
1795
1796         batadv_dbg(BATADV_DBG_TT, bat_priv,
1797                    "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
1798                    common->addr, batadv_print_vid(common->vid),
1799                    orig_node->orig);
1800         ret = true;
1801
1802 out_remove:
1803         /* Do not remove multicast addresses from the local hash on
1804          * global additions
1805          */
1806         if (is_multicast_ether_addr(tt_addr))
1807                 goto out;
1808
1809         /* remove address from local hash if present */
1810         local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,
1811                                              "global tt received",
1812                                              flags & BATADV_TT_CLIENT_ROAM);
1813         tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;
1814
1815         if (!(flags & BATADV_TT_CLIENT_ROAM))
1816                 /* this is a normal global add. Therefore the client is not in a
1817                  * roaming state anymore.
1818                  */
1819                 tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
1820
1821 out:
1822         if (tt_global_entry)
1823                 batadv_tt_global_entry_put(tt_global_entry);
1824         if (tt_local_entry)
1825                 batadv_tt_local_entry_put(tt_local_entry);
1826         return ret;
1827 }
1828
1829 /**
1830  * batadv_transtable_best_orig() - Get best originator list entry from tt entry
1831  * @bat_priv: the bat priv with all the soft interface information
1832  * @tt_global_entry: global translation table entry to be analyzed
1833  *
1834  * This functon assumes the caller holds rcu_read_lock().
1835  * Return: best originator list entry or NULL on errors.
1836  */
1837 static struct batadv_tt_orig_list_entry *
1838 batadv_transtable_best_orig(struct batadv_priv *bat_priv,
1839                             struct batadv_tt_global_entry *tt_global_entry)
1840 {
1841         struct batadv_neigh_node *router, *best_router = NULL;
1842         struct batadv_algo_ops *bao = bat_priv->algo_ops;
1843         struct hlist_head *head;
1844         struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;
1845
1846         head = &tt_global_entry->orig_list;
1847         hlist_for_each_entry_rcu(orig_entry, head, list) {
1848                 router = batadv_orig_router_get(orig_entry->orig_node,
1849                                                 BATADV_IF_DEFAULT);
1850                 if (!router)
1851                         continue;
1852
1853                 if (best_router &&
1854                     bao->neigh.cmp(router, BATADV_IF_DEFAULT, best_router,
1855                                    BATADV_IF_DEFAULT) <= 0) {
1856                         batadv_neigh_node_put(router);
1857                         continue;
1858                 }
1859
1860                 /* release the refcount for the "old" best */
1861                 if (best_router)
1862                         batadv_neigh_node_put(best_router);
1863
1864                 best_entry = orig_entry;
1865                 best_router = router;
1866         }
1867
1868         if (best_router)
1869                 batadv_neigh_node_put(best_router);
1870
1871         return best_entry;
1872 }
1873
1874 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
1875 /**
1876  * batadv_tt_global_print_entry() - print all orig nodes who announce the
1877  *  address for this global entry
1878  * @bat_priv: the bat priv with all the soft interface information
1879  * @tt_global_entry: global translation table entry to be printed
1880  * @seq: debugfs table seq_file struct
1881  *
1882  * This functon assumes the caller holds rcu_read_lock().
1883  */
1884 static void
1885 batadv_tt_global_print_entry(struct batadv_priv *bat_priv,
1886                              struct batadv_tt_global_entry *tt_global_entry,
1887                              struct seq_file *seq)
1888 {
1889         struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
1890         struct batadv_tt_common_entry *tt_common_entry;
1891         struct batadv_orig_node_vlan *vlan;
1892         struct hlist_head *head;
1893         u8 last_ttvn;
1894         u16 flags;
1895
1896         tt_common_entry = &tt_global_entry->common;
1897         flags = tt_common_entry->flags;
1898
1899         best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
1900         if (best_entry) {
1901                 vlan = batadv_orig_node_vlan_get(best_entry->orig_node,
1902                                                  tt_common_entry->vid);
1903                 if (!vlan) {
1904                         seq_printf(seq,
1905                                    " * Cannot retrieve VLAN %d for originator %pM\n",
1906                                    batadv_print_vid(tt_common_entry->vid),
1907                                    best_entry->orig_node->orig);
1908                         goto print_list;
1909                 }
1910
1911                 last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);
1912                 seq_printf(seq,
1913                            " %c %pM %4i   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1914                            '*', tt_global_entry->common.addr,
1915                            batadv_print_vid(tt_global_entry->common.vid),
1916                            best_entry->ttvn, best_entry->orig_node->orig,
1917                            last_ttvn, vlan->tt.crc,
1918                            ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
1919                            ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
1920                            ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1921                            ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1922
1923                 batadv_orig_node_vlan_put(vlan);
1924         }
1925
1926 print_list:
1927         head = &tt_global_entry->orig_list;
1928
1929         hlist_for_each_entry_rcu(orig_entry, head, list) {
1930                 if (best_entry == orig_entry)
1931                         continue;
1932
1933                 vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,
1934                                                  tt_common_entry->vid);
1935                 if (!vlan) {
1936                         seq_printf(seq,
1937                                    " + Cannot retrieve VLAN %d for originator %pM\n",
1938                                    batadv_print_vid(tt_common_entry->vid),
1939                                    orig_entry->orig_node->orig);
1940                         continue;
1941                 }
1942
1943                 last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);
1944                 seq_printf(seq,
1945                            " %c %pM %4d   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1946                            '+', tt_global_entry->common.addr,
1947                            batadv_print_vid(tt_global_entry->common.vid),
1948                            orig_entry->ttvn, orig_entry->orig_node->orig,
1949                            last_ttvn, vlan->tt.crc,
1950                            ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
1951                            ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
1952                            ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1953                            ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1954
1955                 batadv_orig_node_vlan_put(vlan);
1956         }
1957 }
1958
1959 /**
1960  * batadv_tt_global_seq_print_text() - Print the global tt table in a seq file
1961  * @seq: seq file to print on
1962  * @offset: not used
1963  *
1964  * Return: always 0
1965  */
1966 int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
1967 {
1968         struct net_device *net_dev = (struct net_device *)seq->private;
1969         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1970         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1971         struct batadv_tt_common_entry *tt_common_entry;
1972         struct batadv_tt_global_entry *tt_global;
1973         struct batadv_hard_iface *primary_if;
1974         struct hlist_head *head;
1975         u32 i;
1976
1977         primary_if = batadv_seq_print_text_primary_if_get(seq);
1978         if (!primary_if)
1979                 goto out;
1980
1981         seq_printf(seq,
1982                    "Globally announced TT entries received via the mesh %s\n",
1983                    net_dev->name);
1984         seq_puts(seq,
1985                  "       Client         VID  (TTVN)       Originator      (Curr TTVN) (CRC       ) Flags\n");
1986
1987         for (i = 0; i < hash->size; i++) {
1988                 head = &hash->table[i];
1989
1990                 rcu_read_lock();
1991                 hlist_for_each_entry_rcu(tt_common_entry,
1992                                          head, hash_entry) {
1993                         tt_global = container_of(tt_common_entry,
1994                                                  struct batadv_tt_global_entry,
1995                                                  common);
1996                         batadv_tt_global_print_entry(bat_priv, tt_global, seq);
1997                 }
1998                 rcu_read_unlock();
1999         }
2000 out:
2001         if (primary_if)
2002                 batadv_hardif_put(primary_if);
2003         return 0;
2004 }
2005 #endif
2006
2007 /**
2008  * batadv_tt_global_dump_subentry() - Dump all TT local entries into a message
2009  * @msg: Netlink message to dump into
2010  * @portid: Port making netlink request
2011  * @seq: Sequence number of netlink message
2012  * @common: tt local & tt global common data
2013  * @orig: Originator node announcing a non-mesh client
2014  * @best: Is the best originator for the TT entry
2015  *
2016  * Return: Error code, or 0 on success
2017  */
2018 static int
2019 batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
2020                                struct batadv_tt_common_entry *common,
2021                                struct batadv_tt_orig_list_entry *orig,
2022                                bool best)
2023 {
2024         u16 flags = (common->flags & (~BATADV_TT_SYNC_MASK)) | orig->flags;
2025         void *hdr;
2026         struct batadv_orig_node_vlan *vlan;
2027         u8 last_ttvn;
2028         u32 crc;
2029
2030         vlan = batadv_orig_node_vlan_get(orig->orig_node,
2031                                          common->vid);
2032         if (!vlan)
2033                 return 0;
2034
2035         crc = vlan->tt.crc;
2036
2037         batadv_orig_node_vlan_put(vlan);
2038
2039         hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
2040                           NLM_F_MULTI,
2041                           BATADV_CMD_GET_TRANSTABLE_GLOBAL);
2042         if (!hdr)
2043                 return -ENOBUFS;
2044
2045         last_ttvn = atomic_read(&orig->orig_node->last_ttvn);
2046
2047         if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) ||
2048             nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
2049                     orig->orig_node->orig) ||
2050             nla_put_u8(msg, BATADV_ATTR_TT_TTVN, orig->ttvn) ||
2051             nla_put_u8(msg, BATADV_ATTR_TT_LAST_TTVN, last_ttvn) ||
2052             nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
2053             nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) ||
2054             nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, flags))
2055                 goto nla_put_failure;
2056
2057         if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
2058                 goto nla_put_failure;
2059
2060         genlmsg_end(msg, hdr);
2061         return 0;
2062
2063  nla_put_failure:
2064         genlmsg_cancel(msg, hdr);
2065         return -EMSGSIZE;
2066 }
2067
2068 /**
2069  * batadv_tt_global_dump_entry() - Dump one TT global entry into a message
2070  * @msg: Netlink message to dump into
2071  * @portid: Port making netlink request
2072  * @seq: Sequence number of netlink message
2073  * @bat_priv: The bat priv with all the soft interface information
2074  * @common: tt local & tt global common data
2075  * @sub_s: Number of entries to skip
2076  *
2077  * This function assumes the caller holds rcu_read_lock().
2078  *
2079  * Return: Error code, or 0 on success
2080  */
2081 static int
2082 batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
2083                             struct batadv_priv *bat_priv,
2084                             struct batadv_tt_common_entry *common, int *sub_s)
2085 {
2086         struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
2087         struct batadv_tt_global_entry *global;
2088         struct hlist_head *head;
2089         int sub = 0;
2090         bool best;
2091
2092         global = container_of(common, struct batadv_tt_global_entry, common);
2093         best_entry = batadv_transtable_best_orig(bat_priv, global);
2094         head = &global->orig_list;
2095
2096         hlist_for_each_entry_rcu(orig_entry, head, list) {
2097                 if (sub++ < *sub_s)
2098                         continue;
2099
2100                 best = (orig_entry == best_entry);
2101
2102                 if (batadv_tt_global_dump_subentry(msg, portid, seq, common,
2103                                                    orig_entry, best)) {
2104                         *sub_s = sub - 1;
2105                         return -EMSGSIZE;
2106                 }
2107         }
2108
2109         *sub_s = 0;
2110         return 0;
2111 }
2112
2113 /**
2114  * batadv_tt_global_dump_bucket() - Dump one TT local bucket into a message
2115  * @msg: Netlink message to dump into
2116  * @portid: Port making netlink request
2117  * @seq: Sequence number of netlink message
2118  * @bat_priv: The bat priv with all the soft interface information
2119  * @head: Pointer to the list containing the global tt entries
2120  * @idx_s: Number of entries to skip
2121  * @sub: Number of entries to skip
2122  *
2123  * Return: Error code, or 0 on success
2124  */
2125 static int
2126 batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
2127                              struct batadv_priv *bat_priv,
2128                              struct hlist_head *head, int *idx_s, int *sub)
2129 {
2130         struct batadv_tt_common_entry *common;
2131         int idx = 0;
2132
2133         rcu_read_lock();
2134         hlist_for_each_entry_rcu(common, head, hash_entry) {
2135                 if (idx++ < *idx_s)
2136                         continue;
2137
2138                 if (batadv_tt_global_dump_entry(msg, portid, seq, bat_priv,
2139                                                 common, sub)) {
2140                         rcu_read_unlock();
2141                         *idx_s = idx - 1;
2142                         return -EMSGSIZE;
2143                 }
2144         }
2145         rcu_read_unlock();
2146
2147         *idx_s = 0;
2148         *sub = 0;
2149         return 0;
2150 }
2151
2152 /**
2153  * batadv_tt_global_dump() -  Dump TT global entries into a message
2154  * @msg: Netlink message to dump into
2155  * @cb: Parameters from query
2156  *
2157  * Return: Error code, or length of message on success
2158  */
2159 int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb)
2160 {
2161         struct net *net = sock_net(cb->skb->sk);
2162         struct net_device *soft_iface;
2163         struct batadv_priv *bat_priv;
2164         struct batadv_hard_iface *primary_if = NULL;
2165         struct batadv_hashtable *hash;
2166         struct hlist_head *head;
2167         int ret;
2168         int ifindex;
2169         int bucket = cb->args[0];
2170         int idx = cb->args[1];
2171         int sub = cb->args[2];
2172         int portid = NETLINK_CB(cb->skb).portid;
2173
2174         ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
2175         if (!ifindex)
2176                 return -EINVAL;
2177
2178         soft_iface = dev_get_by_index(net, ifindex);
2179         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2180                 ret = -ENODEV;
2181                 goto out;
2182         }
2183
2184         bat_priv = netdev_priv(soft_iface);
2185
2186         primary_if = batadv_primary_if_get_selected(bat_priv);
2187         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2188                 ret = -ENOENT;
2189                 goto out;
2190         }
2191
2192         hash = bat_priv->tt.global_hash;
2193
2194         while (bucket < hash->size) {
2195                 head = &hash->table[bucket];
2196
2197                 if (batadv_tt_global_dump_bucket(msg, portid,
2198                                                  cb->nlh->nlmsg_seq, bat_priv,
2199                                                  head, &idx, &sub))
2200                         break;
2201
2202                 bucket++;
2203         }
2204
2205         ret = msg->len;
2206
2207  out:
2208         if (primary_if)
2209                 batadv_hardif_put(primary_if);
2210         if (soft_iface)
2211                 dev_put(soft_iface);
2212
2213         cb->args[0] = bucket;
2214         cb->args[1] = idx;
2215         cb->args[2] = sub;
2216
2217         return ret;
2218 }
2219
2220 /**
2221  * _batadv_tt_global_del_orig_entry() - remove and free an orig_entry
2222  * @tt_global_entry: the global entry to remove the orig_entry from
2223  * @orig_entry: the orig entry to remove and free
2224  *
2225  * Remove an orig_entry from its list in the given tt_global_entry and
2226  * free this orig_entry afterwards.
2227  *
2228  * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is
2229  * part of a list.
2230  */
2231 static void
2232 _batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
2233                                  struct batadv_tt_orig_list_entry *orig_entry)
2234 {
2235         lockdep_assert_held(&tt_global_entry->list_lock);
2236
2237         batadv_tt_global_size_dec(orig_entry->orig_node,
2238                                   tt_global_entry->common.vid);
2239         atomic_dec(&tt_global_entry->orig_list_count);
2240         /* requires holding tt_global_entry->list_lock and orig_entry->list
2241          * being part of a list
2242          */
2243         hlist_del_rcu(&orig_entry->list);
2244         batadv_tt_orig_list_entry_put(orig_entry);
2245 }
2246
2247 /* deletes the orig list of a tt_global_entry */
2248 static void
2249 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
2250 {
2251         struct hlist_head *head;
2252         struct hlist_node *safe;
2253         struct batadv_tt_orig_list_entry *orig_entry;
2254
2255         spin_lock_bh(&tt_global_entry->list_lock);
2256         head = &tt_global_entry->orig_list;
2257         hlist_for_each_entry_safe(orig_entry, safe, head, list)
2258                 _batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);
2259         spin_unlock_bh(&tt_global_entry->list_lock);
2260 }
2261
2262 /**
2263  * batadv_tt_global_del_orig_node() - remove orig_node from a global tt entry
2264  * @bat_priv: the bat priv with all the soft interface information
2265  * @tt_global_entry: the global entry to remove the orig_node from
2266  * @orig_node: the originator announcing the client
2267  * @message: message to append to the log on deletion
2268  *
2269  * Remove the given orig_node and its according orig_entry from the given
2270  * global tt entry.
2271  */
2272 static void
2273 batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,
2274                                struct batadv_tt_global_entry *tt_global_entry,
2275                                struct batadv_orig_node *orig_node,
2276                                const char *message)
2277 {
2278         struct hlist_head *head;
2279         struct hlist_node *safe;
2280         struct batadv_tt_orig_list_entry *orig_entry;
2281         unsigned short vid;
2282
2283         spin_lock_bh(&tt_global_entry->list_lock);
2284         head = &tt_global_entry->orig_list;
2285         hlist_for_each_entry_safe(orig_entry, safe, head, list) {
2286                 if (orig_entry->orig_node == orig_node) {
2287                         vid = tt_global_entry->common.vid;
2288                         batadv_dbg(BATADV_DBG_TT, bat_priv,
2289                                    "Deleting %pM from global tt entry %pM (vid: %d): %s\n",
2290                                    orig_node->orig,
2291                                    tt_global_entry->common.addr,
2292                                    batadv_print_vid(vid), message);
2293                         _batadv_tt_global_del_orig_entry(tt_global_entry,
2294                                                          orig_entry);
2295                 }
2296         }
2297         spin_unlock_bh(&tt_global_entry->list_lock);
2298 }
2299
2300 /* If the client is to be deleted, we check if it is the last origantor entry
2301  * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the
2302  * timer, otherwise we simply remove the originator scheduled for deletion.
2303  */
2304 static void
2305 batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
2306                              struct batadv_tt_global_entry *tt_global_entry,
2307                              struct batadv_orig_node *orig_node,
2308                              const char *message)
2309 {
2310         bool last_entry = true;
2311         struct hlist_head *head;
2312         struct batadv_tt_orig_list_entry *orig_entry;
2313
2314         /* no local entry exists, case 1:
2315          * Check if this is the last one or if other entries exist.
2316          */
2317
2318         rcu_read_lock();
2319         head = &tt_global_entry->orig_list;
2320         hlist_for_each_entry_rcu(orig_entry, head, list) {
2321                 if (orig_entry->orig_node != orig_node) {
2322                         last_entry = false;
2323                         break;
2324                 }
2325         }
2326         rcu_read_unlock();
2327
2328         if (last_entry) {
2329                 /* its the last one, mark for roaming. */
2330                 tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
2331                 tt_global_entry->roam_at = jiffies;
2332         } else {
2333                 /* there is another entry, we can simply delete this
2334                  * one and can still use the other one.
2335                  */
2336                 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
2337                                                orig_node, message);
2338         }
2339 }
2340
2341 /**
2342  * batadv_tt_global_del() - remove a client from the global table
2343  * @bat_priv: the bat priv with all the soft interface information
2344  * @orig_node: an originator serving this client
2345  * @addr: the mac address of the client
2346  * @vid: VLAN identifier
2347  * @message: a message explaining the reason for deleting the client to print
2348  *  for debugging purpose
2349  * @roaming: true if the deletion has been triggered by a roaming event
2350  */
2351 static void batadv_tt_global_del(struct batadv_priv *bat_priv,
2352                                  struct batadv_orig_node *orig_node,
2353                                  const unsigned char *addr, unsigned short vid,
2354                                  const char *message, bool roaming)
2355 {
2356         struct batadv_tt_global_entry *tt_global_entry;
2357         struct batadv_tt_local_entry *local_entry = NULL;
2358
2359         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2360         if (!tt_global_entry)
2361                 goto out;
2362
2363         if (!roaming) {
2364                 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
2365                                                orig_node, message);
2366
2367                 if (hlist_empty(&tt_global_entry->orig_list))
2368                         batadv_tt_global_free(bat_priv, tt_global_entry,
2369                                               message);
2370
2371                 goto out;
2372         }
2373
2374         /* if we are deleting a global entry due to a roam
2375          * event, there are two possibilities:
2376          * 1) the client roamed from node A to node B => if there
2377          *    is only one originator left for this client, we mark
2378          *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we
2379          *    wait for node B to claim it. In case of timeout
2380          *    the entry is purged.
2381          *
2382          *    If there are other originators left, we directly delete
2383          *    the originator.
2384          * 2) the client roamed to us => we can directly delete
2385          *    the global entry, since it is useless now.
2386          */
2387         local_entry = batadv_tt_local_hash_find(bat_priv,
2388                                                 tt_global_entry->common.addr,
2389                                                 vid);
2390         if (local_entry) {
2391                 /* local entry exists, case 2: client roamed to us. */
2392                 batadv_tt_global_del_orig_list(tt_global_entry);
2393                 batadv_tt_global_free(bat_priv, tt_global_entry, message);
2394         } else {
2395                 /* no local entry exists, case 1: check for roaming */
2396                 batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
2397                                              orig_node, message);
2398         }
2399
2400 out:
2401         if (tt_global_entry)
2402                 batadv_tt_global_entry_put(tt_global_entry);
2403         if (local_entry)
2404                 batadv_tt_local_entry_put(local_entry);
2405 }
2406
2407 /**
2408  * batadv_tt_global_del_orig() - remove all the TT global entries belonging to
2409  *  the given originator matching the provided vid
2410  * @bat_priv: the bat priv with all the soft interface information
2411  * @orig_node: the originator owning the entries to remove
2412  * @match_vid: the VLAN identifier to match. If negative all the entries will be
2413  *  removed
2414  * @message: debug message to print as "reason"
2415  */
2416 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
2417                                struct batadv_orig_node *orig_node,
2418                                s32 match_vid,
2419                                const char *message)
2420 {
2421         struct batadv_tt_global_entry *tt_global;
2422         struct batadv_tt_common_entry *tt_common_entry;
2423         u32 i;
2424         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2425         struct hlist_node *safe;
2426         struct hlist_head *head;
2427         spinlock_t *list_lock; /* protects write access to the hash lists */
2428         unsigned short vid;
2429
2430         if (!hash)
2431                 return;
2432
2433         for (i = 0; i < hash->size; i++) {
2434                 head = &hash->table[i];
2435                 list_lock = &hash->list_locks[i];
2436
2437                 spin_lock_bh(list_lock);
2438                 hlist_for_each_entry_safe(tt_common_entry, safe,
2439                                           head, hash_entry) {
2440                         /* remove only matching entries */
2441                         if (match_vid >= 0 && tt_common_entry->vid != match_vid)
2442                                 continue;
2443
2444                         tt_global = container_of(tt_common_entry,
2445                                                  struct batadv_tt_global_entry,
2446                                                  common);
2447
2448                         batadv_tt_global_del_orig_node(bat_priv, tt_global,
2449                                                        orig_node, message);
2450
2451                         if (hlist_empty(&tt_global->orig_list)) {
2452                                 vid = tt_global->common.vid;
2453                                 batadv_dbg(BATADV_DBG_TT, bat_priv,
2454                                            "Deleting global tt entry %pM (vid: %d): %s\n",
2455                                            tt_global->common.addr,
2456                                            batadv_print_vid(vid), message);
2457                                 hlist_del_rcu(&tt_common_entry->hash_entry);
2458                                 batadv_tt_global_entry_put(tt_global);
2459                         }
2460                 }
2461                 spin_unlock_bh(list_lock);
2462         }
2463         clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
2464 }
2465
2466 static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
2467                                       char **msg)
2468 {
2469         bool purge = false;
2470         unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
2471         unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;
2472
2473         if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&
2474             batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {
2475                 purge = true;
2476                 *msg = "Roaming timeout\n";
2477         }
2478
2479         if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&
2480             batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {
2481                 purge = true;
2482                 *msg = "Temporary client timeout\n";
2483         }
2484
2485         return purge;
2486 }
2487
2488 static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
2489 {
2490         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2491         struct hlist_head *head;
2492         struct hlist_node *node_tmp;
2493         spinlock_t *list_lock; /* protects write access to the hash lists */
2494         u32 i;
2495         char *msg = NULL;
2496         struct batadv_tt_common_entry *tt_common;
2497         struct batadv_tt_global_entry *tt_global;
2498
2499         for (i = 0; i < hash->size; i++) {
2500                 head = &hash->table[i];
2501                 list_lock = &hash->list_locks[i];
2502
2503                 spin_lock_bh(list_lock);
2504                 hlist_for_each_entry_safe(tt_common, node_tmp, head,
2505                                           hash_entry) {
2506                         tt_global = container_of(tt_common,
2507                                                  struct batadv_tt_global_entry,
2508                                                  common);
2509
2510                         if (!batadv_tt_global_to_purge(tt_global, &msg))
2511                                 continue;
2512
2513                         batadv_dbg(BATADV_DBG_TT, bat_priv,
2514                                    "Deleting global tt entry %pM (vid: %d): %s\n",
2515                                    tt_global->common.addr,
2516                                    batadv_print_vid(tt_global->common.vid),
2517                                    msg);
2518
2519                         hlist_del_rcu(&tt_common->hash_entry);
2520
2521                         batadv_tt_global_entry_put(tt_global);
2522                 }
2523                 spin_unlock_bh(list_lock);
2524         }
2525 }
2526
2527 static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
2528 {
2529         struct batadv_hashtable *hash;
2530         spinlock_t *list_lock; /* protects write access to the hash lists */
2531         struct batadv_tt_common_entry *tt_common_entry;
2532         struct batadv_tt_global_entry *tt_global;
2533         struct hlist_node *node_tmp;
2534         struct hlist_head *head;
2535         u32 i;
2536
2537         if (!bat_priv->tt.global_hash)
2538                 return;
2539
2540         hash = bat_priv->tt.global_hash;
2541
2542         for (i = 0; i < hash->size; i++) {
2543                 head = &hash->table[i];
2544                 list_lock = &hash->list_locks[i];
2545
2546                 spin_lock_bh(list_lock);
2547                 hlist_for_each_entry_safe(tt_common_entry, node_tmp,
2548                                           head, hash_entry) {
2549                         hlist_del_rcu(&tt_common_entry->hash_entry);
2550                         tt_global = container_of(tt_common_entry,
2551                                                  struct batadv_tt_global_entry,
2552                                                  common);
2553                         batadv_tt_global_entry_put(tt_global);
2554                 }
2555                 spin_unlock_bh(list_lock);
2556         }
2557
2558         batadv_hash_destroy(hash);
2559
2560         bat_priv->tt.global_hash = NULL;
2561 }
2562
2563 static bool
2564 _batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
2565                        struct batadv_tt_global_entry *tt_global_entry)
2566 {
2567         if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
2568             tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
2569                 return true;
2570
2571         /* check if the two clients are marked as isolated */
2572         if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&
2573             tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)
2574                 return true;
2575
2576         return false;
2577 }
2578
2579 /**
2580  * batadv_transtable_search() - get the mesh destination for a given client
2581  * @bat_priv: the bat priv with all the soft interface information
2582  * @src: mac address of the source client
2583  * @addr: mac address of the destination client
2584  * @vid: VLAN identifier
2585  *
2586  * Return: a pointer to the originator that was selected as destination in the
2587  * mesh for contacting the client 'addr', NULL otherwise.
2588  * In case of multiple originators serving the same client, the function returns
2589  * the best one (best in terms of metric towards the destination node).
2590  *
2591  * If the two clients are AP isolated the function returns NULL.
2592  */
2593 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
2594                                                   const u8 *src,
2595                                                   const u8 *addr,
2596                                                   unsigned short vid)
2597 {
2598         struct batadv_tt_local_entry *tt_local_entry = NULL;
2599         struct batadv_tt_global_entry *tt_global_entry = NULL;
2600         struct batadv_orig_node *orig_node = NULL;
2601         struct batadv_tt_orig_list_entry *best_entry;
2602
2603         if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {
2604                 tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);
2605                 if (!tt_local_entry ||
2606                     (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))
2607                         goto out;
2608         }
2609
2610         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2611         if (!tt_global_entry)
2612                 goto out;
2613
2614         /* check whether the clients should not communicate due to AP
2615          * isolation
2616          */
2617         if (tt_local_entry &&
2618             _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
2619                 goto out;
2620
2621         rcu_read_lock();
2622         best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
2623         /* found anything? */
2624         if (best_entry)
2625                 orig_node = best_entry->orig_node;
2626         if (orig_node && !kref_get_unless_zero(&orig_node->refcount))
2627                 orig_node = NULL;
2628         rcu_read_unlock();
2629
2630 out:
2631         if (tt_global_entry)
2632                 batadv_tt_global_entry_put(tt_global_entry);
2633         if (tt_local_entry)
2634                 batadv_tt_local_entry_put(tt_local_entry);
2635
2636         return orig_node;
2637 }
2638
2639 /**
2640  * batadv_tt_global_crc() - calculates the checksum of the local table belonging
2641  *  to the given orig_node
2642  * @bat_priv: the bat priv with all the soft interface information
2643  * @orig_node: originator for which the CRC should be computed
2644  * @vid: VLAN identifier for which the CRC32 has to be computed
2645  *
2646  * This function computes the checksum for the global table corresponding to a
2647  * specific originator. In particular, the checksum is computed as follows: For
2648  * each client connected to the originator the CRC32C of the MAC address and the
2649  * VID is computed and then all the CRC32Cs of the various clients are xor'ed
2650  * together.
2651  *
2652  * The idea behind is that CRC32C should be used as much as possible in order to
2653  * produce a unique hash of the table, but since the order which is used to feed
2654  * the CRC32C function affects the result and since every node in the network
2655  * probably sorts the clients differently, the hash function cannot be directly
2656  * computed over the entire table. Hence the CRC32C is used only on
2657  * the single client entry, while all the results are then xor'ed together
2658  * because the XOR operation can combine them all while trying to reduce the
2659  * noise as much as possible.
2660  *
2661  * Return: the checksum of the global table of a given originator.
2662  */
2663 static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
2664                                 struct batadv_orig_node *orig_node,
2665                                 unsigned short vid)
2666 {
2667         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2668         struct batadv_tt_orig_list_entry *tt_orig;
2669         struct batadv_tt_common_entry *tt_common;
2670         struct batadv_tt_global_entry *tt_global;
2671         struct hlist_head *head;
2672         u32 i, crc_tmp, crc = 0;
2673         u8 flags;
2674         __be16 tmp_vid;
2675
2676         for (i = 0; i < hash->size; i++) {
2677                 head = &hash->table[i];
2678
2679                 rcu_read_lock();
2680                 hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2681                         tt_global = container_of(tt_common,
2682                                                  struct batadv_tt_global_entry,
2683                                                  common);
2684                         /* compute the CRC only for entries belonging to the
2685                          * VLAN identified by the vid passed as parameter
2686                          */
2687                         if (tt_common->vid != vid)
2688                                 continue;
2689
2690                         /* Roaming clients are in the global table for
2691                          * consistency only. They don't have to be
2692                          * taken into account while computing the
2693                          * global crc
2694                          */
2695                         if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
2696                                 continue;
2697                         /* Temporary clients have not been announced yet, so
2698                          * they have to be skipped while computing the global
2699                          * crc
2700                          */
2701                         if (tt_common->flags & BATADV_TT_CLIENT_TEMP)
2702                                 continue;
2703
2704                         /* find out if this global entry is announced by this
2705                          * originator
2706                          */
2707                         tt_orig = batadv_tt_global_orig_entry_find(tt_global,
2708                                                                    orig_node);
2709                         if (!tt_orig)
2710                                 continue;
2711
2712                         /* use network order to read the VID: this ensures that
2713                          * every node reads the bytes in the same order.
2714                          */
2715                         tmp_vid = htons(tt_common->vid);
2716                         crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2717
2718                         /* compute the CRC on flags that have to be kept in sync
2719                          * among nodes
2720                          */
2721                         flags = tt_orig->flags;
2722                         crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2723
2724                         crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2725
2726                         batadv_tt_orig_list_entry_put(tt_orig);
2727                 }
2728                 rcu_read_unlock();
2729         }
2730
2731         return crc;
2732 }
2733
2734 /**
2735  * batadv_tt_local_crc() - calculates the checksum of the local table
2736  * @bat_priv: the bat priv with all the soft interface information
2737  * @vid: VLAN identifier for which the CRC32 has to be computed
2738  *
2739  * For details about the computation, please refer to the documentation for
2740  * batadv_tt_global_crc().
2741  *
2742  * Return: the checksum of the local table
2743  */
2744 static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,
2745                                unsigned short vid)
2746 {
2747         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
2748         struct batadv_tt_common_entry *tt_common;
2749         struct hlist_head *head;
2750         u32 i, crc_tmp, crc = 0;
2751         u8 flags;
2752         __be16 tmp_vid;
2753
2754         for (i = 0; i < hash->size; i++) {
2755                 head = &hash->table[i];
2756
2757                 rcu_read_lock();
2758                 hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2759                         /* compute the CRC only for entries belonging to the
2760                          * VLAN identified by vid
2761                          */
2762                         if (tt_common->vid != vid)
2763                                 continue;
2764
2765                         /* not yet committed clients have not to be taken into
2766                          * account while computing the CRC
2767                          */
2768                         if (tt_common->flags & BATADV_TT_CLIENT_NEW)
2769                                 continue;
2770
2771                         /* use network order to read the VID: this ensures that
2772                          * every node reads the bytes in the same order.
2773                          */
2774                         tmp_vid = htons(tt_common->vid);
2775                         crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2776
2777                         /* compute the CRC on flags that have to be kept in sync
2778                          * among nodes
2779                          */
2780                         flags = tt_common->flags & BATADV_TT_SYNC_MASK;
2781                         crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2782
2783                         crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2784                 }
2785                 rcu_read_unlock();
2786         }
2787
2788         return crc;
2789 }
2790
2791 /**
2792  * batadv_tt_req_node_release() - free tt_req node entry
2793  * @ref: kref pointer of the tt req_node entry
2794  */
2795 static void batadv_tt_req_node_release(struct kref *ref)
2796 {
2797         struct batadv_tt_req_node *tt_req_node;
2798
2799         tt_req_node = container_of(ref, struct batadv_tt_req_node, refcount);
2800
2801         kmem_cache_free(batadv_tt_req_cache, tt_req_node);
2802 }
2803
2804 /**
2805  * batadv_tt_req_node_put() - decrement the tt_req_node refcounter and
2806  *  possibly release it
2807  * @tt_req_node: tt_req_node to be free'd
2808  */
2809 static void batadv_tt_req_node_put(struct batadv_tt_req_node *tt_req_node)
2810 {
2811         kref_put(&tt_req_node->refcount, batadv_tt_req_node_release);
2812 }
2813
2814 static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
2815 {
2816         struct batadv_tt_req_node *node;
2817         struct hlist_node *safe;
2818
2819         spin_lock_bh(&bat_priv->tt.req_list_lock);
2820
2821         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2822                 hlist_del_init(&node->list);
2823                 batadv_tt_req_node_put(node);
2824         }
2825
2826         spin_unlock_bh(&bat_priv->tt.req_list_lock);
2827 }
2828
2829 static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
2830                                        struct batadv_orig_node *orig_node,
2831                                        const void *tt_buff,
2832                                        u16 tt_buff_len)
2833 {
2834         /* Replace the old buffer only if I received something in the
2835          * last OGM (the OGM could carry no changes)
2836          */
2837         spin_lock_bh(&orig_node->tt_buff_lock);
2838         if (tt_buff_len > 0) {
2839                 kfree(orig_node->tt_buff);
2840                 orig_node->tt_buff_len = 0;
2841                 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
2842                 if (orig_node->tt_buff) {
2843                         memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
2844                         orig_node->tt_buff_len = tt_buff_len;
2845                 }
2846         }
2847         spin_unlock_bh(&orig_node->tt_buff_lock);
2848 }
2849
2850 static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
2851 {
2852         struct batadv_tt_req_node *node;
2853         struct hlist_node *safe;
2854
2855         spin_lock_bh(&bat_priv->tt.req_list_lock);
2856         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2857                 if (batadv_has_timed_out(node->issued_at,
2858                                          BATADV_TT_REQUEST_TIMEOUT)) {
2859                         hlist_del_init(&node->list);
2860                         batadv_tt_req_node_put(node);
2861                 }
2862         }
2863         spin_unlock_bh(&bat_priv->tt.req_list_lock);
2864 }
2865
2866 /**
2867  * batadv_tt_req_node_new() - search and possibly create a tt_req_node object
2868  * @bat_priv: the bat priv with all the soft interface information
2869  * @orig_node: orig node this request is being issued for
2870  *
2871  * Return: the pointer to the new tt_req_node struct if no request
2872  * has already been issued for this orig_node, NULL otherwise.
2873  */
2874 static struct batadv_tt_req_node *
2875 batadv_tt_req_node_new(struct batadv_priv *bat_priv,
2876                        struct batadv_orig_node *orig_node)
2877 {
2878         struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
2879
2880         spin_lock_bh(&bat_priv->tt.req_list_lock);
2881         hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
2882                 if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
2883                     !batadv_has_timed_out(tt_req_node_tmp->issued_at,
2884                                           BATADV_TT_REQUEST_TIMEOUT))
2885                         goto unlock;
2886         }
2887
2888         tt_req_node = kmem_cache_alloc(batadv_tt_req_cache, GFP_ATOMIC);
2889         if (!tt_req_node)
2890                 goto unlock;
2891
2892         kref_init(&tt_req_node->refcount);
2893         ether_addr_copy(tt_req_node->addr, orig_node->orig);
2894         tt_req_node->issued_at = jiffies;
2895
2896         kref_get(&tt_req_node->refcount);
2897         hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list);
2898 unlock:
2899         spin_unlock_bh(&bat_priv->tt.req_list_lock);
2900         return tt_req_node;
2901 }
2902
2903 /**
2904  * batadv_tt_local_valid() - verify local tt entry and get flags
2905  * @entry_ptr: to be checked local tt entry
2906  * @data_ptr: not used but definition required to satisfy the callback prototype
2907  * @flags: a pointer to store TT flags for this client to
2908  *
2909  * Checks the validity of the given local TT entry. If it is, then the provided
2910  * flags pointer is updated.
2911  *
2912  * Return: true if the entry is a valid, false otherwise.
2913  */
2914 static bool batadv_tt_local_valid(const void *entry_ptr,
2915                                   const void *data_ptr,
2916                                   u8 *flags)
2917 {
2918         const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2919
2920         if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
2921                 return false;
2922
2923         if (flags)
2924                 *flags = tt_common_entry->flags;
2925
2926         return true;
2927 }
2928
2929 /**
2930  * batadv_tt_global_valid() - verify global tt entry and get flags
2931  * @entry_ptr: to be checked global tt entry
2932  * @data_ptr: an orig_node object (may be NULL)
2933  * @flags: a pointer to store TT flags for this client to
2934  *
2935  * Checks the validity of the given global TT entry. If it is, then the provided
2936  * flags pointer is updated either with the common (summed) TT flags if data_ptr
2937  * is NULL or the specific, per originator TT flags otherwise.
2938  *
2939  * Return: true if the entry is a valid, false otherwise.
2940  */
2941 static bool batadv_tt_global_valid(const void *entry_ptr,
2942                                    const void *data_ptr,
2943                                    u8 *flags)
2944 {
2945         const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2946         const struct batadv_tt_global_entry *tt_global_entry;
2947         const struct batadv_orig_node *orig_node = data_ptr;
2948
2949         if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
2950             tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
2951                 return false;
2952
2953         tt_global_entry = container_of(tt_common_entry,
2954                                        struct batadv_tt_global_entry,
2955                                        common);
2956
2957         return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node,
2958                                                flags);
2959 }
2960
2961 /**
2962  * batadv_tt_tvlv_generate() - fill the tvlv buff with the tt entries from the
2963  *  specified tt hash
2964  * @bat_priv: the bat priv with all the soft interface information
2965  * @hash: hash table containing the tt entries
2966  * @tt_len: expected tvlv tt data buffer length in number of bytes
2967  * @tvlv_buff: pointer to the buffer to fill with the TT data
2968  * @valid_cb: function to filter tt change entries and to return TT flags
2969  * @cb_data: data passed to the filter function as argument
2970  *
2971  * Fills the tvlv buff with the tt entries from the specified hash. If valid_cb
2972  * is not provided then this becomes a no-op.
2973  */
2974 static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
2975                                     struct batadv_hashtable *hash,
2976                                     void *tvlv_buff, u16 tt_len,
2977                                     bool (*valid_cb)(const void *,
2978                                                      const void *,
2979                                                      u8 *flags),
2980                                     void *cb_data)
2981 {
2982         struct batadv_tt_common_entry *tt_common_entry;
2983         struct batadv_tvlv_tt_change *tt_change;
2984         struct hlist_head *head;
2985         u16 tt_tot, tt_num_entries = 0;
2986         u8 flags;
2987         bool ret;
2988         u32 i;
2989
2990         tt_tot = batadv_tt_entries(tt_len);
2991         tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;
2992
2993         if (!valid_cb)
2994                 return;
2995
2996         rcu_read_lock();
2997         for (i = 0; i < hash->size; i++) {
2998                 head = &hash->table[i];
2999
3000                 hlist_for_each_entry_rcu(tt_common_entry,
3001                                          head, hash_entry) {
3002                         if (tt_tot == tt_num_entries)
3003                                 break;
3004
3005                         ret = valid_cb(tt_common_entry, cb_data, &flags);
3006                         if (!ret)
3007                                 continue;
3008
3009                         ether_addr_copy(tt_change->addr, tt_common_entry->addr);
3010                         tt_change->flags = flags;
3011                         tt_change->vid = htons(tt_common_entry->vid);
3012                         memset(tt_change->reserved, 0,
3013                                sizeof(tt_change->reserved));
3014
3015                         tt_num_entries++;
3016                         tt_change++;
3017                 }
3018         }
3019         rcu_read_unlock();
3020 }
3021
3022 /**
3023  * batadv_tt_global_check_crc() - check if all the CRCs are correct
3024  * @orig_node: originator for which the CRCs have to be checked
3025  * @tt_vlan: pointer to the first tvlv VLAN entry
3026  * @num_vlan: number of tvlv VLAN entries
3027  *
3028  * Return: true if all the received CRCs match the locally stored ones, false
3029  * otherwise
3030  */
3031 static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,
3032                                        struct batadv_tvlv_tt_vlan_data *tt_vlan,
3033                                        u16 num_vlan)
3034 {
3035         struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;
3036         struct batadv_orig_node_vlan *vlan;
3037         int i, orig_num_vlan;
3038         u32 crc;
3039
3040         /* check if each received CRC matches the locally stored one */
3041         for (i = 0; i < num_vlan; i++) {
3042                 tt_vlan_tmp = tt_vlan + i;
3043
3044                 /* if orig_node is a backbone node for this VLAN, don't check
3045                  * the CRC as we ignore all the global entries over it
3046                  */
3047                 if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,
3048                                                    orig_node->orig,
3049                                                    ntohs(tt_vlan_tmp->vid)))
3050                         continue;
3051
3052                 vlan = batadv_orig_node_vlan_get(orig_node,
3053                                                  ntohs(tt_vlan_tmp->vid));
3054                 if (!vlan)
3055                         return false;
3056
3057                 crc = vlan->tt.crc;
3058                 batadv_orig_node_vlan_put(vlan);
3059
3060                 if (crc != ntohl(tt_vlan_tmp->crc))
3061                         return false;
3062         }
3063
3064         /* check if any excess VLANs exist locally for the originator
3065          * which are not mentioned in the TVLV from the originator.
3066          */
3067         rcu_read_lock();
3068         orig_num_vlan = 0;
3069         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list)
3070                 orig_num_vlan++;
3071         rcu_read_unlock();
3072
3073         if (orig_num_vlan > num_vlan)
3074                 return false;
3075
3076         return true;
3077 }
3078
3079 /**
3080  * batadv_tt_local_update_crc() - update all the local CRCs
3081  * @bat_priv: the bat priv with all the soft interface information
3082  */
3083 static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)
3084 {
3085         struct batadv_softif_vlan *vlan;
3086
3087         /* recompute the global CRC for each VLAN */
3088         rcu_read_lock();
3089         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
3090                 vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);
3091         }
3092         rcu_read_unlock();
3093 }
3094
3095 /**
3096  * batadv_tt_global_update_crc() - update all the global CRCs for this orig_node
3097  * @bat_priv: the bat priv with all the soft interface information
3098  * @orig_node: the orig_node for which the CRCs have to be updated
3099  */
3100 static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
3101                                         struct batadv_orig_node *orig_node)
3102 {
3103         struct batadv_orig_node_vlan *vlan;
3104         u32 crc;
3105
3106         /* recompute the global CRC for each VLAN */
3107         rcu_read_lock();
3108         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
3109                 /* if orig_node is a backbone node for this VLAN, don't compute
3110                  * the CRC as we ignore all the global entries over it
3111                  */
3112                 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
3113                                                    vlan->vid))
3114                         continue;
3115
3116                 crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);
3117                 vlan->tt.crc = crc;
3118         }
3119         rcu_read_unlock();
3120 }
3121
3122 /**
3123  * batadv_send_tt_request() - send a TT Request message to a given node
3124  * @bat_priv: the bat priv with all the soft interface information
3125  * @dst_orig_node: the destination of the message
3126  * @ttvn: the version number that the source of the message is looking for
3127  * @tt_vlan: pointer to the first tvlv VLAN object to request
3128  * @num_vlan: number of tvlv VLAN entries
3129  * @full_table: ask for the entire translation table if true, while only for the
3130  *  last TT diff otherwise
3131  *
3132  * Return: true if the TT Request was sent, false otherwise
3133  */
3134 static bool batadv_send_tt_request(struct batadv_priv *bat_priv,
3135                                    struct batadv_orig_node *dst_orig_node,
3136                                    u8 ttvn,
3137                                    struct batadv_tvlv_tt_vlan_data *tt_vlan,
3138                                    u16 num_vlan, bool full_table)
3139 {
3140         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
3141         struct batadv_tt_req_node *tt_req_node = NULL;
3142         struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
3143         struct batadv_hard_iface *primary_if;
3144         bool ret = false;
3145         int i, size;
3146
3147         primary_if = batadv_primary_if_get_selected(bat_priv);
3148         if (!primary_if)
3149                 goto out;
3150
3151         /* The new tt_req will be issued only if I'm not waiting for a
3152          * reply from the same orig_node yet
3153          */
3154         tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);
3155         if (!tt_req_node)
3156                 goto out;
3157
3158         size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
3159         tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
3160         if (!tvlv_tt_data)
3161                 goto out;
3162
3163         tvlv_tt_data->flags = BATADV_TT_REQUEST;
3164         tvlv_tt_data->ttvn = ttvn;
3165         tvlv_tt_data->num_vlan = htons(num_vlan);
3166
3167         /* send all the CRCs within the request. This is needed by intermediate
3168          * nodes to ensure they have the correct table before replying
3169          */
3170         tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);
3171         for (i = 0; i < num_vlan; i++) {
3172                 tt_vlan_req->vid = tt_vlan->vid;
3173                 tt_vlan_req->crc = tt_vlan->crc;
3174
3175                 tt_vlan_req++;
3176                 tt_vlan++;
3177         }
3178
3179         if (full_table)
3180                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
3181
3182         batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",
3183                    dst_orig_node->orig, full_table ? 'F' : '.');
3184
3185         batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
3186         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3187                                  dst_orig_node->orig, BATADV_TVLV_TT, 1,
3188                                  tvlv_tt_data, size);
3189         ret = true;
3190
3191 out:
3192         if (primary_if)
3193                 batadv_hardif_put(primary_if);
3194
3195         if (ret && tt_req_node) {
3196                 spin_lock_bh(&bat_priv->tt.req_list_lock);
3197                 if (!hlist_unhashed(&tt_req_node->list)) {
3198                         hlist_del_init(&tt_req_node->list);
3199                         batadv_tt_req_node_put(tt_req_node);
3200                 }
3201                 spin_unlock_bh(&bat_priv->tt.req_list_lock);
3202         }
3203
3204         if (tt_req_node)
3205                 batadv_tt_req_node_put(tt_req_node);
3206
3207         kfree(tvlv_tt_data);
3208         return ret;
3209 }
3210
3211 /**
3212  * batadv_send_other_tt_response() - send reply to tt request concerning another
3213  *  node's translation table
3214  * @bat_priv: the bat priv with all the soft interface information
3215  * @tt_data: tt data containing the tt request information
3216  * @req_src: mac address of tt request sender
3217  * @req_dst: mac address of tt request recipient
3218  *
3219  * Return: true if tt request reply was sent, false otherwise.
3220  */
3221 static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
3222                                           struct batadv_tvlv_tt_data *tt_data,
3223                                           u8 *req_src, u8 *req_dst)
3224 {
3225         struct batadv_orig_node *req_dst_orig_node;
3226         struct batadv_orig_node *res_dst_orig_node = NULL;
3227         struct batadv_tvlv_tt_change *tt_change;
3228         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
3229         struct batadv_tvlv_tt_vlan_data *tt_vlan;
3230         bool ret = false, full_table;
3231         u8 orig_ttvn, req_ttvn;
3232         u16 tvlv_len;
3233         s32 tt_len;
3234
3235         batadv_dbg(BATADV_DBG_TT, bat_priv,
3236                    "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
3237                    req_src, tt_data->ttvn, req_dst,
3238                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3239
3240         /* Let's get the orig node of the REAL destination */
3241         req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
3242         if (!req_dst_orig_node)
3243                 goto out;
3244
3245         res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
3246         if (!res_dst_orig_node)
3247                 goto out;
3248
3249         orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);
3250         req_ttvn = tt_data->ttvn;
3251
3252         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
3253         /* this node doesn't have the requested data */
3254         if (orig_ttvn != req_ttvn ||
3255             !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
3256                                         ntohs(tt_data->num_vlan)))
3257                 goto out;
3258
3259         /* If the full table has been explicitly requested */
3260         if (tt_data->flags & BATADV_TT_FULL_TABLE ||
3261             !req_dst_orig_node->tt_buff)
3262                 full_table = true;
3263         else
3264                 full_table = false;
3265
3266         /* TT fragmentation hasn't been implemented yet, so send as many
3267          * TT entries fit a single packet as possible only
3268          */
3269         if (!full_table) {
3270                 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
3271                 tt_len = req_dst_orig_node->tt_buff_len;
3272
3273                 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
3274                                                               &tvlv_tt_data,
3275                                                               &tt_change,
3276                                                               &tt_len);
3277                 if (!tt_len)
3278                         goto unlock;
3279
3280                 /* Copy the last orig_node's OGM buffer */
3281                 memcpy(tt_change, req_dst_orig_node->tt_buff,
3282                        req_dst_orig_node->tt_buff_len);
3283                 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
3284         } else {
3285                 /* allocate the tvlv, put the tt_data and all the tt_vlan_data
3286                  * in the initial part
3287                  */
3288                 tt_len = -1;
3289                 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
3290                                                               &tvlv_tt_data,
3291                                                               &tt_change,
3292                                                               &tt_len);
3293                 if (!tt_len)
3294                         goto out;
3295
3296                 /* fill the rest of the tvlv with the real TT entries */
3297                 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,
3298                                         tt_change, tt_len,
3299                                         batadv_tt_global_valid,
3300                                         req_dst_orig_node);
3301         }
3302
3303         /* Don't send the response, if larger than fragmented packet. */
3304         tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;
3305         if (tt_len > atomic_read(&bat_priv->packet_size_max)) {
3306                 net_ratelimited_function(batadv_info, bat_priv->soft_iface,
3307                                          "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",
3308                                          res_dst_orig_node->orig);
3309                 goto out;
3310         }
3311
3312         tvlv_tt_data->flags = BATADV_TT_RESPONSE;
3313         tvlv_tt_data->ttvn = req_ttvn;
3314
3315         if (full_table)
3316                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
3317
3318         batadv_dbg(BATADV_DBG_TT, bat_priv,
3319                    "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",
3320                    res_dst_orig_node->orig, req_dst_orig_node->orig,
3321                    full_table ? 'F' : '.', req_ttvn);
3322
3323         batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
3324
3325         batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
3326                                  req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
3327                                  tvlv_len);
3328
3329         ret = true;
3330         goto out;
3331
3332 unlock:
3333         spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
3334
3335 out:
3336         if (res_dst_orig_node)
3337                 batadv_orig_node_put(res_dst_orig_node);
3338         if (req_dst_orig_node)
3339                 batadv_orig_node_put(req_dst_orig_node);
3340         kfree(tvlv_tt_data);
3341         return ret;
3342 }
3343
3344 /**
3345  * batadv_send_my_tt_response() - send reply to tt request concerning this
3346  *  node's translation table
3347  * @bat_priv: the bat priv with all the soft interface information
3348  * @tt_data: tt data containing the tt request information
3349  * @req_src: mac address of tt request sender
3350  *
3351  * Return: true if tt request reply was sent, false otherwise.
3352  */
3353 static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
3354                                        struct batadv_tvlv_tt_data *tt_data,
3355                                        u8 *req_src)
3356 {
3357         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
3358         struct batadv_hard_iface *primary_if = NULL;
3359         struct batadv_tvlv_tt_change *tt_change;
3360         struct batadv_orig_node *orig_node;
3361         u8 my_ttvn, req_ttvn;
3362         u16 tvlv_len;
3363         bool full_table;
3364         s32 tt_len;
3365
3366         batadv_dbg(BATADV_DBG_TT, bat_priv,
3367                    "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
3368                    req_src, tt_data->ttvn,
3369                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3370
3371         spin_lock_bh(&bat_priv->tt.commit_lock);
3372
3373         my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
3374         req_ttvn = tt_data->ttvn;
3375
3376         orig_node = batadv_orig_hash_find(bat_priv, req_src);
3377         if (!orig_node)
3378                 goto out;
3379
3380         primary_if = batadv_primary_if_get_selected(bat_priv);
3381         if (!primary_if)
3382                 goto out;
3383
3384         /* If the full table has been explicitly requested or the gap
3385          * is too big send the whole local translation table
3386          */
3387         if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
3388             !bat_priv->tt.last_changeset)
3389                 full_table = true;
3390         else
3391                 full_table = false;
3392
3393         /* TT fragmentation hasn't been implemented yet, so send as many
3394          * TT entries fit a single packet as possible only
3395          */
3396         if (!full_table) {
3397                 spin_lock_bh(&bat_priv->tt.last_changeset_lock);
3398
3399                 tt_len = bat_priv->tt.last_changeset_len;
3400                 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
3401                                                              &tvlv_tt_data,
3402                                                              &tt_change,
3403                                                              &tt_len);
3404                 if (!tt_len || !tvlv_len)
3405                         goto unlock;
3406
3407                 /* Copy the last orig_node's OGM buffer */
3408                 memcpy(tt_change, bat_priv->tt.last_changeset,
3409                        bat_priv->tt.last_changeset_len);
3410                 spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
3411         } else {
3412                 req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
3413
3414                 /* allocate the tvlv, put the tt_data and all the tt_vlan_data
3415                  * in the initial part
3416                  */
3417                 tt_len = -1;
3418                 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
3419                                                              &tvlv_tt_data,
3420                                                              &tt_change,
3421                                                              &tt_len);
3422                 if (!tt_len || !tvlv_len)
3423                         goto out;
3424
3425                 /* fill the rest of the tvlv with the real TT entries */
3426                 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,
3427                                         tt_change, tt_len,
3428                                         batadv_tt_local_valid, NULL);
3429         }
3430
3431         tvlv_tt_data->flags = BATADV_TT_RESPONSE;
3432         tvlv_tt_data->ttvn = req_ttvn;
3433
3434         if (full_table)
3435                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
3436
3437         batadv_dbg(BATADV_DBG_TT, bat_priv,
3438                    "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
3439                    orig_node->orig, full_table ? 'F' : '.', req_ttvn);
3440
3441         batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
3442
3443         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3444                                  req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
3445                                  tvlv_len);
3446
3447         goto out;
3448
3449 unlock:
3450         spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
3451 out:
3452         spin_unlock_bh(&bat_priv->tt.commit_lock);
3453         if (orig_node)
3454                 batadv_orig_node_put(orig_node);
3455         if (primary_if)
3456                 batadv_hardif_put(primary_if);
3457         kfree(tvlv_tt_data);
3458         /* The packet was for this host, so it doesn't need to be re-routed */
3459         return true;
3460 }
3461
3462 /**
3463  * batadv_send_tt_response() - send reply to tt request
3464  * @bat_priv: the bat priv with all the soft interface information
3465  * @tt_data: tt data containing the tt request information
3466  * @req_src: mac address of tt request sender
3467  * @req_dst: mac address of tt request recipient
3468  *
3469  * Return: true if tt request reply was sent, false otherwise.
3470  */
3471 static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
3472                                     struct batadv_tvlv_tt_data *tt_data,
3473                                     u8 *req_src, u8 *req_dst)
3474 {
3475         if (batadv_is_my_mac(bat_priv, req_dst))
3476                 return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
3477         return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
3478                                              req_dst);
3479 }
3480
3481 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
3482                                       struct batadv_orig_node *orig_node,
3483                                       struct batadv_tvlv_tt_change *tt_change,
3484                                       u16 tt_num_changes, u8 ttvn)
3485 {
3486         int i;
3487         int roams;
3488
3489         for (i = 0; i < tt_num_changes; i++) {
3490                 if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
3491                         roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
3492                         batadv_tt_global_del(bat_priv, orig_node,
3493                                              (tt_change + i)->addr,
3494                                              ntohs((tt_change + i)->vid),
3495                                              "tt removed by changes",
3496                                              roams);
3497                 } else {
3498                         if (!batadv_tt_global_add(bat_priv, orig_node,
3499                                                   (tt_change + i)->addr,
3500                                                   ntohs((tt_change + i)->vid),
3501                                                   (tt_change + i)->flags, ttvn))
3502                                 /* In case of problem while storing a
3503                                  * global_entry, we stop the updating
3504                                  * procedure without committing the
3505                                  * ttvn change. This will avoid to send
3506                                  * corrupted data on tt_request
3507                                  */
3508                                 return;
3509                 }
3510         }
3511         set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
3512 }
3513
3514 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
3515                                   struct batadv_tvlv_tt_change *tt_change,
3516                                   u8 ttvn, u8 *resp_src,
3517                                   u16 num_entries)
3518 {
3519         struct batadv_orig_node *orig_node;
3520
3521         orig_node = batadv_orig_hash_find(bat_priv, resp_src);
3522         if (!orig_node)
3523                 goto out;
3524
3525         /* Purge the old table first.. */
3526         batadv_tt_global_del_orig(bat_priv, orig_node, -1,
3527                                   "Received full table");
3528
3529         _batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
3530                                   ttvn);
3531
3532         spin_lock_bh(&orig_node->tt_buff_lock);
3533         kfree(orig_node->tt_buff);
3534         orig_node->tt_buff_len = 0;
3535         orig_node->tt_buff = NULL;
3536         spin_unlock_bh(&orig_node->tt_buff_lock);
3537
3538         atomic_set(&orig_node->last_ttvn, ttvn);
3539
3540 out:
3541         if (orig_node)
3542                 batadv_orig_node_put(orig_node);
3543 }
3544
3545 static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
3546                                      struct batadv_orig_node *orig_node,
3547                                      u16 tt_num_changes, u8 ttvn,
3548                                      struct batadv_tvlv_tt_change *tt_change)
3549 {
3550         _batadv_tt_update_changes(bat_priv, orig_node, tt_change,
3551                                   tt_num_changes, ttvn);
3552
3553         batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
3554                                    batadv_tt_len(tt_num_changes));
3555         atomic_set(&orig_node->last_ttvn, ttvn);
3556 }
3557
3558 /**
3559  * batadv_is_my_client() - check if a client is served by the local node
3560  * @bat_priv: the bat priv with all the soft interface information
3561  * @addr: the mac address of the client to check
3562  * @vid: VLAN identifier
3563  *
3564  * Return: true if the client is served by this node, false otherwise.
3565  */
3566 bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,
3567                          unsigned short vid)
3568 {
3569         struct batadv_tt_local_entry *tt_local_entry;
3570         bool ret = false;
3571
3572         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3573         if (!tt_local_entry)
3574                 goto out;
3575         /* Check if the client has been logically deleted (but is kept for
3576          * consistency purpose)
3577          */
3578         if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
3579             (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
3580                 goto out;
3581         ret = true;
3582 out:
3583         if (tt_local_entry)
3584                 batadv_tt_local_entry_put(tt_local_entry);
3585         return ret;
3586 }
3587
3588 /**
3589  * batadv_handle_tt_response() - process incoming tt reply
3590  * @bat_priv: the bat priv with all the soft interface information
3591  * @tt_data: tt data containing the tt request information
3592  * @resp_src: mac address of tt reply sender
3593  * @num_entries: number of tt change entries appended to the tt data
3594  */
3595 static void batadv_handle_tt_response(struct batadv_priv *bat_priv,
3596                                       struct batadv_tvlv_tt_data *tt_data,
3597                                       u8 *resp_src, u16 num_entries)
3598 {
3599         struct batadv_tt_req_node *node;
3600         struct hlist_node *safe;
3601         struct batadv_orig_node *orig_node = NULL;
3602         struct batadv_tvlv_tt_change *tt_change;
3603         u8 *tvlv_ptr = (u8 *)tt_data;
3604         u16 change_offset;
3605
3606         batadv_dbg(BATADV_DBG_TT, bat_priv,
3607                    "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
3608                    resp_src, tt_data->ttvn, num_entries,
3609                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3610
3611         orig_node = batadv_orig_hash_find(bat_priv, resp_src);
3612         if (!orig_node)
3613                 goto out;
3614
3615         spin_lock_bh(&orig_node->tt_lock);
3616
3617         change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);
3618         change_offset *= ntohs(tt_data->num_vlan);
3619         change_offset += sizeof(*tt_data);
3620         tvlv_ptr += change_offset;
3621
3622         tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;
3623         if (tt_data->flags & BATADV_TT_FULL_TABLE) {
3624                 batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
3625                                       resp_src, num_entries);
3626         } else {
3627                 batadv_tt_update_changes(bat_priv, orig_node, num_entries,
3628                                          tt_data->ttvn, tt_change);
3629         }
3630
3631         /* Recalculate the CRC for this orig_node and store it */
3632         batadv_tt_global_update_crc(bat_priv, orig_node);
3633
3634         spin_unlock_bh(&orig_node->tt_lock);
3635
3636         /* Delete the tt_req_node from pending tt_requests list */
3637         spin_lock_bh(&bat_priv->tt.req_list_lock);
3638         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
3639                 if (!batadv_compare_eth(node->addr, resp_src))
3640                         continue;
3641                 hlist_del_init(&node->list);
3642                 batadv_tt_req_node_put(node);
3643         }
3644
3645         spin_unlock_bh(&bat_priv->tt.req_list_lock);
3646 out:
3647         if (orig_node)
3648                 batadv_orig_node_put(orig_node);
3649 }
3650
3651 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
3652 {
3653         struct batadv_tt_roam_node *node, *safe;
3654
3655         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3656
3657         list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3658                 list_del(&node->list);
3659                 kmem_cache_free(batadv_tt_roam_cache, node);
3660         }
3661
3662         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3663 }
3664
3665 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
3666 {
3667         struct batadv_tt_roam_node *node, *safe;
3668
3669         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3670         list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3671                 if (!batadv_has_timed_out(node->first_time,
3672                                           BATADV_ROAMING_MAX_TIME))
3673                         continue;
3674
3675                 list_del(&node->list);
3676                 kmem_cache_free(batadv_tt_roam_cache, node);
3677         }
3678         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3679 }
3680
3681 /**
3682  * batadv_tt_check_roam_count() - check if a client has roamed too frequently
3683  * @bat_priv: the bat priv with all the soft interface information
3684  * @client: mac address of the roaming client
3685  *
3686  * This function checks whether the client already reached the
3687  * maximum number of possible roaming phases. In this case the ROAMING_ADV
3688  * will not be sent.
3689  *
3690  * Return: true if the ROAMING_ADV can be sent, false otherwise
3691  */
3692 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)
3693 {
3694         struct batadv_tt_roam_node *tt_roam_node;
3695         bool ret = false;
3696
3697         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3698         /* The new tt_req will be issued only if I'm not waiting for a
3699          * reply from the same orig_node yet
3700          */
3701         list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
3702                 if (!batadv_compare_eth(tt_roam_node->addr, client))
3703                         continue;
3704
3705                 if (batadv_has_timed_out(tt_roam_node->first_time,
3706                                          BATADV_ROAMING_MAX_TIME))
3707                         continue;
3708
3709                 if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
3710                         /* Sorry, you roamed too many times! */
3711                         goto unlock;
3712                 ret = true;
3713                 break;
3714         }
3715
3716         if (!ret) {
3717                 tt_roam_node = kmem_cache_alloc(batadv_tt_roam_cache,
3718                                                 GFP_ATOMIC);
3719                 if (!tt_roam_node)
3720                         goto unlock;
3721
3722                 tt_roam_node->first_time = jiffies;
3723                 atomic_set(&tt_roam_node->counter,
3724                            BATADV_ROAMING_MAX_COUNT - 1);
3725                 ether_addr_copy(tt_roam_node->addr, client);
3726
3727                 list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3728                 ret = true;
3729         }
3730
3731 unlock:
3732         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3733         return ret;
3734 }
3735
3736 /**
3737  * batadv_send_roam_adv() - send a roaming advertisement message
3738  * @bat_priv: the bat priv with all the soft interface information
3739  * @client: mac address of the roaming client
3740  * @vid: VLAN identifier
3741  * @orig_node: message destination
3742  *
3743  * Send a ROAMING_ADV message to the node which was previously serving this
3744  * client. This is done to inform the node that from now on all traffic destined
3745  * for this particular roamed client has to be forwarded to the sender of the
3746  * roaming message.
3747  */
3748 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
3749                                  unsigned short vid,
3750                                  struct batadv_orig_node *orig_node)
3751 {
3752         struct batadv_hard_iface *primary_if;
3753         struct batadv_tvlv_roam_adv tvlv_roam;
3754
3755         primary_if = batadv_primary_if_get_selected(bat_priv);
3756         if (!primary_if)
3757                 goto out;
3758
3759         /* before going on we have to check whether the client has
3760          * already roamed to us too many times
3761          */
3762         if (!batadv_tt_check_roam_count(bat_priv, client))
3763                 goto out;
3764
3765         batadv_dbg(BATADV_DBG_TT, bat_priv,
3766                    "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
3767                    orig_node->orig, client, batadv_print_vid(vid));
3768
3769         batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3770
3771         memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3772         tvlv_roam.vid = htons(vid);
3773
3774         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3775                                  orig_node->orig, BATADV_TVLV_ROAM, 1,
3776                                  &tvlv_roam, sizeof(tvlv_roam));
3777
3778 out:
3779         if (primary_if)
3780                 batadv_hardif_put(primary_if);
3781 }
3782
3783 static void batadv_tt_purge(struct work_struct *work)
3784 {
3785         struct delayed_work *delayed_work;
3786         struct batadv_priv_tt *priv_tt;
3787         struct batadv_priv *bat_priv;
3788
3789         delayed_work = to_delayed_work(work);
3790         priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
3791         bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3792
3793         batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3794         batadv_tt_global_purge(bat_priv);
3795         batadv_tt_req_purge(bat_priv);
3796         batadv_tt_roam_purge(bat_priv);
3797
3798         queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3799                            msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3800 }
3801
3802 /**
3803  * batadv_tt_free() - Free translation table of soft interface
3804  * @bat_priv: the bat priv with all the soft interface information
3805  */
3806 void batadv_tt_free(struct batadv_priv *bat_priv)
3807 {
3808         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
3809         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);
3810
3811         cancel_delayed_work_sync(&bat_priv->tt.work);
3812
3813         batadv_tt_local_table_free(bat_priv);
3814         batadv_tt_global_table_free(bat_priv);
3815         batadv_tt_req_list_free(bat_priv);
3816         batadv_tt_changes_list_free(bat_priv);
3817         batadv_tt_roam_list_free(bat_priv);
3818
3819         kfree(bat_priv->tt.last_changeset);
3820 }
3821
3822 /**
3823  * batadv_tt_local_set_flags() - set or unset the specified flags on the local
3824  *  table and possibly count them in the TT size
3825  * @bat_priv: the bat priv with all the soft interface information
3826  * @flags: the flag to switch
3827  * @enable: whether to set or unset the flag
3828  * @count: whether to increase the TT size by the number of changed entries
3829  */
3830 static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,
3831                                       bool enable, bool count)
3832 {
3833         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3834         struct batadv_tt_common_entry *tt_common_entry;
3835         struct hlist_head *head;
3836         u32 i;
3837
3838         if (!hash)
3839                 return;
3840
3841         for (i = 0; i < hash->size; i++) {
3842                 head = &hash->table[i];
3843
3844                 rcu_read_lock();
3845                 hlist_for_each_entry_rcu(tt_common_entry,
3846                                          head, hash_entry) {
3847                         if (enable) {
3848                                 if ((tt_common_entry->flags & flags) == flags)
3849                                         continue;
3850                                 tt_common_entry->flags |= flags;
3851                         } else {
3852                                 if (!(tt_common_entry->flags & flags))
3853                                         continue;
3854                                 tt_common_entry->flags &= ~flags;
3855                         }
3856
3857                         if (!count)
3858                                 continue;
3859
3860                         batadv_tt_local_size_inc(bat_priv,
3861                                                  tt_common_entry->vid);
3862                 }
3863                 rcu_read_unlock();
3864         }
3865 }
3866
3867 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
3868 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3869 {
3870         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3871         struct batadv_tt_common_entry *tt_common;
3872         struct batadv_tt_local_entry *tt_local;
3873         struct hlist_node *node_tmp;
3874         struct hlist_head *head;
3875         spinlock_t *list_lock; /* protects write access to the hash lists */
3876         u32 i;
3877
3878         if (!hash)
3879                 return;
3880
3881         for (i = 0; i < hash->size; i++) {
3882                 head = &hash->table[i];
3883                 list_lock = &hash->list_locks[i];
3884
3885                 spin_lock_bh(list_lock);
3886                 hlist_for_each_entry_safe(tt_common, node_tmp, head,
3887                                           hash_entry) {
3888                         if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3889                                 continue;
3890
3891                         batadv_dbg(BATADV_DBG_TT, bat_priv,
3892                                    "Deleting local tt entry (%pM, vid: %d): pending\n",
3893                                    tt_common->addr,
3894                                    batadv_print_vid(tt_common->vid));
3895
3896                         batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3897                         hlist_del_rcu(&tt_common->hash_entry);
3898                         tt_local = container_of(tt_common,
3899                                                 struct batadv_tt_local_entry,
3900                                                 common);
3901
3902                         batadv_tt_local_entry_put(tt_local);
3903                 }
3904                 spin_unlock_bh(list_lock);
3905         }
3906 }
3907
3908 /**
3909  * batadv_tt_local_commit_changes_nolock() - commit all pending local tt changes
3910  *  which have been queued in the time since the last commit
3911  * @bat_priv: the bat priv with all the soft interface information
3912  *
3913  * Caller must hold tt->commit_lock.
3914  */
3915 static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3916 {
3917         lockdep_assert_held(&bat_priv->tt.commit_lock);
3918
3919         if (atomic_read(&bat_priv->tt.local_changes) < 1) {
3920                 if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))
3921                         batadv_tt_tvlv_container_update(bat_priv);
3922                 return;
3923         }
3924
3925         batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3926
3927         batadv_tt_local_purge_pending_clients(bat_priv);
3928         batadv_tt_local_update_crc(bat_priv);
3929
3930         /* Increment the TTVN only once per OGM interval */
3931         atomic_inc(&bat_priv->tt.vn);
3932         batadv_dbg(BATADV_DBG_TT, bat_priv,
3933                    "Local changes committed, updating to ttvn %u\n",
3934                    (u8)atomic_read(&bat_priv->tt.vn));
3935
3936         /* reset the sending counter */
3937         atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3938         batadv_tt_tvlv_container_update(bat_priv);
3939 }
3940
3941 /**
3942  * batadv_tt_local_commit_changes() - commit all pending local tt changes which
3943  *  have been queued in the time since the last commit
3944  * @bat_priv: the bat priv with all the soft interface information
3945  */
3946 void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)
3947 {
3948         spin_lock_bh(&bat_priv->tt.commit_lock);
3949         batadv_tt_local_commit_changes_nolock(bat_priv);
3950         spin_unlock_bh(&bat_priv->tt.commit_lock);
3951 }
3952
3953 /**
3954  * batadv_is_ap_isolated() - Check if packet from upper layer should be dropped
3955  * @bat_priv: the bat priv with all the soft interface information
3956  * @src: source mac address of packet
3957  * @dst: destination mac address of packet
3958  * @vid: vlan id of packet
3959  *
3960  * Return: true when src+dst(+vid) pair should be isolated, false otherwise
3961  */
3962 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,
3963                            unsigned short vid)
3964 {
3965         struct batadv_tt_local_entry *tt_local_entry;
3966         struct batadv_tt_global_entry *tt_global_entry;
3967         struct batadv_softif_vlan *vlan;
3968         bool ret = false;
3969
3970         vlan = batadv_softif_vlan_get(bat_priv, vid);
3971         if (!vlan)
3972                 return false;
3973
3974         if (!atomic_read(&vlan->ap_isolation))
3975                 goto vlan_put;
3976
3977         tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3978         if (!tt_local_entry)
3979                 goto vlan_put;
3980
3981         tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3982         if (!tt_global_entry)
3983                 goto local_entry_put;
3984
3985         if (_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3986                 ret = true;
3987
3988         batadv_tt_global_entry_put(tt_global_entry);
3989 local_entry_put:
3990         batadv_tt_local_entry_put(tt_local_entry);
3991 vlan_put:
3992         batadv_softif_vlan_put(vlan);
3993         return ret;
3994 }
3995
3996 /**
3997  * batadv_tt_update_orig() - update global translation table with new tt
3998  *  information received via ogms
3999  * @bat_priv: the bat priv with all the soft interface information
4000  * @orig_node: the orig_node of the ogm
4001  * @tt_buff: pointer to the first tvlv VLAN entry
4002  * @tt_num_vlan: number of tvlv VLAN entries
4003  * @tt_change: pointer to the first entry in the TT buffer
4004  * @tt_num_changes: number of tt changes inside the tt buffer
4005  * @ttvn: translation table version number of this changeset
4006  */
4007 static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
4008                                   struct batadv_orig_node *orig_node,
4009                                   const void *tt_buff, u16 tt_num_vlan,
4010                                   struct batadv_tvlv_tt_change *tt_change,
4011                                   u16 tt_num_changes, u8 ttvn)
4012 {
4013         u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
4014         struct batadv_tvlv_tt_vlan_data *tt_vlan;
4015         bool full_table = true;
4016         bool has_tt_init;
4017
4018         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
4019         has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,
4020                                &orig_node->capa_initialized);
4021
4022         /* orig table not initialised AND first diff is in the OGM OR the ttvn
4023          * increased by one -> we can apply the attached changes
4024          */
4025         if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
4026                 /* the OGM could not contain the changes due to their size or
4027                  * because they have already been sent BATADV_TT_OGM_APPEND_MAX
4028                  * times.
4029                  * In this case send a tt request
4030                  */
4031                 if (!tt_num_changes) {
4032                         full_table = false;
4033                         goto request_table;
4034                 }
4035
4036                 spin_lock_bh(&orig_node->tt_lock);
4037
4038                 batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
4039                                          ttvn, tt_change);
4040
4041                 /* Even if we received the precomputed crc with the OGM, we
4042                  * prefer to recompute it to spot any possible inconsistency
4043                  * in the global table
4044                  */
4045                 batadv_tt_global_update_crc(bat_priv, orig_node);
4046
4047                 spin_unlock_bh(&orig_node->tt_lock);
4048
4049                 /* The ttvn alone is not enough to guarantee consistency
4050                  * because a single value could represent different states
4051                  * (due to the wrap around). Thus a node has to check whether
4052                  * the resulting table (after applying the changes) is still
4053                  * consistent or not. E.g. a node could disconnect while its
4054                  * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
4055                  * checking the CRC value is mandatory to detect the
4056                  * inconsistency
4057                  */
4058                 if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
4059                                                 tt_num_vlan))
4060                         goto request_table;
4061         } else {
4062                 /* if we missed more than one change or our tables are not
4063                  * in sync anymore -> request fresh tt data
4064                  */
4065                 if (!has_tt_init || ttvn != orig_ttvn ||
4066                     !batadv_tt_global_check_crc(orig_node, tt_vlan,
4067                                                 tt_num_vlan)) {
4068 request_table:
4069                         batadv_dbg(BATADV_DBG_TT, bat_priv,
4070                                    "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",
4071                                    orig_node->orig, ttvn, orig_ttvn,
4072                                    tt_num_changes);
4073                         batadv_send_tt_request(bat_priv, orig_node, ttvn,
4074                                                tt_vlan, tt_num_vlan,
4075                                                full_table);
4076                         return;
4077                 }
4078         }
4079 }
4080
4081 /**
4082  * batadv_tt_global_client_is_roaming() - check if a client is marked as roaming
4083  * @bat_priv: the bat priv with all the soft interface information
4084  * @addr: the mac address of the client to check
4085  * @vid: VLAN identifier
4086  *
4087  * Return: true if we know that the client has moved from its old originator
4088  * to another one. This entry is still kept for consistency purposes and will be
4089  * deleted later by a DEL or because of timeout
4090  */
4091 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
4092                                         u8 *addr, unsigned short vid)
4093 {
4094         struct batadv_tt_global_entry *tt_global_entry;
4095         bool ret = false;
4096
4097         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
4098         if (!tt_global_entry)
4099                 goto out;
4100
4101         ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
4102         batadv_tt_global_entry_put(tt_global_entry);
4103 out:
4104         return ret;
4105 }
4106
4107 /**
4108  * batadv_tt_local_client_is_roaming() - tells whether the client is roaming
4109  * @bat_priv: the bat priv with all the soft interface information
4110  * @addr: the mac address of the local client to query
4111  * @vid: VLAN identifier
4112  *
4113  * Return: true if the local client is known to be roaming (it is not served by
4114  * this node anymore) or not. If yes, the client is still present in the table
4115  * to keep the latter consistent with the node TTVN
4116  */
4117 bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
4118                                        u8 *addr, unsigned short vid)
4119 {
4120         struct batadv_tt_local_entry *tt_local_entry;
4121         bool ret = false;
4122
4123         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
4124         if (!tt_local_entry)
4125                 goto out;
4126
4127         ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
4128         batadv_tt_local_entry_put(tt_local_entry);
4129 out:
4130         return ret;
4131 }
4132
4133 /**
4134  * batadv_tt_add_temporary_global_entry() - Add temporary entry to global TT
4135  * @bat_priv: the bat priv with all the soft interface information
4136  * @orig_node: orig node which the temporary entry should be associated with
4137  * @addr: mac address of the client
4138  * @vid: VLAN id of the new temporary global translation table
4139  *
4140  * Return: true when temporary tt entry could be added, false otherwise
4141  */
4142 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
4143                                           struct batadv_orig_node *orig_node,
4144                                           const unsigned char *addr,
4145                                           unsigned short vid)
4146 {
4147         /* ignore loop detect macs, they are not supposed to be in the tt local
4148          * data as well.
4149          */
4150         if (batadv_bla_is_loopdetect_mac(addr))
4151                 return false;
4152
4153         if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
4154                                   BATADV_TT_CLIENT_TEMP,
4155                                   atomic_read(&orig_node->last_ttvn)))
4156                 return false;
4157
4158         batadv_dbg(BATADV_DBG_TT, bat_priv,
4159                    "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
4160                    addr, batadv_print_vid(vid), orig_node->orig);
4161
4162         return true;
4163 }
4164
4165 /**
4166  * batadv_tt_local_resize_to_mtu() - resize the local translation table fit the
4167  *  maximum packet size that can be transported through the mesh
4168  * @soft_iface: netdev struct of the mesh interface
4169  *
4170  * Remove entries older than 'timeout' and half timeout if more entries need
4171  * to be removed.
4172  */
4173 void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)
4174 {
4175         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
4176         int packet_size_max = atomic_read(&bat_priv->packet_size_max);
4177         int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;
4178         bool reduced = false;
4179
4180         spin_lock_bh(&bat_priv->tt.commit_lock);
4181
4182         while (true) {
4183                 table_size = batadv_tt_local_table_transmit_size(bat_priv);
4184                 if (packet_size_max >= table_size)
4185                         break;
4186
4187                 batadv_tt_local_purge(bat_priv, timeout);
4188                 batadv_tt_local_purge_pending_clients(bat_priv);
4189
4190                 timeout /= 2;
4191                 reduced = true;
4192                 net_ratelimited_function(batadv_info, soft_iface,
4193                                          "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",
4194                                          packet_size_max);
4195         }
4196
4197         /* commit these changes immediately, to avoid synchronization problem
4198          * with the TTVN
4199          */
4200         if (reduced)
4201                 batadv_tt_local_commit_changes_nolock(bat_priv);
4202
4203         spin_unlock_bh(&bat_priv->tt.commit_lock);
4204 }
4205
4206 /**
4207  * batadv_tt_tvlv_ogm_handler_v1() - process incoming tt tvlv container
4208  * @bat_priv: the bat priv with all the soft interface information
4209  * @orig: the orig_node of the ogm
4210  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
4211  * @tvlv_value: tvlv buffer containing the gateway data
4212  * @tvlv_value_len: tvlv buffer length
4213  */
4214 static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
4215                                           struct batadv_orig_node *orig,
4216                                           u8 flags, void *tvlv_value,
4217                                           u16 tvlv_value_len)
4218 {
4219         struct batadv_tvlv_tt_vlan_data *tt_vlan;
4220         struct batadv_tvlv_tt_change *tt_change;
4221         struct batadv_tvlv_tt_data *tt_data;
4222         u16 num_entries, num_vlan;
4223
4224         if (tvlv_value_len < sizeof(*tt_data))
4225                 return;
4226
4227         tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
4228         tvlv_value_len -= sizeof(*tt_data);
4229
4230         num_vlan = ntohs(tt_data->num_vlan);
4231
4232         if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)
4233                 return;
4234
4235         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
4236         tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);
4237         tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;
4238
4239         num_entries = batadv_tt_entries(tvlv_value_len);
4240
4241         batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
4242                               num_entries, tt_data->ttvn);
4243 }
4244
4245 /**
4246  * batadv_tt_tvlv_unicast_handler_v1() - process incoming (unicast) tt tvlv
4247  *  container
4248  * @bat_priv: the bat priv with all the soft interface information
4249  * @src: mac address of tt tvlv sender
4250  * @dst: mac address of tt tvlv recipient
4251  * @tvlv_value: tvlv buffer containing the tt data
4252  * @tvlv_value_len: tvlv buffer length
4253  *
4254  * Return: NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS
4255  * otherwise.
4256  */
4257 static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
4258                                              u8 *src, u8 *dst,
4259                                              void *tvlv_value,
4260                                              u16 tvlv_value_len)
4261 {
4262         struct batadv_tvlv_tt_data *tt_data;
4263         u16 tt_vlan_len, tt_num_entries;
4264         char tt_flag;
4265         bool ret;
4266
4267         if (tvlv_value_len < sizeof(*tt_data))
4268                 return NET_RX_SUCCESS;
4269
4270         tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
4271         tvlv_value_len -= sizeof(*tt_data);
4272
4273         tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);
4274         tt_vlan_len *= ntohs(tt_data->num_vlan);
4275
4276         if (tvlv_value_len < tt_vlan_len)
4277                 return NET_RX_SUCCESS;
4278
4279         tvlv_value_len -= tt_vlan_len;
4280         tt_num_entries = batadv_tt_entries(tvlv_value_len);
4281
4282         switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {
4283         case BATADV_TT_REQUEST:
4284                 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
4285
4286                 /* If this node cannot provide a TT response the tt_request is
4287                  * forwarded
4288                  */
4289                 ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);
4290                 if (!ret) {
4291                         if (tt_data->flags & BATADV_TT_FULL_TABLE)
4292                                 tt_flag = 'F';
4293                         else
4294                                 tt_flag = '.';
4295
4296                         batadv_dbg(BATADV_DBG_TT, bat_priv,
4297                                    "Routing TT_REQUEST to %pM [%c]\n",
4298                                    dst, tt_flag);
4299                         /* tvlv API will re-route the packet */
4300                         return NET_RX_DROP;
4301                 }
4302                 break;
4303         case BATADV_TT_RESPONSE:
4304                 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
4305
4306                 if (batadv_is_my_mac(bat_priv, dst)) {
4307                         batadv_handle_tt_response(bat_priv, tt_data,
4308                                                   src, tt_num_entries);
4309                         return NET_RX_SUCCESS;
4310                 }
4311
4312                 if (tt_data->flags & BATADV_TT_FULL_TABLE)
4313                         tt_flag =  'F';
4314                 else
4315                         tt_flag = '.';
4316
4317                 batadv_dbg(BATADV_DBG_TT, bat_priv,
4318                            "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);
4319
4320                 /* tvlv API will re-route the packet */
4321                 return NET_RX_DROP;
4322         }
4323
4324         return NET_RX_SUCCESS;
4325 }
4326
4327 /**
4328  * batadv_roam_tvlv_unicast_handler_v1() - process incoming tt roam tvlv
4329  *  container
4330  * @bat_priv: the bat priv with all the soft interface information
4331  * @src: mac address of tt tvlv sender
4332  * @dst: mac address of tt tvlv recipient
4333  * @tvlv_value: tvlv buffer containing the tt data
4334  * @tvlv_value_len: tvlv buffer length
4335  *
4336  * Return: NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS
4337  * otherwise.
4338  */
4339 static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
4340                                                u8 *src, u8 *dst,
4341                                                void *tvlv_value,
4342                                                u16 tvlv_value_len)
4343 {
4344         struct batadv_tvlv_roam_adv *roaming_adv;
4345         struct batadv_orig_node *orig_node = NULL;
4346
4347         /* If this node is not the intended recipient of the
4348          * roaming advertisement the packet is forwarded
4349          * (the tvlv API will re-route the packet).
4350          */
4351         if (!batadv_is_my_mac(bat_priv, dst))
4352                 return NET_RX_DROP;
4353
4354         if (tvlv_value_len < sizeof(*roaming_adv))
4355                 goto out;
4356
4357         orig_node = batadv_orig_hash_find(bat_priv, src);
4358         if (!orig_node)
4359                 goto out;
4360
4361         batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
4362         roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;
4363
4364         batadv_dbg(BATADV_DBG_TT, bat_priv,
4365                    "Received ROAMING_ADV from %pM (client %pM)\n",
4366                    src, roaming_adv->client);
4367
4368         batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,
4369                              ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
4370                              atomic_read(&orig_node->last_ttvn) + 1);
4371
4372 out:
4373         if (orig_node)
4374                 batadv_orig_node_put(orig_node);
4375         return NET_RX_SUCCESS;
4376 }
4377
4378 /**
4379  * batadv_tt_init() - initialise the translation table internals
4380  * @bat_priv: the bat priv with all the soft interface information
4381  *
4382  * Return: 0 on success or negative error number in case of failure.
4383  */
4384 int batadv_tt_init(struct batadv_priv *bat_priv)
4385 {
4386         int ret;
4387
4388         /* synchronized flags must be remote */
4389         BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));
4390
4391         ret = batadv_tt_local_init(bat_priv);
4392         if (ret < 0)
4393                 return ret;
4394
4395         ret = batadv_tt_global_init(bat_priv);
4396         if (ret < 0)
4397                 return ret;
4398
4399         batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,
4400                                      batadv_tt_tvlv_unicast_handler_v1,
4401                                      BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
4402
4403         batadv_tvlv_handler_register(bat_priv, NULL,
4404                                      batadv_roam_tvlv_unicast_handler_v1,
4405                                      BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);
4406
4407         INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
4408         queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
4409                            msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
4410
4411         return 1;
4412 }
4413
4414 /**
4415  * batadv_tt_global_is_isolated() - check if a client is marked as isolated
4416  * @bat_priv: the bat priv with all the soft interface information
4417  * @addr: the mac address of the client
4418  * @vid: the identifier of the VLAN where this client is connected
4419  *
4420  * Return: true if the client is marked with the TT_CLIENT_ISOLA flag, false
4421  * otherwise
4422  */
4423 bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
4424                                   const u8 *addr, unsigned short vid)
4425 {
4426         struct batadv_tt_global_entry *tt;
4427         bool ret;
4428
4429         tt = batadv_tt_global_hash_find(bat_priv, addr, vid);
4430         if (!tt)
4431                 return false;
4432
4433         ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;
4434
4435         batadv_tt_global_entry_put(tt);
4436
4437         return ret;
4438 }
4439
4440 /**
4441  * batadv_tt_cache_init() - Initialize tt memory object cache
4442  *
4443  * Return: 0 on success or negative error number in case of failure.
4444  */
4445 int __init batadv_tt_cache_init(void)
4446 {
4447         size_t tl_size = sizeof(struct batadv_tt_local_entry);
4448         size_t tg_size = sizeof(struct batadv_tt_global_entry);
4449         size_t tt_orig_size = sizeof(struct batadv_tt_orig_list_entry);
4450         size_t tt_change_size = sizeof(struct batadv_tt_change_node);
4451         size_t tt_req_size = sizeof(struct batadv_tt_req_node);
4452         size_t tt_roam_size = sizeof(struct batadv_tt_roam_node);
4453
4454         batadv_tl_cache = kmem_cache_create("batadv_tl_cache", tl_size, 0,
4455                                             SLAB_HWCACHE_ALIGN, NULL);
4456         if (!batadv_tl_cache)
4457                 return -ENOMEM;
4458
4459         batadv_tg_cache = kmem_cache_create("batadv_tg_cache", tg_size, 0,
4460                                             SLAB_HWCACHE_ALIGN, NULL);
4461         if (!batadv_tg_cache)
4462                 goto err_tt_tl_destroy;
4463
4464         batadv_tt_orig_cache = kmem_cache_create("batadv_tt_orig_cache",
4465                                                  tt_orig_size, 0,
4466                                                  SLAB_HWCACHE_ALIGN, NULL);
4467         if (!batadv_tt_orig_cache)
4468                 goto err_tt_tg_destroy;
4469
4470         batadv_tt_change_cache = kmem_cache_create("batadv_tt_change_cache",
4471                                                    tt_change_size, 0,
4472                                                    SLAB_HWCACHE_ALIGN, NULL);
4473         if (!batadv_tt_change_cache)
4474                 goto err_tt_orig_destroy;
4475
4476         batadv_tt_req_cache = kmem_cache_create("batadv_tt_req_cache",
4477                                                 tt_req_size, 0,
4478                                                 SLAB_HWCACHE_ALIGN, NULL);
4479         if (!batadv_tt_req_cache)
4480                 goto err_tt_change_destroy;
4481
4482         batadv_tt_roam_cache = kmem_cache_create("batadv_tt_roam_cache",
4483                                                  tt_roam_size, 0,
4484                                                  SLAB_HWCACHE_ALIGN, NULL);
4485         if (!batadv_tt_roam_cache)
4486                 goto err_tt_req_destroy;
4487
4488         return 0;
4489
4490 err_tt_req_destroy:
4491         kmem_cache_destroy(batadv_tt_req_cache);
4492         batadv_tt_req_cache = NULL;
4493 err_tt_change_destroy:
4494         kmem_cache_destroy(batadv_tt_change_cache);
4495         batadv_tt_change_cache = NULL;
4496 err_tt_orig_destroy:
4497         kmem_cache_destroy(batadv_tt_orig_cache);
4498         batadv_tt_orig_cache = NULL;
4499 err_tt_tg_destroy:
4500         kmem_cache_destroy(batadv_tg_cache);
4501         batadv_tg_cache = NULL;
4502 err_tt_tl_destroy:
4503         kmem_cache_destroy(batadv_tl_cache);
4504         batadv_tl_cache = NULL;
4505
4506         return -ENOMEM;
4507 }
4508
4509 /**
4510  * batadv_tt_cache_destroy() - Destroy tt memory object cache
4511  */
4512 void batadv_tt_cache_destroy(void)
4513 {
4514         kmem_cache_destroy(batadv_tl_cache);
4515         kmem_cache_destroy(batadv_tg_cache);
4516         kmem_cache_destroy(batadv_tt_orig_cache);
4517         kmem_cache_destroy(batadv_tt_change_cache);
4518         kmem_cache_destroy(batadv_tt_req_cache);
4519         kmem_cache_destroy(batadv_tt_roam_cache);
4520 }