kernel/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                 tt_global_entry->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         u32 crc;
2421         int i;
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         return true;
2448 }
2449
2450 /**
2451  * batadv_tt_local_update_crc - update all the local CRCs
2452  * @bat_priv: the bat priv with all the soft interface information
2453  */
2454 static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)
2455 {
2456         struct batadv_softif_vlan *vlan;
2457
2458         /* recompute the global CRC for each VLAN */
2459         rcu_read_lock();
2460         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
2461                 vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);
2462         }
2463         rcu_read_unlock();
2464 }
2465
2466 /**
2467  * batadv_tt_global_update_crc - update all the global CRCs for this orig_node
2468  * @bat_priv: the bat priv with all the soft interface information
2469  * @orig_node: the orig_node for which the CRCs have to be updated
2470  */
2471 static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
2472                                         struct batadv_orig_node *orig_node)
2473 {
2474         struct batadv_orig_node_vlan *vlan;
2475         u32 crc;
2476
2477         /* recompute the global CRC for each VLAN */
2478         rcu_read_lock();
2479         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
2480                 /* if orig_node is a backbone node for this VLAN, don't compute
2481                  * the CRC as we ignore all the global entries over it
2482                  */
2483                 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
2484                                                    vlan->vid))
2485                         continue;
2486
2487                 crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);
2488                 vlan->tt.crc = crc;
2489         }
2490         rcu_read_unlock();
2491 }
2492
2493 /**
2494  * batadv_send_tt_request - send a TT Request message to a given node
2495  * @bat_priv: the bat priv with all the soft interface information
2496  * @dst_orig_node: the destination of the message
2497  * @ttvn: the version number that the source of the message is looking for
2498  * @tt_vlan: pointer to the first tvlv VLAN object to request
2499  * @num_vlan: number of tvlv VLAN entries
2500  * @full_table: ask for the entire translation table if true, while only for the
2501  *  last TT diff otherwise
2502  */
2503 static int batadv_send_tt_request(struct batadv_priv *bat_priv,
2504                                   struct batadv_orig_node *dst_orig_node,
2505                                   u8 ttvn,
2506                                   struct batadv_tvlv_tt_vlan_data *tt_vlan,
2507                                   u16 num_vlan, bool full_table)
2508 {
2509         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2510         struct batadv_tt_req_node *tt_req_node = NULL;
2511         struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
2512         struct batadv_hard_iface *primary_if;
2513         bool ret = false;
2514         int i, size;
2515
2516         primary_if = batadv_primary_if_get_selected(bat_priv);
2517         if (!primary_if)
2518                 goto out;
2519
2520         /* The new tt_req will be issued only if I'm not waiting for a
2521          * reply from the same orig_node yet
2522          */
2523         tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);
2524         if (!tt_req_node)
2525                 goto out;
2526
2527         size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
2528         tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
2529         if (!tvlv_tt_data)
2530                 goto out;
2531
2532         tvlv_tt_data->flags = BATADV_TT_REQUEST;
2533         tvlv_tt_data->ttvn = ttvn;
2534         tvlv_tt_data->num_vlan = htons(num_vlan);
2535
2536         /* send all the CRCs within the request. This is needed by intermediate
2537          * nodes to ensure they have the correct table before replying
2538          */
2539         tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);
2540         for (i = 0; i < num_vlan; i++) {
2541                 tt_vlan_req->vid = tt_vlan->vid;
2542                 tt_vlan_req->crc = tt_vlan->crc;
2543
2544                 tt_vlan_req++;
2545                 tt_vlan++;
2546         }
2547
2548         if (full_table)
2549                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2550
2551         batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",
2552                    dst_orig_node->orig, full_table ? 'F' : '.');
2553
2554         batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
2555         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2556                                  dst_orig_node->orig, BATADV_TVLV_TT, 1,
2557                                  tvlv_tt_data, size);
2558         ret = true;
2559
2560 out:
2561         if (primary_if)
2562                 batadv_hardif_free_ref(primary_if);
2563         if (ret && tt_req_node) {
2564                 spin_lock_bh(&bat_priv->tt.req_list_lock);
2565                 /* hlist_del_init() verifies tt_req_node still is in the list */
2566                 hlist_del_init(&tt_req_node->list);
2567                 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2568                 kfree(tt_req_node);
2569         }
2570         kfree(tvlv_tt_data);
2571         return ret;
2572 }
2573
2574 /**
2575  * batadv_send_other_tt_response - send reply to tt request concerning another
2576  *  node's translation table
2577  * @bat_priv: the bat priv with all the soft interface information
2578  * @tt_data: tt data containing the tt request information
2579  * @req_src: mac address of tt request sender
2580  * @req_dst: mac address of tt request recipient
2581  *
2582  * Returns true if tt request reply was sent, false otherwise.
2583  */
2584 static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
2585                                           struct batadv_tvlv_tt_data *tt_data,
2586                                           u8 *req_src, u8 *req_dst)
2587 {
2588         struct batadv_orig_node *req_dst_orig_node;
2589         struct batadv_orig_node *res_dst_orig_node = NULL;
2590         struct batadv_tvlv_tt_change *tt_change;
2591         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2592         struct batadv_tvlv_tt_vlan_data *tt_vlan;
2593         bool ret = false, full_table;
2594         u8 orig_ttvn, req_ttvn;
2595         u16 tvlv_len;
2596         s32 tt_len;
2597
2598         batadv_dbg(BATADV_DBG_TT, bat_priv,
2599                    "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
2600                    req_src, tt_data->ttvn, req_dst,
2601                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2602
2603         /* Let's get the orig node of the REAL destination */
2604         req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
2605         if (!req_dst_orig_node)
2606                 goto out;
2607
2608         res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
2609         if (!res_dst_orig_node)
2610                 goto out;
2611
2612         orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);
2613         req_ttvn = tt_data->ttvn;
2614
2615         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
2616         /* this node doesn't have the requested data */
2617         if (orig_ttvn != req_ttvn ||
2618             !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
2619                                         ntohs(tt_data->num_vlan)))
2620                 goto out;
2621
2622         /* If the full table has been explicitly requested */
2623         if (tt_data->flags & BATADV_TT_FULL_TABLE ||
2624             !req_dst_orig_node->tt_buff)
2625                 full_table = true;
2626         else
2627                 full_table = false;
2628
2629         /* TT fragmentation hasn't been implemented yet, so send as many
2630          * TT entries fit a single packet as possible only
2631          */
2632         if (!full_table) {
2633                 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
2634                 tt_len = req_dst_orig_node->tt_buff_len;
2635
2636                 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
2637                                                               &tvlv_tt_data,
2638                                                               &tt_change,
2639                                                               &tt_len);
2640                 if (!tt_len)
2641                         goto unlock;
2642
2643                 /* Copy the last orig_node's OGM buffer */
2644                 memcpy(tt_change, req_dst_orig_node->tt_buff,
2645                        req_dst_orig_node->tt_buff_len);
2646                 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
2647         } else {
2648                 /* allocate the tvlv, put the tt_data and all the tt_vlan_data
2649                  * in the initial part
2650                  */
2651                 tt_len = -1;
2652                 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
2653                                                               &tvlv_tt_data,
2654                                                               &tt_change,
2655                                                               &tt_len);
2656                 if (!tt_len)
2657                         goto out;
2658
2659                 /* fill the rest of the tvlv with the real TT entries */
2660                 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,
2661                                         tt_change, tt_len,
2662                                         batadv_tt_global_valid,
2663                                         req_dst_orig_node);
2664         }
2665
2666         /* Don't send the response, if larger than fragmented packet. */
2667         tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;
2668         if (tt_len > atomic_read(&bat_priv->packet_size_max)) {
2669                 net_ratelimited_function(batadv_info, bat_priv->soft_iface,
2670                                          "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",
2671                                          res_dst_orig_node->orig);
2672                 goto out;
2673         }
2674
2675         tvlv_tt_data->flags = BATADV_TT_RESPONSE;
2676         tvlv_tt_data->ttvn = req_ttvn;
2677
2678         if (full_table)
2679                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2680
2681         batadv_dbg(BATADV_DBG_TT, bat_priv,
2682                    "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",
2683                    res_dst_orig_node->orig, req_dst_orig_node->orig,
2684                    full_table ? 'F' : '.', req_ttvn);
2685
2686         batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2687
2688         batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
2689                                  req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
2690                                  tvlv_len);
2691
2692         ret = true;
2693         goto out;
2694
2695 unlock:
2696         spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
2697
2698 out:
2699         if (res_dst_orig_node)
2700                 batadv_orig_node_free_ref(res_dst_orig_node);
2701         if (req_dst_orig_node)
2702                 batadv_orig_node_free_ref(req_dst_orig_node);
2703         kfree(tvlv_tt_data);
2704         return ret;
2705 }
2706
2707 /**
2708  * batadv_send_my_tt_response - send reply to tt request concerning this node's
2709  *  translation table
2710  * @bat_priv: the bat priv with all the soft interface information
2711  * @tt_data: tt data containing the tt request information
2712  * @req_src: mac address of tt request sender
2713  *
2714  * Returns true if tt request reply was sent, false otherwise.
2715  */
2716 static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
2717                                        struct batadv_tvlv_tt_data *tt_data,
2718                                        u8 *req_src)
2719 {
2720         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2721         struct batadv_hard_iface *primary_if = NULL;
2722         struct batadv_tvlv_tt_change *tt_change;
2723         struct batadv_orig_node *orig_node;
2724         u8 my_ttvn, req_ttvn;
2725         u16 tvlv_len;
2726         bool full_table;
2727         s32 tt_len;
2728
2729         batadv_dbg(BATADV_DBG_TT, bat_priv,
2730                    "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
2731                    req_src, tt_data->ttvn,
2732                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2733
2734         spin_lock_bh(&bat_priv->tt.commit_lock);
2735
2736         my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2737         req_ttvn = tt_data->ttvn;
2738
2739         orig_node = batadv_orig_hash_find(bat_priv, req_src);
2740         if (!orig_node)
2741                 goto out;
2742
2743         primary_if = batadv_primary_if_get_selected(bat_priv);
2744         if (!primary_if)
2745                 goto out;
2746
2747         /* If the full table has been explicitly requested or the gap
2748          * is too big send the whole local translation table
2749          */
2750         if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
2751             !bat_priv->tt.last_changeset)
2752                 full_table = true;
2753         else
2754                 full_table = false;
2755
2756         /* TT fragmentation hasn't been implemented yet, so send as many
2757          * TT entries fit a single packet as possible only
2758          */
2759         if (!full_table) {
2760                 spin_lock_bh(&bat_priv->tt.last_changeset_lock);
2761
2762                 tt_len = bat_priv->tt.last_changeset_len;
2763                 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
2764                                                              &tvlv_tt_data,
2765                                                              &tt_change,
2766                                                              &tt_len);
2767                 if (!tt_len)
2768                         goto unlock;
2769
2770                 /* Copy the last orig_node's OGM buffer */
2771                 memcpy(tt_change, bat_priv->tt.last_changeset,
2772                        bat_priv->tt.last_changeset_len);
2773                 spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2774         } else {
2775                 req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2776
2777                 /* allocate the tvlv, put the tt_data and all the tt_vlan_data
2778                  * in the initial part
2779                  */
2780                 tt_len = -1;
2781                 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
2782                                                              &tvlv_tt_data,
2783                                                              &tt_change,
2784                                                              &tt_len);
2785                 if (!tt_len)
2786                         goto out;
2787
2788                 /* fill the rest of the tvlv with the real TT entries */
2789                 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,
2790                                         tt_change, tt_len,
2791                                         batadv_tt_local_valid, NULL);
2792         }
2793
2794         tvlv_tt_data->flags = BATADV_TT_RESPONSE;
2795         tvlv_tt_data->ttvn = req_ttvn;
2796
2797         if (full_table)
2798                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2799
2800         batadv_dbg(BATADV_DBG_TT, bat_priv,
2801                    "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
2802                    orig_node->orig, full_table ? 'F' : '.', req_ttvn);
2803
2804         batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2805
2806         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2807                                  req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
2808                                  tvlv_len);
2809
2810         goto out;
2811
2812 unlock:
2813         spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2814 out:
2815         spin_unlock_bh(&bat_priv->tt.commit_lock);
2816         if (orig_node)
2817                 batadv_orig_node_free_ref(orig_node);
2818         if (primary_if)
2819                 batadv_hardif_free_ref(primary_if);
2820         kfree(tvlv_tt_data);
2821         /* The packet was for this host, so it doesn't need to be re-routed */
2822         return true;
2823 }
2824
2825 /**
2826  * batadv_send_tt_response - send reply to tt request
2827  * @bat_priv: the bat priv with all the soft interface information
2828  * @tt_data: tt data containing the tt request information
2829  * @req_src: mac address of tt request sender
2830  * @req_dst: mac address of tt request recipient
2831  *
2832  * Returns true if tt request reply was sent, false otherwise.
2833  */
2834 static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
2835                                     struct batadv_tvlv_tt_data *tt_data,
2836                                     u8 *req_src, u8 *req_dst)
2837 {
2838         if (batadv_is_my_mac(bat_priv, req_dst))
2839                 return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
2840         return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
2841                                              req_dst);
2842 }
2843
2844 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
2845                                       struct batadv_orig_node *orig_node,
2846                                       struct batadv_tvlv_tt_change *tt_change,
2847                                       u16 tt_num_changes, u8 ttvn)
2848 {
2849         int i;
2850         int roams;
2851
2852         for (i = 0; i < tt_num_changes; i++) {
2853                 if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
2854                         roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
2855                         batadv_tt_global_del(bat_priv, orig_node,
2856                                              (tt_change + i)->addr,
2857                                              ntohs((tt_change + i)->vid),
2858                                              "tt removed by changes",
2859                                              roams);
2860                 } else {
2861                         if (!batadv_tt_global_add(bat_priv, orig_node,
2862                                                   (tt_change + i)->addr,
2863                                                   ntohs((tt_change + i)->vid),
2864                                                   (tt_change + i)->flags, ttvn))
2865                                 /* In case of problem while storing a
2866                                  * global_entry, we stop the updating
2867                                  * procedure without committing the
2868                                  * ttvn change. This will avoid to send
2869                                  * corrupted data on tt_request
2870                                  */
2871                                 return;
2872                 }
2873         }
2874         set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
2875 }
2876
2877 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
2878                                   struct batadv_tvlv_tt_change *tt_change,
2879                                   u8 ttvn, u8 *resp_src,
2880                                   u16 num_entries)
2881 {
2882         struct batadv_orig_node *orig_node;
2883
2884         orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2885         if (!orig_node)
2886                 goto out;
2887
2888         /* Purge the old table first.. */
2889         batadv_tt_global_del_orig(bat_priv, orig_node, -1,
2890                                   "Received full table");
2891
2892         _batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
2893                                   ttvn);
2894
2895         spin_lock_bh(&orig_node->tt_buff_lock);
2896         kfree(orig_node->tt_buff);
2897         orig_node->tt_buff_len = 0;
2898         orig_node->tt_buff = NULL;
2899         spin_unlock_bh(&orig_node->tt_buff_lock);
2900
2901         atomic_set(&orig_node->last_ttvn, ttvn);
2902
2903 out:
2904         if (orig_node)
2905                 batadv_orig_node_free_ref(orig_node);
2906 }
2907
2908 static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
2909                                      struct batadv_orig_node *orig_node,
2910                                      u16 tt_num_changes, u8 ttvn,
2911                                      struct batadv_tvlv_tt_change *tt_change)
2912 {
2913         _batadv_tt_update_changes(bat_priv, orig_node, tt_change,
2914                                   tt_num_changes, ttvn);
2915
2916         batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
2917                                    batadv_tt_len(tt_num_changes));
2918         atomic_set(&orig_node->last_ttvn, ttvn);
2919 }
2920
2921 /**
2922  * batadv_is_my_client - check if a client is served by the local node
2923  * @bat_priv: the bat priv with all the soft interface information
2924  * @addr: the mac address of the client to check
2925  * @vid: VLAN identifier
2926  *
2927  * Returns true if the client is served by this node, false otherwise.
2928  */
2929 bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,
2930                          unsigned short vid)
2931 {
2932         struct batadv_tt_local_entry *tt_local_entry;
2933         bool ret = false;
2934
2935         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
2936         if (!tt_local_entry)
2937                 goto out;
2938         /* Check if the client has been logically deleted (but is kept for
2939          * consistency purpose)
2940          */
2941         if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
2942             (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
2943                 goto out;
2944         ret = true;
2945 out:
2946         if (tt_local_entry)
2947                 batadv_tt_local_entry_free_ref(tt_local_entry);
2948         return ret;
2949 }
2950
2951 /**
2952  * batadv_handle_tt_response - process incoming tt reply
2953  * @bat_priv: the bat priv with all the soft interface information
2954  * @tt_data: tt data containing the tt request information
2955  * @resp_src: mac address of tt reply sender
2956  * @num_entries: number of tt change entries appended to the tt data
2957  */
2958 static void batadv_handle_tt_response(struct batadv_priv *bat_priv,
2959                                       struct batadv_tvlv_tt_data *tt_data,
2960                                       u8 *resp_src, u16 num_entries)
2961 {
2962         struct batadv_tt_req_node *node;
2963         struct hlist_node *safe;
2964         struct batadv_orig_node *orig_node = NULL;
2965         struct batadv_tvlv_tt_change *tt_change;
2966         u8 *tvlv_ptr = (u8 *)tt_data;
2967         u16 change_offset;
2968
2969         batadv_dbg(BATADV_DBG_TT, bat_priv,
2970                    "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
2971                    resp_src, tt_data->ttvn, num_entries,
2972                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2973
2974         orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2975         if (!orig_node)
2976                 goto out;
2977
2978         spin_lock_bh(&orig_node->tt_lock);
2979
2980         change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);
2981         change_offset *= ntohs(tt_data->num_vlan);
2982         change_offset += sizeof(*tt_data);
2983         tvlv_ptr += change_offset;
2984
2985         tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;
2986         if (tt_data->flags & BATADV_TT_FULL_TABLE) {
2987                 batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
2988                                       resp_src, num_entries);
2989         } else {
2990                 batadv_tt_update_changes(bat_priv, orig_node, num_entries,
2991                                          tt_data->ttvn, tt_change);
2992         }
2993
2994         /* Recalculate the CRC for this orig_node and store it */
2995         batadv_tt_global_update_crc(bat_priv, orig_node);
2996
2997         spin_unlock_bh(&orig_node->tt_lock);
2998
2999         /* Delete the tt_req_node from pending tt_requests list */
3000         spin_lock_bh(&bat_priv->tt.req_list_lock);
3001         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
3002                 if (!batadv_compare_eth(node->addr, resp_src))
3003                         continue;
3004                 hlist_del_init(&node->list);
3005                 kfree(node);
3006         }
3007
3008         spin_unlock_bh(&bat_priv->tt.req_list_lock);
3009 out:
3010         if (orig_node)
3011                 batadv_orig_node_free_ref(orig_node);
3012 }
3013
3014 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
3015 {
3016         struct batadv_tt_roam_node *node, *safe;
3017
3018         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3019
3020         list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3021                 list_del(&node->list);
3022                 kfree(node);
3023         }
3024
3025         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3026 }
3027
3028 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
3029 {
3030         struct batadv_tt_roam_node *node, *safe;
3031
3032         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3033         list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3034                 if (!batadv_has_timed_out(node->first_time,
3035                                           BATADV_ROAMING_MAX_TIME))
3036                         continue;
3037
3038                 list_del(&node->list);
3039                 kfree(node);
3040         }
3041         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3042 }
3043
3044 /* This function checks whether the client already reached the
3045  * maximum number of possible roaming phases. In this case the ROAMING_ADV
3046  * will not be sent.
3047  *
3048  * returns true if the ROAMING_ADV can be sent, false otherwise
3049  */
3050 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)
3051 {
3052         struct batadv_tt_roam_node *tt_roam_node;
3053         bool ret = false;
3054
3055         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3056         /* The new tt_req will be issued only if I'm not waiting for a
3057          * reply from the same orig_node yet
3058          */
3059         list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
3060                 if (!batadv_compare_eth(tt_roam_node->addr, client))
3061                         continue;
3062
3063                 if (batadv_has_timed_out(tt_roam_node->first_time,
3064                                          BATADV_ROAMING_MAX_TIME))
3065                         continue;
3066
3067                 if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
3068                         /* Sorry, you roamed too many times! */
3069                         goto unlock;
3070                 ret = true;
3071                 break;
3072         }
3073
3074         if (!ret) {
3075                 tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
3076                 if (!tt_roam_node)
3077                         goto unlock;
3078
3079                 tt_roam_node->first_time = jiffies;
3080                 atomic_set(&tt_roam_node->counter,
3081                            BATADV_ROAMING_MAX_COUNT - 1);
3082                 ether_addr_copy(tt_roam_node->addr, client);
3083
3084                 list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3085                 ret = true;
3086         }
3087
3088 unlock:
3089         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3090         return ret;
3091 }
3092
3093 /**
3094  * batadv_send_roam_adv - send a roaming advertisement message
3095  * @bat_priv: the bat priv with all the soft interface information
3096  * @client: mac address of the roaming client
3097  * @vid: VLAN identifier
3098  * @orig_node: message destination
3099  *
3100  * Send a ROAMING_ADV message to the node which was previously serving this
3101  * client. This is done to inform the node that from now on all traffic destined
3102  * for this particular roamed client has to be forwarded to the sender of the
3103  * roaming message.
3104  */
3105 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
3106                                  unsigned short vid,
3107                                  struct batadv_orig_node *orig_node)
3108 {
3109         struct batadv_hard_iface *primary_if;
3110         struct batadv_tvlv_roam_adv tvlv_roam;
3111
3112         primary_if = batadv_primary_if_get_selected(bat_priv);
3113         if (!primary_if)
3114                 goto out;
3115
3116         /* before going on we have to check whether the client has
3117          * already roamed to us too many times
3118          */
3119         if (!batadv_tt_check_roam_count(bat_priv, client))
3120                 goto out;
3121
3122         batadv_dbg(BATADV_DBG_TT, bat_priv,
3123                    "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
3124                    orig_node->orig, client, BATADV_PRINT_VID(vid));
3125
3126         batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3127
3128         memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3129         tvlv_roam.vid = htons(vid);
3130
3131         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3132                                  orig_node->orig, BATADV_TVLV_ROAM, 1,
3133                                  &tvlv_roam, sizeof(tvlv_roam));
3134
3135 out:
3136         if (primary_if)
3137                 batadv_hardif_free_ref(primary_if);
3138 }
3139
3140 static void batadv_tt_purge(struct work_struct *work)
3141 {
3142         struct delayed_work *delayed_work;
3143         struct batadv_priv_tt *priv_tt;
3144         struct batadv_priv *bat_priv;
3145
3146         delayed_work = container_of(work, struct delayed_work, work);
3147         priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
3148         bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3149
3150         batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3151         batadv_tt_global_purge(bat_priv);
3152         batadv_tt_req_purge(bat_priv);
3153         batadv_tt_roam_purge(bat_priv);
3154
3155         queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3156                            msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3157 }
3158
3159 void batadv_tt_free(struct batadv_priv *bat_priv)
3160 {
3161         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
3162         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);
3163
3164         cancel_delayed_work_sync(&bat_priv->tt.work);
3165
3166         batadv_tt_local_table_free(bat_priv);
3167         batadv_tt_global_table_free(bat_priv);
3168         batadv_tt_req_list_free(bat_priv);
3169         batadv_tt_changes_list_free(bat_priv);
3170         batadv_tt_roam_list_free(bat_priv);
3171
3172         kfree(bat_priv->tt.last_changeset);
3173 }
3174
3175 /**
3176  * batadv_tt_local_set_flags - set or unset the specified flags on the local
3177  *  table and possibly count them in the TT size
3178  * @bat_priv: the bat priv with all the soft interface information
3179  * @flags: the flag to switch
3180  * @enable: whether to set or unset the flag
3181  * @count: whether to increase the TT size by the number of changed entries
3182  */
3183 static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,
3184                                       bool enable, bool count)
3185 {
3186         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3187         struct batadv_tt_common_entry *tt_common_entry;
3188         u16 changed_num = 0;
3189         struct hlist_head *head;
3190         u32 i;
3191
3192         if (!hash)
3193                 return;
3194
3195         for (i = 0; i < hash->size; i++) {
3196                 head = &hash->table[i];
3197
3198                 rcu_read_lock();
3199                 hlist_for_each_entry_rcu(tt_common_entry,
3200                                          head, hash_entry) {
3201                         if (enable) {
3202                                 if ((tt_common_entry->flags & flags) == flags)
3203                                         continue;
3204                                 tt_common_entry->flags |= flags;
3205                         } else {
3206                                 if (!(tt_common_entry->flags & flags))
3207                                         continue;
3208                                 tt_common_entry->flags &= ~flags;
3209                         }
3210                         changed_num++;
3211
3212                         if (!count)
3213                                 continue;
3214
3215                         batadv_tt_local_size_inc(bat_priv,
3216                                                  tt_common_entry->vid);
3217                 }
3218                 rcu_read_unlock();
3219         }
3220 }
3221
3222 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
3223 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3224 {
3225         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3226         struct batadv_tt_common_entry *tt_common;
3227         struct batadv_tt_local_entry *tt_local;
3228         struct batadv_softif_vlan *vlan;
3229         struct hlist_node *node_tmp;
3230         struct hlist_head *head;
3231         spinlock_t *list_lock; /* protects write access to the hash lists */
3232         u32 i;
3233
3234         if (!hash)
3235                 return;
3236
3237         for (i = 0; i < hash->size; i++) {
3238                 head = &hash->table[i];
3239                 list_lock = &hash->list_locks[i];
3240
3241                 spin_lock_bh(list_lock);
3242                 hlist_for_each_entry_safe(tt_common, node_tmp, head,
3243                                           hash_entry) {
3244                         if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3245                                 continue;
3246
3247                         batadv_dbg(BATADV_DBG_TT, bat_priv,
3248                                    "Deleting local tt entry (%pM, vid: %d): pending\n",
3249                                    tt_common->addr,
3250                                    BATADV_PRINT_VID(tt_common->vid));
3251
3252                         batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3253                         hlist_del_rcu(&tt_common->hash_entry);
3254                         tt_local = container_of(tt_common,
3255                                                 struct batadv_tt_local_entry,
3256                                                 common);
3257
3258                         /* decrease the reference held for this vlan */
3259                         vlan = batadv_softif_vlan_get(bat_priv, tt_common->vid);
3260                         if (vlan) {
3261                                 batadv_softif_vlan_free_ref(vlan);
3262                                 batadv_softif_vlan_free_ref(vlan);
3263                         }
3264
3265                         batadv_tt_local_entry_free_ref(tt_local);
3266                 }
3267                 spin_unlock_bh(list_lock);
3268         }
3269 }
3270
3271 /**
3272  * batadv_tt_local_commit_changes_nolock - commit all pending local tt changes
3273  *  which have been queued in the time since the last commit
3274  * @bat_priv: the bat priv with all the soft interface information
3275  *
3276  * Caller must hold tt->commit_lock.
3277  */
3278 static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3279 {
3280         lockdep_assert_held(&bat_priv->tt.commit_lock);
3281
3282         /* Update multicast addresses in local translation table */
3283         batadv_mcast_mla_update(bat_priv);
3284
3285         if (atomic_read(&bat_priv->tt.local_changes) < 1) {
3286                 if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))
3287                         batadv_tt_tvlv_container_update(bat_priv);
3288                 return;
3289         }
3290
3291         batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3292
3293         batadv_tt_local_purge_pending_clients(bat_priv);
3294         batadv_tt_local_update_crc(bat_priv);
3295
3296         /* Increment the TTVN only once per OGM interval */
3297         atomic_inc(&bat_priv->tt.vn);
3298         batadv_dbg(BATADV_DBG_TT, bat_priv,
3299                    "Local changes committed, updating to ttvn %u\n",
3300                    (u8)atomic_read(&bat_priv->tt.vn));
3301
3302         /* reset the sending counter */
3303         atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3304         batadv_tt_tvlv_container_update(bat_priv);
3305 }
3306
3307 /**
3308  * batadv_tt_local_commit_changes - commit all pending local tt changes which
3309  *  have been queued in the time since the last commit
3310  * @bat_priv: the bat priv with all the soft interface information
3311  */
3312 void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)
3313 {
3314         spin_lock_bh(&bat_priv->tt.commit_lock);
3315         batadv_tt_local_commit_changes_nolock(bat_priv);
3316         spin_unlock_bh(&bat_priv->tt.commit_lock);
3317 }
3318
3319 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,
3320                            unsigned short vid)
3321 {
3322         struct batadv_tt_local_entry *tt_local_entry = NULL;
3323         struct batadv_tt_global_entry *tt_global_entry = NULL;
3324         struct batadv_softif_vlan *vlan;
3325         bool ret = false;
3326
3327         vlan = batadv_softif_vlan_get(bat_priv, vid);
3328         if (!vlan || !atomic_read(&vlan->ap_isolation))
3329                 goto out;
3330
3331         tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3332         if (!tt_local_entry)
3333                 goto out;
3334
3335         tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3336         if (!tt_global_entry)
3337                 goto out;
3338
3339         if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3340                 goto out;
3341
3342         ret = true;
3343
3344 out:
3345         if (vlan)
3346                 batadv_softif_vlan_free_ref(vlan);
3347         if (tt_global_entry)
3348                 batadv_tt_global_entry_free_ref(tt_global_entry);
3349         if (tt_local_entry)
3350                 batadv_tt_local_entry_free_ref(tt_local_entry);
3351         return ret;
3352 }
3353
3354 /**
3355  * batadv_tt_update_orig - update global translation table with new tt
3356  *  information received via ogms
3357  * @bat_priv: the bat priv with all the soft interface information
3358  * @orig: the orig_node of the ogm
3359  * @tt_vlan: pointer to the first tvlv VLAN entry
3360  * @tt_num_vlan: number of tvlv VLAN entries
3361  * @tt_change: pointer to the first entry in the TT buffer
3362  * @tt_num_changes: number of tt changes inside the tt buffer
3363  * @ttvn: translation table version number of this changeset
3364  * @tt_crc: crc32 checksum of orig node's translation table
3365  */
3366 static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
3367                                   struct batadv_orig_node *orig_node,
3368                                   const void *tt_buff, u16 tt_num_vlan,
3369                                   struct batadv_tvlv_tt_change *tt_change,
3370                                   u16 tt_num_changes, u8 ttvn)
3371 {
3372         u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
3373         struct batadv_tvlv_tt_vlan_data *tt_vlan;
3374         bool full_table = true;
3375         bool has_tt_init;
3376
3377         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
3378         has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,
3379                                &orig_node->capa_initialized);
3380
3381         /* orig table not initialised AND first diff is in the OGM OR the ttvn
3382          * increased by one -> we can apply the attached changes
3383          */
3384         if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
3385                 /* the OGM could not contain the changes due to their size or
3386                  * because they have already been sent BATADV_TT_OGM_APPEND_MAX
3387                  * times.
3388                  * In this case send a tt request
3389                  */
3390                 if (!tt_num_changes) {
3391                         full_table = false;
3392                         goto request_table;
3393                 }
3394
3395                 spin_lock_bh(&orig_node->tt_lock);
3396
3397                 batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
3398                                          ttvn, tt_change);
3399
3400                 /* Even if we received the precomputed crc with the OGM, we
3401                  * prefer to recompute it to spot any possible inconsistency
3402                  * in the global table
3403                  */
3404                 batadv_tt_global_update_crc(bat_priv, orig_node);
3405
3406                 spin_unlock_bh(&orig_node->tt_lock);
3407
3408                 /* The ttvn alone is not enough to guarantee consistency
3409                  * because a single value could represent different states
3410                  * (due to the wrap around). Thus a node has to check whether
3411                  * the resulting table (after applying the changes) is still
3412                  * consistent or not. E.g. a node could disconnect while its
3413                  * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
3414                  * checking the CRC value is mandatory to detect the
3415                  * inconsistency
3416                  */
3417                 if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
3418                                                 tt_num_vlan))
3419                         goto request_table;
3420         } else {
3421                 /* if we missed more than one change or our tables are not
3422                  * in sync anymore -> request fresh tt data
3423                  */
3424                 if (!has_tt_init || ttvn != orig_ttvn ||
3425                     !batadv_tt_global_check_crc(orig_node, tt_vlan,
3426                                                 tt_num_vlan)) {
3427 request_table:
3428                         batadv_dbg(BATADV_DBG_TT, bat_priv,
3429                                    "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",
3430                                    orig_node->orig, ttvn, orig_ttvn,
3431                                    tt_num_changes);
3432                         batadv_send_tt_request(bat_priv, orig_node, ttvn,
3433                                                tt_vlan, tt_num_vlan,
3434                                                full_table);
3435                         return;
3436                 }
3437         }
3438 }
3439
3440 /**
3441  * batadv_tt_global_client_is_roaming - check if a client is marked as roaming
3442  * @bat_priv: the bat priv with all the soft interface information
3443  * @addr: the mac address of the client to check
3444  * @vid: VLAN identifier
3445  *
3446  * Returns true if we know that the client has moved from its old originator
3447  * to another one. This entry is still kept for consistency purposes and will be
3448  * deleted later by a DEL or because of timeout
3449  */
3450 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
3451                                         u8 *addr, unsigned short vid)
3452 {
3453         struct batadv_tt_global_entry *tt_global_entry;
3454         bool ret = false;
3455
3456         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
3457         if (!tt_global_entry)
3458                 goto out;
3459
3460         ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3461         batadv_tt_global_entry_free_ref(tt_global_entry);
3462 out:
3463         return ret;
3464 }
3465
3466 /**
3467  * batadv_tt_local_client_is_roaming - tells whether the client is roaming
3468  * @bat_priv: the bat priv with all the soft interface information
3469  * @addr: the mac address of the local client to query
3470  * @vid: VLAN identifier
3471  *
3472  * Returns true if the local client is known to be roaming (it is not served by
3473  * this node anymore) or not. If yes, the client is still present in the table
3474  * to keep the latter consistent with the node TTVN
3475  */
3476 bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
3477                                        u8 *addr, unsigned short vid)
3478 {
3479         struct batadv_tt_local_entry *tt_local_entry;
3480         bool ret = false;
3481
3482         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3483         if (!tt_local_entry)
3484                 goto out;
3485
3486         ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3487         batadv_tt_local_entry_free_ref(tt_local_entry);
3488 out:
3489         return ret;
3490 }
3491
3492 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
3493                                           struct batadv_orig_node *orig_node,
3494                                           const unsigned char *addr,
3495                                           unsigned short vid)
3496 {
3497         bool ret = false;
3498
3499         if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
3500                                   BATADV_TT_CLIENT_TEMP,
3501                                   atomic_read(&orig_node->last_ttvn)))
3502                 goto out;
3503
3504         batadv_dbg(BATADV_DBG_TT, bat_priv,
3505                    "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
3506                    addr, BATADV_PRINT_VID(vid), orig_node->orig);
3507         ret = true;
3508 out:
3509         return ret;
3510 }
3511
3512 /**
3513  * batadv_tt_local_resize_to_mtu - resize the local translation table fit the
3514  *  maximum packet size that can be transported through the mesh
3515  * @soft_iface: netdev struct of the mesh interface
3516  *
3517  * Remove entries older than 'timeout' and half timeout if more entries need
3518  * to be removed.
3519  */
3520 void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)
3521 {
3522         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
3523         int packet_size_max = atomic_read(&bat_priv->packet_size_max);
3524         int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;
3525         bool reduced = false;
3526
3527         spin_lock_bh(&bat_priv->tt.commit_lock);
3528
3529         while (true) {
3530                 table_size = batadv_tt_local_table_transmit_size(bat_priv);
3531                 if (packet_size_max >= table_size)
3532                         break;
3533
3534                 batadv_tt_local_purge(bat_priv, timeout);
3535                 batadv_tt_local_purge_pending_clients(bat_priv);
3536
3537                 timeout /= 2;
3538                 reduced = true;
3539                 net_ratelimited_function(batadv_info, soft_iface,
3540                                          "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",
3541                                          packet_size_max);
3542         }
3543
3544         /* commit these changes immediately, to avoid synchronization problem
3545          * with the TTVN
3546          */
3547         if (reduced)
3548                 batadv_tt_local_commit_changes_nolock(bat_priv);
3549
3550         spin_unlock_bh(&bat_priv->tt.commit_lock);
3551 }
3552
3553 /**
3554  * batadv_tt_tvlv_ogm_handler_v1 - process incoming tt tvlv container
3555  * @bat_priv: the bat priv with all the soft interface information
3556  * @orig: the orig_node of the ogm
3557  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
3558  * @tvlv_value: tvlv buffer containing the gateway data
3559  * @tvlv_value_len: tvlv buffer length
3560  */
3561 static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
3562                                           struct batadv_orig_node *orig,
3563                                           u8 flags, void *tvlv_value,
3564                                           u16 tvlv_value_len)
3565 {
3566         struct batadv_tvlv_tt_vlan_data *tt_vlan;
3567         struct batadv_tvlv_tt_change *tt_change;
3568         struct batadv_tvlv_tt_data *tt_data;
3569         u16 num_entries, num_vlan;
3570
3571         if (tvlv_value_len < sizeof(*tt_data))
3572                 return;
3573
3574         tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
3575         tvlv_value_len -= sizeof(*tt_data);
3576
3577         num_vlan = ntohs(tt_data->num_vlan);
3578
3579         if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)
3580                 return;
3581
3582         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
3583         tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);
3584         tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;
3585
3586         num_entries = batadv_tt_entries(tvlv_value_len);
3587
3588         batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
3589                               num_entries, tt_data->ttvn);
3590 }
3591
3592 /**
3593  * batadv_tt_tvlv_unicast_handler_v1 - process incoming (unicast) tt tvlv
3594  *  container
3595  * @bat_priv: the bat priv with all the soft interface information
3596  * @src: mac address of tt tvlv sender
3597  * @dst: mac address of tt tvlv recipient
3598  * @tvlv_value: tvlv buffer containing the tt data
3599  * @tvlv_value_len: tvlv buffer length
3600  *
3601  * Returns NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS
3602  * otherwise.
3603  */
3604 static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3605                                              u8 *src, u8 *dst,
3606                                              void *tvlv_value,
3607                                              u16 tvlv_value_len)
3608 {
3609         struct batadv_tvlv_tt_data *tt_data;
3610         u16 tt_vlan_len, tt_num_entries;
3611         char tt_flag;
3612         bool ret;
3613
3614         if (tvlv_value_len < sizeof(*tt_data))
3615                 return NET_RX_SUCCESS;
3616
3617         tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
3618         tvlv_value_len -= sizeof(*tt_data);
3619
3620         tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);
3621         tt_vlan_len *= ntohs(tt_data->num_vlan);
3622
3623         if (tvlv_value_len < tt_vlan_len)
3624                 return NET_RX_SUCCESS;
3625
3626         tvlv_value_len -= tt_vlan_len;
3627         tt_num_entries = batadv_tt_entries(tvlv_value_len);
3628
3629         switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {
3630         case BATADV_TT_REQUEST:
3631                 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
3632
3633                 /* If this node cannot provide a TT response the tt_request is
3634                  * forwarded
3635                  */
3636                 ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);
3637                 if (!ret) {
3638                         if (tt_data->flags & BATADV_TT_FULL_TABLE)
3639                                 tt_flag = 'F';
3640                         else
3641                                 tt_flag = '.';
3642
3643                         batadv_dbg(BATADV_DBG_TT, bat_priv,
3644                                    "Routing TT_REQUEST to %pM [%c]\n",
3645                                    dst, tt_flag);
3646                         /* tvlv API will re-route the packet */
3647                         return NET_RX_DROP;
3648                 }
3649                 break;
3650         case BATADV_TT_RESPONSE:
3651                 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
3652
3653                 if (batadv_is_my_mac(bat_priv, dst)) {
3654                         batadv_handle_tt_response(bat_priv, tt_data,
3655                                                   src, tt_num_entries);
3656                         return NET_RX_SUCCESS;
3657                 }
3658
3659                 if (tt_data->flags & BATADV_TT_FULL_TABLE)
3660                         tt_flag =  'F';
3661                 else
3662                         tt_flag = '.';
3663
3664                 batadv_dbg(BATADV_DBG_TT, bat_priv,
3665                            "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);
3666
3667                 /* tvlv API will re-route the packet */
3668                 return NET_RX_DROP;
3669         }
3670
3671         return NET_RX_SUCCESS;
3672 }
3673
3674 /**
3675  * batadv_roam_tvlv_unicast_handler_v1 - process incoming tt roam tvlv container
3676  * @bat_priv: the bat priv with all the soft interface information
3677  * @src: mac address of tt tvlv sender
3678  * @dst: mac address of tt tvlv recipient
3679  * @tvlv_value: tvlv buffer containing the tt data
3680  * @tvlv_value_len: tvlv buffer length
3681  *
3682  * Returns NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS
3683  * otherwise.
3684  */
3685 static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3686                                                u8 *src, u8 *dst,
3687                                                void *tvlv_value,
3688                                                u16 tvlv_value_len)
3689 {
3690         struct batadv_tvlv_roam_adv *roaming_adv;
3691         struct batadv_orig_node *orig_node = NULL;
3692
3693         /* If this node is not the intended recipient of the
3694          * roaming advertisement the packet is forwarded
3695          * (the tvlv API will re-route the packet).
3696          */
3697         if (!batadv_is_my_mac(bat_priv, dst))
3698                 return NET_RX_DROP;
3699
3700         if (tvlv_value_len < sizeof(*roaming_adv))
3701                 goto out;
3702
3703         orig_node = batadv_orig_hash_find(bat_priv, src);
3704         if (!orig_node)
3705                 goto out;
3706
3707         batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
3708         roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;
3709
3710         batadv_dbg(BATADV_DBG_TT, bat_priv,
3711                    "Received ROAMING_ADV from %pM (client %pM)\n",
3712                    src, roaming_adv->client);
3713
3714         batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,
3715                              ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
3716                              atomic_read(&orig_node->last_ttvn) + 1);
3717
3718 out:
3719         if (orig_node)
3720                 batadv_orig_node_free_ref(orig_node);
3721         return NET_RX_SUCCESS;
3722 }
3723
3724 /**
3725  * batadv_tt_init - initialise the translation table internals
3726  * @bat_priv: the bat priv with all the soft interface information
3727  *
3728  * Return 0 on success or negative error number in case of failure.
3729  */
3730 int batadv_tt_init(struct batadv_priv *bat_priv)
3731 {
3732         int ret;
3733
3734         /* synchronized flags must be remote */
3735         BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));
3736
3737         ret = batadv_tt_local_init(bat_priv);
3738         if (ret < 0)
3739                 return ret;
3740
3741         ret = batadv_tt_global_init(bat_priv);
3742         if (ret < 0)
3743                 return ret;
3744
3745         batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,
3746                                      batadv_tt_tvlv_unicast_handler_v1,
3747                                      BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
3748
3749         batadv_tvlv_handler_register(bat_priv, NULL,
3750                                      batadv_roam_tvlv_unicast_handler_v1,
3751                                      BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);
3752
3753         INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
3754         queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3755                            msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3756
3757         return 1;
3758 }
3759
3760 /**
3761  * batadv_tt_global_is_isolated - check if a client is marked as isolated
3762  * @bat_priv: the bat priv with all the soft interface information
3763  * @addr: the mac address of the client
3764  * @vid: the identifier of the VLAN where this client is connected
3765  *
3766  * Returns true if the client is marked with the TT_CLIENT_ISOLA flag, false
3767  * otherwise
3768  */
3769 bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
3770                                   const u8 *addr, unsigned short vid)
3771 {
3772         struct batadv_tt_global_entry *tt;
3773         bool ret;
3774
3775         tt = batadv_tt_global_hash_find(bat_priv, addr, vid);
3776         if (!tt)
3777                 return false;
3778
3779         ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;
3780
3781         batadv_tt_global_entry_free_ref(tt);
3782
3783         return ret;
3784 }