net/batman-adv/translation-table.c

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