net/batman-adv/translation-table.c

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