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