translation-table.c 114.6 KB
Newer Older
1
/* Copyright (C) 2007-2016  B.A.T.M.A.N. contributors:
2
 *
3
 * Marek Lindner, Simon Wunderlich, Antonio Quartulli
4 5 6 7 8 9 10 11 12 13 14
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * 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 20 21
#include "main.h"

#include <linux/atomic.h>
22
#include <linux/bitops.h>
23 24 25 26 27 28 29 30 31 32 33
#include <linux/bug.h>
#include <linux/byteorder/generic.h>
#include <linux/compiler.h>
#include <linux/crc32c.h>
#include <linux/errno.h>
#include <linux/etherdevice.h>
#include <linux/fs.h>
#include <linux/if_ether.h>
#include <linux/jhash.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
34
#include <linux/kref.h>
35 36 37 38 39 40 41 42 43 44 45 46 47
#include <linux/list.h>
#include <linux/lockdep.h>
#include <linux/netdevice.h>
#include <linux/rculist.h>
#include <linux/rcupdate.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/stddef.h>
#include <linux/string.h>
#include <linux/workqueue.h>

#include "bridge_loop_avoidance.h"
48
#include "hard-interface.h"
49
#include "hash.h"
50
#include "log.h"
51
#include "multicast.h"
52 53 54
#include "originator.h"
#include "packet.h"
#include "soft-interface.h"
55
#include "tvlv.h"
56

57 58 59 60
/* hash class keys */
static struct lock_class_key batadv_tt_local_hash_lock_class_key;
static struct lock_class_key batadv_tt_global_hash_lock_class_key;

61
static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
62
				 unsigned short vid,
63
				 struct batadv_orig_node *orig_node);
64 65
static void batadv_tt_purge(struct work_struct *work);
static void
66
batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);
67 68 69
static void batadv_tt_global_del(struct batadv_priv *bat_priv,
				 struct batadv_orig_node *orig_node,
				 const unsigned char *addr,
70 71
				 unsigned short vid, const char *message,
				 bool roaming);
72

73
/**
74 75 76
 * batadv_compare_tt - check if two TT entries are the same
 * @node: the list element pointer of the first TT entry
 * @data2: pointer to the tt_common_entry of the second TT entry
77
 *
78 79
 * Compare the MAC address and the VLAN ID of the two TT entries and check if
 * they are the same TT client.
80
 * Return: true if the two TT clients are the same, false otherwise
81
 */
82
static bool batadv_compare_tt(const struct hlist_node *node, const void *data2)
83
{
84
	const void *data1 = container_of(node, struct batadv_tt_common_entry,
85
					 hash_entry);
86 87
	const struct batadv_tt_common_entry *tt1 = data1;
	const struct batadv_tt_common_entry *tt2 = data2;
88

89
	return (tt1->vid == tt2->vid) && batadv_compare_eth(data1, data2);
90 91
}

92 93 94 95 96
/**
 * batadv_choose_tt - return the index of the tt entry in the hash table
 * @data: pointer to the tt_common_entry object to map
 * @size: the size of the hash table
 *
97
 * Return: the hash index where the object represented by 'data' should be
98 99
 * stored at.
 */
100
static inline u32 batadv_choose_tt(const void *data, u32 size)
101 102
{
	struct batadv_tt_common_entry *tt;
103
	u32 hash = 0;
104 105

	tt = (struct batadv_tt_common_entry *)data;
106 107
	hash = jhash(&tt->addr, ETH_ALEN, hash);
	hash = jhash(&tt->vid, sizeof(tt->vid), hash);
108 109 110 111 112 113 114 115 116 117

	return hash % size;
}

/**
 * batadv_tt_hash_find - look for a client in the given hash table
 * @hash: the hash table to search
 * @addr: the mac address of the client to look for
 * @vid: VLAN identifier
 *
118
 * Return: a pointer to the tt_common struct belonging to the searched client if
119 120
 * found, NULL otherwise.
 */
121
static struct batadv_tt_common_entry *
122
batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,
123
		    unsigned short vid)
124 125
{
	struct hlist_head *head;
126
	struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;
127
	u32 index;
128 129 130 131

	if (!hash)
		return NULL;

132
	ether_addr_copy(to_search.addr, addr);
133 134 135
	to_search.vid = vid;

	index = batadv_choose_tt(&to_search, hash->size);
136 137 138
	head = &hash->table[index];

	rcu_read_lock();
139 140 141 142 143
	hlist_for_each_entry_rcu(tt, head, hash_entry) {
		if (!batadv_compare_eth(tt, addr))
			continue;

		if (tt->vid != vid)
144 145
			continue;

146
		if (!kref_get_unless_zero(&tt->refcount))
147 148
			continue;

149
		tt_tmp = tt;
150 151 152 153
		break;
	}
	rcu_read_unlock();

154
	return tt_tmp;
155 156
}

157 158 159 160 161 162
/**
 * batadv_tt_local_hash_find - search the local table for a given client
 * @bat_priv: the bat priv with all the soft interface information
 * @addr: the mac address of the client to look for
 * @vid: VLAN identifier
 *
163
 * Return: a pointer to the corresponding tt_local_entry struct if the client is
164 165
 * found, NULL otherwise.
 */
166
static struct batadv_tt_local_entry *
167
batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
168
			  unsigned short vid)
169
{
170 171
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_local_entry *tt_local_entry = NULL;
172

173 174
	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
					      vid);
175 176
	if (tt_common_entry)
		tt_local_entry = container_of(tt_common_entry,
177 178
					      struct batadv_tt_local_entry,
					      common);
179 180
	return tt_local_entry;
}
181

182 183 184 185 186 187
/**
 * batadv_tt_global_hash_find - search the global table for a given client
 * @bat_priv: the bat priv with all the soft interface information
 * @addr: the mac address of the client to look for
 * @vid: VLAN identifier
 *
188
 * Return: a pointer to the corresponding tt_global_entry struct if the client
189 190
 * is found, NULL otherwise.
 */
191
static struct batadv_tt_global_entry *
192
batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
193
			   unsigned short vid)
194
{
195 196
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_global_entry *tt_global_entry = NULL;
197

198 199
	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
					      vid);
200 201
	if (tt_common_entry)
		tt_global_entry = container_of(tt_common_entry,
202 203
					       struct batadv_tt_global_entry,
					       common);
204
	return tt_global_entry;
205 206
}

207 208 209 210 211 212 213 214 215 216 217 218
/**
 * batadv_tt_local_entry_release - release tt_local_entry from lists and queue
 *  for free after rcu grace period
 * @ref: kref pointer of the nc_node
 */
static void batadv_tt_local_entry_release(struct kref *ref)
{
	struct batadv_tt_local_entry *tt_local_entry;

	tt_local_entry = container_of(ref, struct batadv_tt_local_entry,
				      common.refcount);

219 220
	batadv_softif_vlan_put(tt_local_entry->vlan);

221 222 223 224
	kfree_rcu(tt_local_entry, common.rcu);
}

/**
225
 * batadv_tt_local_entry_put - decrement the tt_local_entry refcounter and
226 227 228
 *  possibly release it
 * @tt_local_entry: tt_local_entry to be free'd
 */
229
static void
230
batadv_tt_local_entry_put(struct batadv_tt_local_entry *tt_local_entry)
231
{
232 233
	kref_put(&tt_local_entry->common.refcount,
		 batadv_tt_local_entry_release);
234 235
}

236
/**
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
 * batadv_tt_global_entry_release - release tt_global_entry from lists and queue
 *  for free after rcu grace period
 * @ref: kref pointer of the nc_node
 */
static void batadv_tt_global_entry_release(struct kref *ref)
{
	struct batadv_tt_global_entry *tt_global_entry;

	tt_global_entry = container_of(ref, struct batadv_tt_global_entry,
				       common.refcount);

	batadv_tt_global_del_orig_list(tt_global_entry);
	kfree_rcu(tt_global_entry, common.rcu);
}

/**
253 254
 * batadv_tt_global_entry_put - decrement the tt_global_entry refcounter and
 *  possibly release it
255
 * @tt_global_entry: tt_global_entry to be free'd
256
 */
257
static void
258
batadv_tt_global_entry_put(struct batadv_tt_global_entry *tt_global_entry)
259
{
260 261
	kref_put(&tt_global_entry->common.refcount,
		 batadv_tt_global_entry_release);
262 263
}

264 265
/**
 * batadv_tt_global_hash_count - count the number of orig entries
266
 * @bat_priv: the bat priv with all the soft interface information
267 268 269
 * @addr: the mac address of the client to count entries for
 * @vid: VLAN identifier
 *
270
 * Return: the number of originators advertising the given address/data
271 272 273
 * (excluding ourself).
 */
int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
274
				const u8 *addr, unsigned short vid)
275 276 277 278 279 280 281 282 283
{
	struct batadv_tt_global_entry *tt_global_entry;
	int count;

	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
	if (!tt_global_entry)
		return 0;

	count = atomic_read(&tt_global_entry->orig_list_count);
284
	batadv_tt_global_entry_put(tt_global_entry);
285 286 287 288

	return count;
}

289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
/**
 * batadv_tt_local_size_mod - change the size by v of the local table identified
 *  by vid
 * @bat_priv: the bat priv with all the soft interface information
 * @vid: the VLAN identifier of the sub-table to change
 * @v: the amount to sum to the local table size
 */
static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,
				     unsigned short vid, int v)
{
	struct batadv_softif_vlan *vlan;

	vlan = batadv_softif_vlan_get(bat_priv, vid);
	if (!vlan)
		return;

	atomic_add(v, &vlan->tt.num_entries);

307
	batadv_softif_vlan_put(vlan);
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
}

/**
 * batadv_tt_local_size_inc - increase by one the local table size for the given
 *  vid
 * @bat_priv: the bat priv with all the soft interface information
 * @vid: the VLAN identifier
 */
static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,
				     unsigned short vid)
{
	batadv_tt_local_size_mod(bat_priv, vid, 1);
}

/**
 * batadv_tt_local_size_dec - decrease by one the local table size for the given
 *  vid
 * @bat_priv: the bat priv with all the soft interface information
 * @vid: the VLAN identifier
 */
static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,
				     unsigned short vid)
{
	batadv_tt_local_size_mod(bat_priv, vid, -1);
}

/**
335 336 337
 * batadv_tt_global_size_mod - change the size by v of the global table
 *  for orig_node identified by vid
 * @orig_node: the originator for which the table has to be modified
338 339 340 341 342 343 344 345 346 347 348 349 350 351
 * @vid: the VLAN identifier
 * @v: the amount to sum to the global table size
 */
static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,
				      unsigned short vid, int v)
{
	struct batadv_orig_node_vlan *vlan;

	vlan = batadv_orig_node_vlan_new(orig_node, vid);
	if (!vlan)
		return;

	if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {
		spin_lock_bh(&orig_node->vlan_list_lock);
352 353
		if (!hlist_unhashed(&vlan->list)) {
			hlist_del_init_rcu(&vlan->list);
354
			batadv_orig_node_vlan_put(vlan);
355
		}
356 357 358
		spin_unlock_bh(&orig_node->vlan_list_lock);
	}

359
	batadv_orig_node_vlan_put(vlan);
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
}

/**
 * batadv_tt_global_size_inc - increase by one the global table size for the
 *  given vid
 * @orig_node: the originator which global table size has to be decreased
 * @vid: the vlan identifier
 */
static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,
				      unsigned short vid)
{
	batadv_tt_global_size_mod(orig_node, vid, 1);
}

/**
 * batadv_tt_global_size_dec - decrease by one the global table size for the
 *  given vid
 * @orig_node: the originator which global table size has to be decreased
 * @vid: the vlan identifier
 */
static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,
				      unsigned short vid)
{
	batadv_tt_global_size_mod(orig_node, vid, -1);
}

386 387 388
/**
 * batadv_tt_orig_list_entry_release - release tt orig entry from lists and
 *  queue for free after rcu grace period
389
 * @ref: kref pointer of the tt orig entry
390
 */
391
static void batadv_tt_orig_list_entry_release(struct kref *ref)
392
{
393 394 395 396 397
	struct batadv_tt_orig_list_entry *orig_entry;

	orig_entry = container_of(ref, struct batadv_tt_orig_list_entry,
				  refcount);

398
	batadv_orig_node_put(orig_entry->orig_node);
399 400 401
	kfree_rcu(orig_entry, rcu);
}

402
/**
403 404
 * batadv_tt_orig_list_entry_put - decrement the tt orig entry refcounter and
 *  possibly release it
405 406
 * @orig_entry: tt orig entry to be free'd
 */
407
static void
408
batadv_tt_orig_list_entry_put(struct batadv_tt_orig_list_entry *orig_entry)
409
{
410
	kref_put(&orig_entry->refcount, batadv_tt_orig_list_entry_release);
411 412
}

413 414 415 416 417 418
/**
 * batadv_tt_local_event - store a local TT event (ADD/DEL)
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_local_entry: the TT entry involved in the event
 * @event_flags: flags to store in the event structure
 */
419
static void batadv_tt_local_event(struct batadv_priv *bat_priv,
420
				  struct batadv_tt_local_entry *tt_local_entry,
421
				  u8 event_flags)
422
{
423
	struct batadv_tt_change_node *tt_change_node, *entry, *safe;
424
	struct batadv_tt_common_entry *common = &tt_local_entry->common;
425
	u8 flags = common->flags | event_flags;
426 427
	bool event_removed = false;
	bool del_op_requested, del_op_entry;
428 429 430 431 432

	tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
	if (!tt_change_node)
		return;

433
	tt_change_node->change.flags = flags;
434 435
	memset(tt_change_node->change.reserved, 0,
	       sizeof(tt_change_node->change.reserved));
436
	ether_addr_copy(tt_change_node->change.addr, common->addr);
437
	tt_change_node->change.vid = htons(common->vid);
438

439
	del_op_requested = flags & BATADV_TT_CLIENT_DEL;
440 441

	/* check for ADD+DEL or DEL+ADD events */
442 443
	spin_lock_bh(&bat_priv->tt.changes_list_lock);
	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
444
				 list) {
445
		if (!batadv_compare_eth(entry->change.addr, common->addr))
446 447 448 449 450 451 452 453 454
			continue;

		/* DEL+ADD in the same orig interval have no effect and can be
		 * removed to avoid silly behaviour on the receiver side. The
		 * other way around (ADD+DEL) can happen in case of roaming of
		 * a client still in the NEW state. Roaming of NEW clients is
		 * now possible due to automatically recognition of "temporary"
		 * clients
		 */
455
		del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
456 457 458 459
		if (!del_op_requested && del_op_entry)
			goto del;
		if (del_op_requested && !del_op_entry)
			goto del;
460 461 462 463 464 465 466

		/* this is a second add in the same originator interval. It
		 * means that flags have been changed: update them!
		 */
		if (!del_op_requested && !del_op_entry)
			entry->change.flags = flags;

467 468 469 470
		continue;
del:
		list_del(&entry->list);
		kfree(entry);
471
		kfree(tt_change_node);
472 473 474 475
		event_removed = true;
		goto unlock;
	}

476
	/* track the change in the OGMinterval list */
477
	list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);
478 479

unlock:
480
	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
481

482
	if (event_removed)
483
		atomic_dec(&bat_priv->tt.local_changes);
484
	else
485
		atomic_inc(&bat_priv->tt.local_changes);
486 487
}

488 489 490 491
/**
 * batadv_tt_len - compute length in bytes of given number of tt changes
 * @changes_num: number of tt changes
 *
492
 * Return: computed length in bytes.
493 494
 */
static int batadv_tt_len(int changes_num)
495
{
496
	return changes_num * sizeof(struct batadv_tvlv_tt_change);
497 498
}

499 500 501 502
/**
 * batadv_tt_entries - compute the number of entries fitting in tt_len bytes
 * @tt_len: available space
 *
503
 * Return: the number of entries.
504
 */
505
static u16 batadv_tt_entries(u16 tt_len)
506 507 508 509
{
	return tt_len / batadv_tt_len(1);
}

510 511 512 513 514
/**
 * batadv_tt_local_table_transmit_size - calculates the local translation table
 *  size when transmitted over the air
 * @bat_priv: the bat priv with all the soft interface information
 *
515
 * Return: local translation table size in bytes.
516 517 518
 */
static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
{
519 520
	u16 num_vlan = 0;
	u16 tt_local_entries = 0;
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	struct batadv_softif_vlan *vlan;
	int hdr_size;

	rcu_read_lock();
	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
		num_vlan++;
		tt_local_entries += atomic_read(&vlan->tt.num_entries);
	}
	rcu_read_unlock();

	/* header size of tvlv encapsulated tt response payload */
	hdr_size = sizeof(struct batadv_unicast_tvlv_packet);
	hdr_size += sizeof(struct batadv_tvlv_hdr);
	hdr_size += sizeof(struct batadv_tvlv_tt_data);
	hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);

	return hdr_size + batadv_tt_len(tt_local_entries);
}

540
static int batadv_tt_local_init(struct batadv_priv *bat_priv)
541
{
542
	if (bat_priv->tt.local_hash)
543
		return 0;
544

545
	bat_priv->tt.local_hash = batadv_hash_new(1024);
546

547
	if (!bat_priv->tt.local_hash)
548
		return -ENOMEM;
549

550 551 552
	batadv_hash_set_lock_class(bat_priv->tt.local_hash,
				   &batadv_tt_local_hash_lock_class_key);

553
	return 0;
554 555
}

556 557 558 559 560
static void batadv_tt_global_free(struct batadv_priv *bat_priv,
				  struct batadv_tt_global_entry *tt_global,
				  const char *message)
{
	batadv_dbg(BATADV_DBG_TT, bat_priv,
561 562 563
		   "Deleting global tt entry %pM (vid: %d): %s\n",
		   tt_global->common.addr,
		   BATADV_PRINT_VID(tt_global->common.vid), message);
564 565

	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
566
			   batadv_choose_tt, &tt_global->common);
567
	batadv_tt_global_entry_put(tt_global);
568 569
}

570 571 572 573 574 575 576 577
/**
 * batadv_tt_local_add - add a new client to the local table or update an
 *  existing client
 * @soft_iface: netdev struct of the mesh interface
 * @addr: the mac address of the client to add
 * @vid: VLAN identifier
 * @ifindex: index of the interface where the client is connected to (useful to
 *  identify wireless clients)
578 579
 * @mark: the value contained in the skb->mark field of the received packet (if
 *  any)
580
 *
581
 * Return: true if the client was successfully added, false otherwise.
582
 */
583 584
bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,
			 unsigned short vid, int ifindex, u32 mark)
585
{
586
	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
587
	struct batadv_tt_local_entry *tt_local;
588
	struct batadv_tt_global_entry *tt_global = NULL;
589
	struct net *net = dev_net(soft_iface);
590
	struct batadv_softif_vlan *vlan;
591
	struct net_device *in_dev = NULL;
592
	struct hlist_head *head;
593
	struct batadv_tt_orig_list_entry *orig_entry;
594
	int hash_added, table_size, packet_size_max;
595 596
	bool ret = false;
	bool roamed_back = false;
597 598
	u8 remote_flags;
	u32 match_mark;
599

600
	if (ifindex != BATADV_NULL_IFINDEX)
601
		in_dev = dev_get_by_index(net, ifindex);
602

603
	tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);
604 605 606

	if (!is_multicast_ether_addr(addr))
		tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);
607

608 609
	if (tt_local) {
		tt_local->last_seen = jiffies;
610 611
		if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
			batadv_dbg(BATADV_DBG_TT, bat_priv,
612 613
				   "Re-adding pending client %pM (vid: %d)\n",
				   addr, BATADV_PRINT_VID(vid));
614 615 616 617 618 619 620 621 622 623 624
			/* whatever the reason why the PENDING flag was set,
			 * this is a client which was enqueued to be removed in
			 * this orig_interval. Since it popped up again, the
			 * flag can be reset like it was never enqueued
			 */
			tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;
			goto add_event;
		}

		if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {
			batadv_dbg(BATADV_DBG_TT, bat_priv,
625 626
				   "Roaming client %pM (vid: %d) came back to its original location\n",
				   addr, BATADV_PRINT_VID(vid));
627 628 629 630 631 632 633 634 635
			/* the ROAM flag is set because this client roamed away
			 * and the node got a roaming_advertisement message. Now
			 * that the client popped up again at its original
			 * location such flag can be unset
			 */
			tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;
			roamed_back = true;
		}
		goto check_roaming;
636 637
	}

638 639 640 641 642 643 644 645 646 647 648
	/* Ignore the client if we cannot send it in a full table response. */
	table_size = batadv_tt_local_table_transmit_size(bat_priv);
	table_size += batadv_tt_len(1);
	packet_size_max = atomic_read(&bat_priv->packet_size_max);
	if (table_size > packet_size_max) {
		net_ratelimited_function(batadv_info, soft_iface,
					 "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",
					 table_size, packet_size_max, addr);
		goto out;
	}

649 650
	tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);
	if (!tt_local)
651
		goto out;
652

653 654
	/* increase the refcounter of the related vlan */
	vlan = batadv_softif_vlan_get(bat_priv, vid);
655 656 657 658
	if (!vlan) {
		net_ratelimited_function(batadv_info, soft_iface,
					 "adding TT local entry %pM to non-existent VLAN %d\n",
					 addr, BATADV_PRINT_VID(vid));
659 660
		kfree(tt_local);
		tt_local = NULL;
661
		goto out;
662
	}
663

664
	batadv_dbg(BATADV_DBG_TT, bat_priv,
665 666
		   "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",
		   addr, BATADV_PRINT_VID(vid),
667
		   (u8)atomic_read(&bat_priv->tt.vn));
668

669
	ether_addr_copy(tt_local->common.addr, addr);
670 671 672 673 674
	/* The local entry has to be marked as NEW to avoid to send it in
	 * a full table response going out before the next ttvn increment
	 * (consistency check)
	 */
	tt_local->common.flags = BATADV_TT_CLIENT_NEW;
675
	tt_local->common.vid = vid;
676
	if (batadv_is_wifi_netdev(in_dev))
677
		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
678 679
	kref_init(&tt_local->common.refcount);
	kref_get(&tt_local->common.refcount);
680 681
	tt_local->last_seen = jiffies;
	tt_local->common.added_at = tt_local->last_seen;
682
	tt_local->vlan = vlan;
683

684 685 686 687 688
	/* the batman interface mac and multicast addresses should never be
	 * purged
	 */
	if (batadv_compare_eth(addr, soft_iface->dev_addr) ||
	    is_multicast_ether_addr(addr))
689
		tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;
690

691
	hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
692
				     batadv_choose_tt, &tt_local->common,
693
				     &tt_local->common.hash_entry);
694 695 696

	if (unlikely(hash_added != 0)) {
		/* remove the reference for the hash */
697
		batadv_tt_local_entry_put(tt_local);
698 699 700
		goto out;
	}

701
add_event:
702
	batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
703

704 705 706 707 708
check_roaming:
	/* Check whether it is a roaming, but don't do anything if the roaming
	 * process has already been handled
	 */
	if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {
709
		/* These node are probably going to update their tt table */
710
		head = &tt_global->orig_list;
711
		rcu_read_lock();
712
		hlist_for_each_entry_rcu(orig_entry, head, list) {
713
			batadv_send_roam_adv(bat_priv, tt_global->common.addr,
714
					     tt_global->common.vid,
715
					     orig_entry->orig_node);
716 717
		}
		rcu_read_unlock();
718 719 720 721 722 723 724 725 726 727 728
		if (roamed_back) {
			batadv_tt_global_free(bat_priv, tt_global,
					      "Roaming canceled");
			tt_global = NULL;
		} else {
			/* The global entry has to be marked as ROAMING and
			 * has to be kept for consistency purpose
			 */
			tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;
			tt_global->roam_at = jiffies;
		}
729
	}
730

731 732 733 734 735 736 737 738 739
	/* store the current remote flags before altering them. This helps
	 * understanding is flags are changing or not
	 */
	remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;

	if (batadv_is_wifi_netdev(in_dev))
		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
	else
		tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;
740

741 742 743 744 745 746 747 748 749 750 751
	/* check the mark in the skb: if it's equal to the configured
	 * isolation_mark, it means the packet is coming from an isolated
	 * non-mesh client
	 */
	match_mark = (mark & bat_priv->isolation_mark_mask);
	if (bat_priv->isolation_mark_mask &&
	    match_mark == bat_priv->isolation_mark)
		tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;
	else
		tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;

752 753 754 755 756 757 758
	/* if any "dynamic" flag has been modified, resend an ADD event for this
	 * entry so that all the nodes can get the new flags
	 */
	if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))
		batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);

	ret = true;
759
out:
760 761
	if (in_dev)
		dev_put(in_dev);
762
	if (tt_local)
763
		batadv_tt_local_entry_put(tt_local);
764
	if (tt_global)
765
		batadv_tt_global_entry_put(tt_global);
766
	return ret;
767 768
}

769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
/**
 * batadv_tt_prepare_tvlv_global_data - prepare the TVLV TT header to send
 *  within a TT Response directed to another node
 * @orig_node: originator for which the TT data has to be prepared
 * @tt_data: uninitialised pointer to the address of the TVLV buffer
 * @tt_change: uninitialised pointer to the address of the area where the TT
 *  changed can be stored
 * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
 *  function reserves the amount of space needed to send the entire global TT
 *  table. In case of success the value is updated with the real amount of
 *  reserved bytes
 * Allocate the needed amount of memory for the entire TT TVLV and write its
 * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
 * objects, one per active VLAN served by the originator node.
 *
784
 * Return: the size of the allocated buffer or 0 in case of failure.
785
 */
786
static u16
787 788 789
batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,
				   struct batadv_tvlv_tt_data **tt_data,
				   struct batadv_tvlv_tt_change **tt_change,
790
				   s32 *tt_len)
791
{
792 793 794 795
	u16 num_vlan = 0;
	u16 num_entries = 0;
	u16 change_offset;
	u16 tvlv_len;
796 797
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
	struct batadv_orig_node_vlan *vlan;
798
	u8 *tt_change_ptr;
799 800

	rcu_read_lock();
801
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
		num_vlan++;
		num_entries += atomic_read(&vlan->tt.num_entries);
	}

	change_offset = sizeof(**tt_data);
	change_offset += num_vlan * sizeof(*tt_vlan);

	/* if tt_len is negative, allocate the space needed by the full table */
	if (*tt_len < 0)
		*tt_len = batadv_tt_len(num_entries);

	tvlv_len = *tt_len;
	tvlv_len += change_offset;

	*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
	if (!*tt_data) {
		*tt_len = 0;
		goto out;
	}

	(*tt_data)->flags = BATADV_NO_FLAGS;
	(*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);
	(*tt_data)->num_vlan = htons(num_vlan);

	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
827
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
828 829 830 831 832 833
		tt_vlan->vid = htons(vlan->vid);
		tt_vlan->crc = htonl(vlan->tt.crc);

		tt_vlan++;
	}

834
	tt_change_ptr = (u8 *)*tt_data + change_offset;
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

out:
	rcu_read_unlock();
	return tvlv_len;
}

/**
 * batadv_tt_prepare_tvlv_local_data - allocate and prepare the TT TVLV for this
 *  node
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_data: uninitialised pointer to the address of the TVLV buffer
 * @tt_change: uninitialised pointer to the address of the area where the TT
 *  changes can be stored
 * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
 *  function reserves the amount of space needed to send the entire local TT
 *  table. In case of success the value is updated with the real amount of
 *  reserved bytes
 *
 * Allocate the needed amount of memory for the entire TT TVLV and write its
 * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
 * objects, one per active VLAN.
 *
858
 * Return: the size of the allocated buffer or 0 in case of failure.
859
 */
860
static u16
861 862 863
batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,
				  struct batadv_tvlv_tt_data **tt_data,
				  struct batadv_tvlv_tt_change **tt_change,
864
				  s32 *tt_len)
865 866 867
{
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
	struct batadv_softif_vlan *vlan;
868 869 870
	u16 num_vlan = 0;
	u16 num_entries = 0;
	u16 tvlv_len;
871
	u8 *tt_change_ptr;
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
	int change_offset;

	rcu_read_lock();
	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
		num_vlan++;
		num_entries += atomic_read(&vlan->tt.num_entries);
	}

	change_offset = sizeof(**tt_data);
	change_offset += num_vlan * sizeof(*tt_vlan);

	/* if tt_len is negative, allocate the space needed by the full table */
	if (*tt_len < 0)
		*tt_len = batadv_tt_len(num_entries);

	tvlv_len = *tt_len;
	tvlv_len += change_offset;

	*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
	if (!*tt_data) {
		tvlv_len = 0;
		goto out;
	}

	(*tt_data)->flags = BATADV_NO_FLAGS;
	(*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);
	(*tt_data)->num_vlan = htons(num_vlan);

	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
		tt_vlan->vid = htons(vlan->vid);
		tt_vlan->crc = htonl(vlan->tt.crc);

		tt_vlan++;
	}

908
	tt_change_ptr = (u8 *)*tt_data + change_offset;
909 910 911 912 913 914 915
	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

out:
	rcu_read_unlock();
	return tvlv_len;
}

916 917 918 919 920 921
/**
 * batadv_tt_tvlv_container_update - update the translation table tvlv container
 *  after local tt changes have been committed
 * @bat_priv: the bat priv with all the soft interface information
 */
static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)
922
{
923 924 925
	struct batadv_tt_change_node *entry, *safe;
	struct batadv_tvlv_tt_data *tt_data;
	struct batadv_tvlv_tt_change *tt_change;
926
	int tt_diff_len, tt_change_len = 0;
927 928
	int tt_diff_entries_num = 0;
	int tt_diff_entries_count = 0;
929
	u16 tvlv_len;
930

931 932
	tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
	tt_diff_len = batadv_tt_len(tt_diff_entries_num);
933 934 935 936

	/* if we have too many changes for one packet don't send any
	 * and wait for the tt table request which will be fragmented
	 */
937 938
	if (tt_diff_len > bat_priv->soft_iface->mtu)
		tt_diff_len = 0;
939

940 941 942
	tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
						     &tt_change, &tt_diff_len);
	if (!tvlv_len)
943
		return;
944

945
	tt_data->flags = BATADV_TT_OGM_DIFF;
946

947 948
	if (tt_diff_len == 0)
		goto container_register;
949

950 951
	spin_lock_bh(&bat_priv->tt.changes_list_lock);
	atomic_set(&bat_priv->tt.local_changes, 0);
952

953
	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
954
				 list) {
955 956 957 958 959
		if (tt_diff_entries_count < tt_diff_entries_num) {
			memcpy(tt_change + tt_diff_entries_count,
			       &entry->change,
			       sizeof(struct batadv_tvlv_tt_change));
			tt_diff_entries_count++;
960
		}
961 962
		list_del(&entry->list);
		kfree(entry);
963
	}
964
	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
965 966

	/* Keep the buffer for possible tt_request */
967 968 969 970
	spin_lock_bh(&bat_priv->tt.last_changeset_lock);
	kfree(bat_priv->tt.last_changeset);
	bat_priv->tt.last_changeset_len = 0;
	bat_priv->tt.last_changeset = NULL;
971
	tt_change_len = batadv_tt_len(tt_diff_entries_count);
972
	/* check whether this new OGM has no changes due to size problems */
973
	if (tt_diff_entries_count > 0) {
974
		/* if kmalloc() fails we will reply with the full table
975 976
		 * instead of providing the diff
		 */
977
		bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);
978
		if (bat_priv->tt.last_changeset) {
979 980 981
			memcpy(bat_priv->tt.last_changeset,
			       tt_change, tt_change_len);
			bat_priv->tt.last_changeset_len = tt_diff_len;
982 983
		}
	}
984
	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
985

986 987
container_register:
	batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,
988
				       tvlv_len);
989
	kfree(tt_data);
990 991
}

992
int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
993 994
{
	struct net_device *net_dev = (struct net_device *)seq->private;
995
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
996
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
997
	struct batadv_tt_common_entry *tt_common_entry;
998
	struct batadv_tt_local_entry *tt_local;
999
	struct batadv_hard_iface *primary_if;
1000
	struct hlist_head *head;
1001
	u32 i;
1002 1003 1004 1005
	int last_seen_secs;
	int last_seen_msecs;
	unsigned long last_seen_jiffies;
	bool no_purge;
1006
	u16 np_flag = BATADV_TT_CLIENT_NOPURGE;
1007

1008 1009
	primary_if = batadv_seq_print_text_primary_if_get(seq);
	if (!primary_if)
1010
		goto out;
1011

1012
	seq_printf(seq,
1013
		   "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
1014
		   net_dev->name, (u8)atomic_read(&bat_priv->tt.vn));
1015 1016
	seq_puts(seq,
		 "       Client         VID Flags    Last seen (CRC       )\n");
1017 1018 1019 1020

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];

1021
		rcu_read_lock();
1022
		hlist_for_each_entry_rcu(tt_common_entry,
1023
					 head, hash_entry) {
1024 1025 1026 1027 1028 1029 1030 1031 1032
			tt_local = container_of(tt_common_entry,
						struct batadv_tt_local_entry,
						common);
			last_seen_jiffies = jiffies - tt_local->last_seen;
			last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
			last_seen_secs = last_seen_msecs / 1000;
			last_seen_msecs = last_seen_msecs % 1000;

			no_purge = tt_common_entry->flags & np_flag;
1033
			seq_printf(seq,
1034
				   " * %pM %4i [%c%c%c%c%c%c] %3u.%03u   (%#.8x)\n",
1035
				   tt_common_entry->addr,
1036
				   BATADV_PRINT_VID(tt_common_entry->vid),
1037 1038
				   ((tt_common_entry->flags &
				     BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
1039
				   no_purge ? 'P' : '.',
1040 1041 1042 1043 1044 1045 1046 1047
				   ((tt_common_entry->flags &
				     BATADV_TT_CLIENT_NEW) ? 'N' : '.'),
				   ((tt_common_entry->flags &
				     BATADV_TT_CLIENT_PENDING) ? 'X' : '.'),
				   ((tt_common_entry->flags &
				     BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
				   ((tt_common_entry->flags &
				     BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1048
				   no_purge ? 0 : last_seen_secs,
1049
				   no_purge ? 0 : last_seen_msecs,
1050
				   tt_local->vlan->tt.crc);
1051
		}
1052
		rcu_read_unlock();
1053
	}
1054 1055
out:
	if (primary_if)
1056
		batadv_hardif_put(primary_if);
1057
	return 0;
1058 1059
}

1060 1061 1062
static void
batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
			    struct batadv_tt_local_entry *tt_local_entry,
1063
			    u16 flags, const char *message)
1064
{
1065
	batadv_tt_local_event(bat_priv, tt_local_entry, flags);
1066

1067 1068
	/* The local client has to be marked as "pending to be removed" but has
	 * to be kept in the table in order to send it in a full table
1069 1070
	 * response issued before the net ttvn increment (consistency check)
	 */
1071
	tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
1072

1073
	batadv_dbg(BATADV_DBG_TT, bat_priv,
1074 1075 1076
		   "Local tt entry (%pM, vid: %d) pending to be removed: %s\n",
		   tt_local_entry->common.addr,
		   BATADV_PRINT_VID(tt_local_entry->common.vid), message);
1077 1078
}

1079 1080 1081 1082
/**
 * batadv_tt_local_remove - logically remove an entry from the local table
 * @bat_priv: the bat priv with all the soft interface information
 * @addr: the MAC address of the client to remove
1083
 * @vid: VLAN identifier
1084 1085 1086
 * @message: message to append to the log on deletion
 * @roaming: true if the deletion is due to a roaming event
 *
1087
 * Return: the flags assigned to the local entry before being deleted
1088
 */
1089 1090 1091
u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,
			   unsigned short vid, const char *message,
			   bool roaming)
1092
{
1093
	struct batadv_tt_local_entry *tt_local_entry;
1094
	u16 flags, curr_flags = BATADV_NO_FLAGS;
1095
	void *tt_entry_exists;
1096

1097
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
1098 1099 1100
	if (!tt_local_entry)
		goto out;

1101 1102
	curr_flags = tt_local_entry->common.flags;

1103
	flags = BATADV_TT_CLIENT_DEL;
1104 1105 1106 1107
	/* if this global entry addition is due to a roaming, the node has to
	 * mark the local entry as "roamed" in order to correctly reroute
	 * packets later
	 */
1108
	if (roaming) {
1109
		flags |= BATADV_TT_CLIENT_ROAM;
1110 1111 1112
		/* mark the local client as ROAMed */
		tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
	}
1113

1114 1115 1116 1117 1118 1119 1120 1121
	if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {
		batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,
					    message);
		goto out;
	}
	/* if this client has been added right now, it is possible to
	 * immediately purge it
	 */
1122
	batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
1123 1124 1125 1126 1127 1128 1129 1130 1131

	tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash,
					     batadv_compare_tt,
					     batadv_choose_tt,
					     &tt_local_entry->common);
	if (!tt_entry_exists)
		goto out;

	/* extra call to free the local tt entry */
1132
	batadv_tt_local_entry_put(tt_local_entry);
1133

1134 1135
out:
	if (tt_local_entry)
1136
		batadv_tt_local_entry_put(tt_local_entry);
1137 1138

	return curr_flags;
1139 1140
}

1141 1142 1143 1144 1145 1146 1147
/**
 * batadv_tt_local_purge_list - purge inactive tt local entries
 * @bat_priv: the bat priv with all the soft interface information
 * @head: pointer to the list containing the local tt entries
 * @timeout: parameter deciding whether a given tt local entry is considered
 *  inactive or not
 */
1148
static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
1149 1150
				       struct hlist_head *head,
				       int timeout)
1151
{
1152 1153
	struct batadv_tt_local_entry *tt_local_entry;
	struct batadv_tt_common_entry *tt_common_entry;
1154
	struct hlist_node *node_tmp;
1155

1156
	hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
1157 1158
				  hash_entry) {
		tt_local_entry = container_of(tt_common_entry,
1159 1160
					      struct batadv_tt_local_entry,
					      common);
1161 1162 1163 1164 1165 1166 1167
		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
			continue;

		/* entry already marked for deletion */
		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
			continue;

1168
		if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))
1169 1170 1171 1172 1173 1174 1175
			continue;

		batadv_tt_local_set_pending(bat_priv, tt_local_entry,
					    BATADV_TT_CLIENT_DEL, "timed out");
	}
}

1176 1177 1178 1179 1180 1181 1182 1183
/**
 * batadv_tt_local_purge - purge inactive tt local entries
 * @bat_priv: the bat priv with all the soft interface information
 * @timeout: parameter deciding whether a given tt local entry is considered
 *  inactive or not
 */
static void batadv_tt_local_purge(struct batadv_priv *bat_priv,
				  int timeout)
1184
{
1185
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1186
	struct hlist_head *head;
1187
	spinlock_t *list_lock; /* protects write access to the hash lists */
1188
	u32 i;
1189 1190 1191

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];
1192
		list_lock = &hash->list_locks[i];
1193

1194
		spin_lock_bh(list_lock);
1195
		batadv_tt_local_purge_list(bat_priv, head, timeout);
1196
		spin_unlock_bh(list_lock);
1197 1198 1199
	}
}

1200
static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
1201
{
1202
	struct batadv_hashtable *hash;
1203
	spinlock_t *list_lock; /* protects write access to the hash lists */
1204 1205
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_local_entry *tt_local;
1206
	struct hlist_node *node_tmp;
1207
	struct hlist_head *head;
1208
	u32 i;
1209

1210
	if (!bat_priv->tt.local_hash)
1211 1212
		return;

1213
	hash = bat_priv->tt.local_hash;
1214 1215 1216 1217 1218 1219

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];
		list_lock = &hash->list_locks[i];

		spin_lock_bh(list_lock);
1220
		hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1221
					  head, hash_entry) {
1222
			hlist_del_rcu(&tt_common_entry->hash_entry);
1223 1224 1225
			tt_local = container_of(tt_common_entry,
						struct batadv_tt_local_entry,
						common);
1226

1227
			batadv_tt_local_entry_put(tt_local);
1228 1229 1230 1231
		}
		spin_unlock_bh(list_lock);
	}

1232
	batadv_hash_destroy(hash);
1233

1234
	bat_priv->tt.local_hash = NULL;
1235 1236
}

1237
static int batadv_tt_global_init(struct batadv_priv *bat_priv)
1238
{
1239
	if (bat_priv->tt.global_hash)
1240
		return 0;
1241

1242
	bat_priv->tt.global_hash = batadv_hash_new(1024);
1243

1244
	if (!bat_priv->tt.global_hash)
1245
		return -ENOMEM;
1246

1247 1248 1249
	batadv_hash_set_lock_class(bat_priv->tt.global_hash,
				   &batadv_tt_global_hash_lock_class_key);

1250
	return 0;
1251 1252
}

1253
static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
1254
{
1255
	struct batadv_tt_change_node *entry, *safe;
1256

1257
	spin_lock_bh(&bat_priv->tt.changes_list_lock);
1258

1259
	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1260 1261 1262 1263
				 list) {
		list_del(&entry->list);
		kfree(entry);
	}
1264

1265 1266
	atomic_set(&bat_priv->tt.local_changes, 0);
	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1267
}
1268

1269
/**
1270 1271 1272 1273
 * batadv_tt_global_orig_entry_find - find a TT orig_list_entry
 * @entry: the TT global entry where the orig_list_entry has to be
 *  extracted from
 * @orig_node: the originator for which the orig_list_entry has to be found
1274
 *
1275
 * retrieve the orig_tt_list_entry belonging to orig_node from the
1276 1277
 * batadv_tt_global_entry list
 *
1278
 * Return: it with an increased refcounter, NULL if not found
1279
 */
1280 1281 1282
static struct batadv_tt_orig_list_entry *
batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
				 const struct batadv_orig_node *orig_node)
1283
{
1284
	struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
1285 1286 1287 1288
	const struct hlist_head *head;

	rcu_read_lock();
	head = &entry->orig_list;
1289
	hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
1290 1291
		if (tmp_orig_entry->orig_node != orig_node)
			continue;
1292
		if (!kref_get_unless_zero(&tmp_orig_entry->refcount))
1293 1294 1295 1296
			continue;

		orig_entry = tmp_orig_entry;
		break;
1297 1298
	}
	rcu_read_unlock();
1299 1300 1301 1302

	return orig_entry;
}

1303
/**
1304 1305 1306 1307
 * batadv_tt_global_entry_has_orig - check if a TT global entry is also handled
 *  by a given originator
 * @entry: the TT global entry to check
 * @orig_node: the originator to search in the list
1308 1309 1310 1311
 *
 * find out if an orig_node is already in the list of a tt_global_entry.
 *
 * Return: true if found, false otherwise
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
 */
static bool
batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
				const struct batadv_orig_node *orig_node)
{
	struct batadv_tt_orig_list_entry *orig_entry;
	bool found = false;

	orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);
	if (orig_entry) {
		found = true;
1323
		batadv_tt_orig_list_entry_put(orig_entry);
1324 1325
	}

1326 1327 1328
	return found;
}

1329
static void
1330
batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
1331
				struct batadv_orig_node *orig_node, int ttvn)
1332
{
1333
	struct batadv_tt_orig_list_entry *orig_entry;
1334

1335
	orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);
1336 1337 1338 1339 1340
	if (orig_entry) {
		/* refresh the ttvn: the current value could be a bogus one that
		 * was added during a "temporary client detection"
		 */
		orig_entry->ttvn = ttvn;
1341
		goto out;
1342
	}
1343

1344 1345
	orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
	if (!orig_entry)
1346
		goto out;
1347 1348

	INIT_HLIST_NODE(&orig_entry->list);
1349
	kref_get(&orig_node->refcount);
1350
	batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
1351 1352
	orig_entry->orig_node = orig_node;
	orig_entry->ttvn = ttvn;
1353 1354
	kref_init(&orig_entry->refcount);
	kref_get(&orig_entry->refcount);
1355

1356
	spin_lock_bh(&tt_global->list_lock);
1357
	hlist_add_head_rcu(&orig_entry->list,
1358 1359
			   &tt_global->orig_list);
	spin_unlock_bh(&tt_global->list_lock);
1360 1361
	atomic_inc(&tt_global->orig_list_count);

1362 1363
out:
	if (orig_entry)
1364
		batadv_tt_orig_list_entry_put(orig_entry);
1365 1366
}

1367 1368 1369 1370 1371
/**
 * batadv_tt_global_add - add a new TT global entry or update an existing one
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: the originator announcing the client
 * @tt_addr: the mac address of the non-mesh client
1372
 * @vid: VLAN identifier
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
 * @flags: TT flags that have to be set for this non-mesh client
 * @ttvn: the tt version number ever announcing this non-mesh client
 *
 * Add a new TT global entry for the given originator. If the entry already
 * exists add a new reference to the given originator (a global entry can have
 * references to multiple originators) and adjust the flags attribute to reflect
 * the function argument.
 * If a TT local entry exists for this non-mesh client remove it.
 *
 * The caller must hold orig_node refcount.
1383
 *
1384
 * Return: true if the new entry has been added, false otherwise
1385
 */
1386 1387
static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
				 struct batadv_orig_node *orig_node,
1388
				 const unsigned char *tt_addr,
1389
				 unsigned short vid, u16 flags, u8 ttvn)
1390
{
1391 1392
	struct batadv_tt_global_entry *tt_global_entry;
	struct batadv_tt_local_entry *tt_local_entry;
1393
	bool ret = false;
1394
	int hash_added;
1395
	struct batadv_tt_common_entry *common;
1396
	u16 local_flags;
1397

1398 1399 1400 1401
	/* ignore global entries from backbone nodes */
	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
		return true;

1402 1403
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);
1404 1405 1406 1407 1408 1409 1410 1411

	/* if the node already has a local client for this entry, it has to wait
	 * for a roaming advertisement instead of manually messing up the global
	 * table
	 */
	if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&
	    !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))
		goto out;
1412 1413

	if (!tt_global_entry) {
1414
		tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);
1415
		if (!tt_global_entry)
1416 1417
			goto out;

1418
		common = &tt_global_entry->common;
1419
		ether_addr_copy(common->addr, tt_addr);
1420
		common->vid = vid;
1421

1422
		common->flags = flags;
1423
		tt_global_entry->roam_at = 0;
1424 1425 1426 1427 1428 1429
		/* node must store current time in case of roaming. This is
		 * needed to purge this entry out on timeout (if nobody claims
		 * it)
		 */
		if (flags & BATADV_TT_CLIENT_ROAM)
			tt_global_entry->roam_at = jiffies;
1430 1431
		kref_init(&common->refcount);
		kref_get(&common->refcount);
1432
		common->added_at = jiffies;
1433 1434

		INIT_HLIST_HEAD(&tt_global_entry->orig_list);
1435
		atomic_set(&tt_global_entry->orig_list_count, 0);
1436
		spin_lock_init(&tt_global_entry->list_lock);
1437

1438
		hash_added = batadv_hash_add(bat_priv->tt.global_hash,
1439
					     batadv_compare_tt,
1440
					     batadv_choose_tt, common,
1441
					     &common->hash_entry);
1442 1443 1444

		if (unlikely(hash_added != 0)) {
			/* remove the reference for the hash */
1445
			batadv_tt_global_entry_put(tt_global_entry);
1446 1447
			goto out_remove;
		}
1448
	} else {
1449
		common = &tt_global_entry->common;
1450 1451
		/* If there is already a global entry, we can use this one for
		 * our processing.
1452 1453 1454 1455 1456 1457 1458
		 * But if we are trying to add a temporary client then here are
		 * two options at this point:
		 * 1) the global client is not a temporary client: the global
		 *    client has to be left as it is, temporary information
		 *    should never override any already known client state
		 * 2) the global client is a temporary client: purge the
		 *    originator list and add the new one orig_entry
1459
		 */
1460 1461 1462 1463 1464 1465 1466 1467 1468
		if (flags & BATADV_TT_CLIENT_TEMP) {
			if (!(common->flags & BATADV_TT_CLIENT_TEMP))
				goto out;
			if (batadv_tt_global_entry_has_orig(tt_global_entry,
							    orig_node))
				goto out_remove;
			batadv_tt_global_del_orig_list(tt_global_entry);
			goto add_orig_entry;
		}
1469 1470

		/* if the client was temporary added before receiving the first
1471 1472 1473 1474
		 * OGM announcing it, we have to clear the TEMP flag. Also,
		 * remove the previous temporary orig node and re-add it
		 * if required. If the orig entry changed, the new one which
		 * is a non-temporary entry is preferred.
1475
		 */
1476 1477 1478 1479
		if (common->flags & BATADV_TT_CLIENT_TEMP) {
			batadv_tt_global_del_orig_list(tt_global_entry);
			common->flags &= ~BATADV_TT_CLIENT_TEMP;
		}
1480

1481 1482 1483 1484
		/* the change can carry possible "attribute" flags like the
		 * TT_CLIENT_WIFI, therefore they have to be copied in the
		 * client entry
		 */
1485
		common->flags |= flags;
1486

1487 1488
		/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
		 * one originator left in the list and we previously received a
1489 1490 1491 1492 1493
		 * delete + roaming change for this originator.
		 *
		 * We should first delete the old originator before adding the
		 * new one.
		 */
1494
		if (common->flags & BATADV_TT_CLIENT_ROAM) {
1495
			batadv_tt_global_del_orig_list(tt_global_entry);
1496
			common->flags &= ~BATADV_TT_CLIENT_ROAM;
1497
			tt_global_entry->roam_at = 0;
1498 1499
		}
	}
1500
add_orig_entry:
1501
	/* add the new orig_entry (if needed) or update it */
1502
	batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);
1503

1504
	batadv_dbg(BATADV_DBG_TT, bat_priv,
1505 1506 1507
		   "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
		   common->addr, BATADV_PRINT_VID(common->vid),
		   orig_node->orig);
1508
	ret = true;
1509

1510
out_remove:
1511 1512 1513 1514 1515
	/* Do not remove multicast addresses from the local hash on
	 * global additions
	 */
	if (is_multicast_ether_addr(tt_addr))
		goto out;
1516

1517
	/* remove address from local hash if present */
1518
	local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,
1519
					     "global tt received",
1520
					     flags & BATADV_TT_CLIENT_ROAM);
1521 1522
	tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;

1523 1524 1525 1526 1527 1528
	if (!(flags & BATADV_TT_CLIENT_ROAM))
		/* this is a normal global add. Therefore the client is not in a
		 * roaming state anymore.
		 */
		tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;

1529 1530
out:
	if (tt_global_entry)
1531
		batadv_tt_global_entry_put(tt_global_entry);
1532
	if (tt_local_entry)
1533
		batadv_tt_local_entry_put(tt_local_entry);
1534
	return ret;
1535 1536
}

1537 1538
/**
 * batadv_transtable_best_orig - Get best originator list entry from tt entry
1539
 * @bat_priv: the bat priv with all the soft interface information
1540 1541 1542
 * @tt_global_entry: global translation table entry to be analyzed
 *
 * This functon assumes the caller holds rcu_read_lock().
1543
 * Return: best originator list entry or NULL on errors.
1544 1545
 */
static struct batadv_tt_orig_list_entry *
1546 1547
batadv_transtable_best_orig(struct batadv_priv *bat_priv,
			    struct batadv_tt_global_entry *tt_global_entry)
1548
{
1549
	struct batadv_neigh_node *router, *best_router = NULL;
1550
	struct batadv_algo_ops *bao = bat_priv->algo_ops;
1551 1552 1553 1554
	struct hlist_head *head;
	struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;

	head = &tt_global_entry->orig_list;
1555
	hlist_for_each_entry_rcu(orig_entry, head, list) {
1556 1557
		router = batadv_orig_router_get(orig_entry->orig_node,
						BATADV_IF_DEFAULT);
1558 1559 1560
		if (!router)
			continue;

1561
		if (best_router &&
1562 1563
		    bao->neigh.cmp(router, BATADV_IF_DEFAULT, best_router,
				   BATADV_IF_DEFAULT) <= 0) {
1564
			batadv_neigh_node_put(router);
1565
			continue;
1566 1567
		}

1568 1569
		/* release the refcount for the "old" best */
		if (best_router)
1570
			batadv_neigh_node_put(best_router);
1571 1572 1573

		best_entry = orig_entry;
		best_router = router;
1574 1575
	}

1576
	if (best_router)
1577
		batadv_neigh_node_put(best_router);
1578

1579 1580 1581
	return best_entry;
}

1582 1583 1584
/**
 * batadv_tt_global_print_entry - print all orig nodes who announce the address
 *  for this global entry
1585
 * @bat_priv: the bat priv with all the soft interface information
1586 1587 1588 1589
 * @tt_global_entry: global translation table entry to be printed
 * @seq: debugfs table seq_file struct
 *
 * This functon assumes the caller holds rcu_read_lock().
1590
 */
1591
static void
1592 1593
batadv_tt_global_print_entry(struct batadv_priv *bat_priv,
			     struct batadv_tt_global_entry *tt_global_entry,
1594
			     struct seq_file *seq)
1595
{
1596
	struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
1597
	struct batadv_tt_common_entry *tt_common_entry;
1598 1599
	struct batadv_orig_node_vlan *vlan;
	struct hlist_head *head;
1600 1601
	u8 last_ttvn;
	u16 flags;
1602 1603

	tt_common_entry = &tt_global_entry->common;
1604 1605
	flags = tt_common_entry->flags;

1606
	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
1607
	if (best_entry) {
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
		vlan = batadv_orig_node_vlan_get(best_entry->orig_node,
						 tt_common_entry->vid);
		if (!vlan) {
			seq_printf(seq,
				   " * Cannot retrieve VLAN %d for originator %pM\n",
				   BATADV_PRINT_VID(tt_common_entry->vid),
				   best_entry->orig_node->orig);
			goto print_list;
		}

1618
		last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);
1619
		seq_printf(seq,
1620
			   " %c %pM %4i   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1621
			   '*', tt_global_entry->common.addr,
1622
			   BATADV_PRINT_VID(tt_global_entry->common.vid),
1623
			   best_entry->ttvn, best_entry->orig_node->orig,
1624
			   last_ttvn, vlan->tt.crc,
1625 1626 1627 1628
			   ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
			   ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
			   ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
			   ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1629

1630
		batadv_orig_node_vlan_put(vlan);
1631
	}
1632

1633
print_list:
1634 1635
	head = &tt_global_entry->orig_list;

1636
	hlist_for_each_entry_rcu(orig_entry, head, list) {
1637 1638 1639
		if (best_entry == orig_entry)
			continue;

1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
		vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,
						 tt_common_entry->vid);
		if (!vlan) {
			seq_printf(seq,
				   " + Cannot retrieve VLAN %d for originator %pM\n",
				   BATADV_PRINT_VID(tt_common_entry->vid),
				   orig_entry->orig_node->orig);
			continue;
		}

1650
		last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);
1651
		seq_printf(seq,
1652
			   " %c %pM %4d   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1653
			   '+', tt_global_entry->common.addr,
1654
			   BATADV_PRINT_VID(tt_global_entry->common.vid),
1655
			   orig_entry->ttvn, orig_entry->orig_node->orig,
1656
			   last_ttvn, vlan->tt.crc,
1657 1658 1659 1660
			   ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
			   ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
			   ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
			   ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1661

1662
		batadv_orig_node_vlan_put(vlan);
1663 1664 1665
	}
}

1666
int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
1667 1668
{
	struct net_device *net_dev = (struct net_device *)seq->private;
1669
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
1670
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1671 1672 1673
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_global_entry *tt_global;
	struct batadv_hard_iface *primary_if;
1674
	struct hlist_head *head;
1675
	u32 i;
1676

1677 1678
	primary_if = batadv_seq_print_text_primary_if_get(seq);
	if (!primary_if)
1679
		goto out;
1680

1681 1682
	seq_printf(seq,
		   "Globally announced TT entries received via the mesh %s\n",
1683
		   net_dev->name);
1684 1685
	seq_puts(seq,
		 "       Client         VID  (TTVN)       Originator      (Curr TTVN) (CRC       ) Flags\n");
1686 1687 1688 1689

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];

1690
		rcu_read_lock();
1691
		hlist_for_each_entry_rcu(tt_common_entry,
1692
					 head, hash_entry) {
1693 1694 1695
			tt_global = container_of(tt_common_entry,
						 struct batadv_tt_global_entry,
						 common);
1696
			batadv_tt_global_print_entry(bat_priv, tt_global, seq);
1697
		}
1698
		rcu_read_unlock();
1699
	}
1700 1701
out:
	if (primary_if)
1702
		batadv_hardif_put(primary_if);
1703
	return 0;
1704 1705
}

1706
/**
1707
 * _batadv_tt_global_del_orig_entry - remove and free an orig_entry
1708 1709 1710 1711 1712
 * @tt_global_entry: the global entry to remove the orig_entry from
 * @orig_entry: the orig entry to remove and free
 *
 * Remove an orig_entry from its list in the given tt_global_entry and
 * free this orig_entry afterwards.
1713 1714 1715
 *
 * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is
 * part of a list.
1716 1717
 */
static void
1718 1719
_batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
				 struct batadv_tt_orig_list_entry *orig_entry)
1720
{
1721 1722
	lockdep_assert_held(&tt_global_entry->list_lock);

1723 1724 1725
	batadv_tt_global_size_dec(orig_entry->orig_node,
				  tt_global_entry->common.vid);
	atomic_dec(&tt_global_entry->orig_list_count);
1726 1727 1728
	/* requires holding tt_global_entry->list_lock and orig_entry->list
	 * being part of a list
	 */
1729
	hlist_del_rcu(&orig_entry->list);
1730
	batadv_tt_orig_list_entry_put(orig_entry);
1731 1732
}

1733
/* deletes the orig list of a tt_global_entry */
1734
static void
1735
batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
1736
{
1737
	struct hlist_head *head;
1738
	struct hlist_node *safe;
1739
	struct batadv_tt_orig_list_entry *orig_entry;
1740

1741 1742
	spin_lock_bh(&tt_global_entry->list_lock);
	head = &tt_global_entry->orig_list;
1743
	hlist_for_each_entry_safe(orig_entry, safe, head, list)
1744
		_batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);
1745 1746 1747
	spin_unlock_bh(&tt_global_entry->list_lock);
}

1748 1749 1750 1751 1752 1753 1754 1755 1756 1757
/**
 * batadv_tt_global_del_orig_node - remove orig_node from a global tt entry
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_global_entry: the global entry to remove the orig_node from
 * @orig_node: the originator announcing the client
 * @message: message to append to the log on deletion
 *
 * Remove the given orig_node and its according orig_entry from the given
 * global tt entry.
 */
1758
static void
1759 1760 1761 1762
batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,
			       struct batadv_tt_global_entry *tt_global_entry,
			       struct batadv_orig_node *orig_node,
			       const char *message)
1763 1764
{
	struct hlist_head *head;
1765
	struct hlist_node *safe;
1766
	struct batadv_tt_orig_list_entry *orig_entry;
1767
	unsigned short vid;
1768 1769 1770

	spin_lock_bh(&tt_global_entry->list_lock);
	head = &tt_global_entry->orig_list;
1771
	hlist_for_each_entry_safe(orig_entry, safe, head, list) {
1772
		if (orig_entry->orig_node == orig_node) {
1773
			vid = tt_global_entry->common.vid;
1774
			batadv_dbg(BATADV_DBG_TT, bat_priv,
1775
				   "Deleting %pM from global tt entry %pM (vid: %d): %s\n",
1776
				   orig_node->orig,
1777 1778
				   tt_global_entry->common.addr,
				   BATADV_PRINT_VID(vid), message);
1779 1780
			_batadv_tt_global_del_orig_entry(tt_global_entry,
							 orig_entry);
1781 1782 1783 1784 1785 1786
		}
	}
	spin_unlock_bh(&tt_global_entry->list_lock);
}

/* If the client is to be deleted, we check if it is the last origantor entry
1787 1788
 * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the
 * timer, otherwise we simply remove the originator scheduled for deletion.
1789
 */
1790
static void
1791 1792 1793 1794
batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
			     struct batadv_tt_global_entry *tt_global_entry,
			     struct batadv_orig_node *orig_node,
			     const char *message)
1795 1796 1797
{
	bool last_entry = true;
	struct hlist_head *head;
1798
	struct batadv_tt_orig_list_entry *orig_entry;
1799 1800 1801 1802 1803 1804 1805

	/* no local entry exists, case 1:
	 * Check if this is the last one or if other entries exist.
	 */

	rcu_read_lock();
	head = &tt_global_entry->orig_list;
1806
	hlist_for_each_entry_rcu(orig_entry, head, list) {
1807 1808 1809 1810 1811 1812 1813 1814 1815
		if (orig_entry->orig_node != orig_node) {
			last_entry = false;
			break;
		}
	}
	rcu_read_unlock();

	if (last_entry) {
		/* its the last one, mark for roaming. */
1816
		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1817 1818 1819 1820 1821
		tt_global_entry->roam_at = jiffies;
	} else
		/* there is another entry, we can simply delete this
		 * one and can still use the other one.
		 */
1822 1823
		batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
					       orig_node, message);
1824 1825
}

1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
/**
 * batadv_tt_global_del - remove a client from the global table
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: an originator serving this client
 * @addr: the mac address of the client
 * @vid: VLAN identifier
 * @message: a message explaining the reason for deleting the client to print
 *  for debugging purpose
 * @roaming: true if the deletion has been triggered by a roaming event
 */
1836 1837
static void batadv_tt_global_del(struct batadv_priv *bat_priv,
				 struct batadv_orig_node *orig_node,
1838
				 const unsigned char *addr, unsigned short vid,
1839
				 const char *message, bool roaming)
1840
{
1841
	struct batadv_tt_global_entry *tt_global_entry;
1842
	struct batadv_tt_local_entry *local_entry = NULL;
1843

1844
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
1845
	if (!tt_global_entry)
1846
		goto out;
1847

1848
	if (!roaming) {
1849 1850
		batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
					       orig_node, message);
1851 1852

		if (hlist_empty(&tt_global_entry->orig_list))
1853 1854
			batadv_tt_global_free(bat_priv, tt_global_entry,
					      message);
1855 1856 1857

		goto out;
	}
1858 1859 1860

	/* if we are deleting a global entry due to a roam
	 * event, there are two possibilities:
1861 1862
	 * 1) the client roamed from node A to node B => if there
	 *    is only one originator left for this client, we mark
1863
	 *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we
1864 1865
	 *    wait for node B to claim it. In case of timeout
	 *    the entry is purged.
1866 1867 1868
	 *
	 *    If there are other originators left, we directly delete
	 *    the originator.
1869
	 * 2) the client roamed to us => we can directly delete
1870 1871
	 *    the global entry, since it is useless now.
	 */
1872
	local_entry = batadv_tt_local_hash_find(bat_priv,
1873 1874
						tt_global_entry->common.addr,
						vid);
1875
	if (local_entry) {
1876
		/* local entry exists, case 2: client roamed to us. */
1877
		batadv_tt_global_del_orig_list(tt_global_entry);
1878
		batadv_tt_global_free(bat_priv, tt_global_entry, message);
1879 1880
	} else
		/* no local entry exists, case 1: check for roaming */
1881 1882
		batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
					     orig_node, message);
1883

1884
out:
1885
	if (tt_global_entry)
1886
		batadv_tt_global_entry_put(tt_global_entry);
1887
	if (local_entry)
1888
		batadv_tt_local_entry_put(local_entry);
1889 1890
}

1891 1892 1893 1894 1895 1896 1897 1898 1899
/**
 * batadv_tt_global_del_orig - remove all the TT global entries belonging to the
 *  given originator matching the provided vid
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: the originator owning the entries to remove
 * @match_vid: the VLAN identifier to match. If negative all the entries will be
 *  removed
 * @message: debug message to print as "reason"
 */
1900 1901
void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
			       struct batadv_orig_node *orig_node,
1902
			       s32 match_vid,
1903
			       const char *message)
1904
{
1905 1906
	struct batadv_tt_global_entry *tt_global;
	struct batadv_tt_common_entry *tt_common_entry;
1907
	u32 i;
1908
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1909
	struct hlist_node *safe;
1910
	struct hlist_head *head;
1911
	spinlock_t *list_lock; /* protects write access to the hash lists */
1912
	unsigned short vid;
1913

1914 1915 1916
	if (!hash)
		return;

1917 1918
	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];
1919
		list_lock = &hash->list_locks[i];
1920

1921
		spin_lock_bh(list_lock);
1922
		hlist_for_each_entry_safe(tt_common_entry, safe,
1923
					  head, hash_entry) {
1924 1925 1926 1927
			/* remove only matching entries */
			if (match_vid >= 0 && tt_common_entry->vid != match_vid)
				continue;

1928 1929 1930
			tt_global = container_of(tt_common_entry,
						 struct batadv_tt_global_entry,
						 common);
1931

1932 1933
			batadv_tt_global_del_orig_node(bat_priv, tt_global,
						       orig_node, message);
1934

1935
			if (hlist_empty(&tt_global->orig_list)) {
1936
				vid = tt_global->common.vid;
1937
				batadv_dbg(BATADV_DBG_TT, bat_priv,
1938 1939 1940
					   "Deleting global tt entry %pM (vid: %d): %s\n",
					   tt_global->common.addr,
					   BATADV_PRINT_VID(vid), message);
1941
				hlist_del_rcu(&tt_common_entry->hash_entry);
1942
				batadv_tt_global_entry_put(tt_global);
1943
			}
1944
		}
1945
		spin_unlock_bh(list_lock);
1946
	}
1947
	clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
1948 1949
}

1950 1951
static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
				      char **msg)
1952
{
1953 1954 1955
	bool purge = false;
	unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
	unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;
1956

1957 1958 1959 1960 1961
	if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&
	    batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {
		purge = true;
		*msg = "Roaming timeout\n";
	}
1962

1963 1964 1965 1966
	if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&
	    batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {
		purge = true;
		*msg = "Temporary client timeout\n";
1967
	}
1968 1969

	return purge;
1970 1971
}

1972
static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
1973
{
1974
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1975
	struct hlist_head *head;
1976
	struct hlist_node *node_tmp;
1977
	spinlock_t *list_lock; /* protects write access to the hash lists */
1978
	u32 i;
1979 1980 1981
	char *msg = NULL;
	struct batadv_tt_common_entry *tt_common;
	struct batadv_tt_global_entry *tt_global;
1982 1983 1984

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];
1985
		list_lock = &hash->list_locks[i];
1986

1987
		spin_lock_bh(list_lock);
1988
		hlist_for_each_entry_safe(tt_common, node_tmp, head,
1989 1990 1991 1992 1993 1994 1995 1996 1997
					  hash_entry) {
			tt_global = container_of(tt_common,
						 struct batadv_tt_global_entry,
						 common);

			if (!batadv_tt_global_to_purge(tt_global, &msg))
				continue;

			batadv_dbg(BATADV_DBG_TT, bat_priv,
1998 1999 2000 2001
				   "Deleting global tt entry %pM (vid: %d): %s\n",
				   tt_global->common.addr,
				   BATADV_PRINT_VID(tt_global->common.vid),
				   msg);
2002

2003
			hlist_del_rcu(&tt_common->hash_entry);
2004

2005
			batadv_tt_global_entry_put(tt_global);
2006
		}
2007
		spin_unlock_bh(list_lock);
2008 2009 2010
	}
}

2011
static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
2012
{
2013
	struct batadv_hashtable *hash;
2014
	spinlock_t *list_lock; /* protects write access to the hash lists */
2015 2016
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_global_entry *tt_global;
2017
	struct hlist_node *node_tmp;
2018
	struct hlist_head *head;
2019
	u32 i;
2020

2021
	if (!bat_priv->tt.global_hash)
2022 2023
		return;

2024
	hash = bat_priv->tt.global_hash;
2025 2026 2027 2028 2029 2030

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];
		list_lock = &hash->list_locks[i];

		spin_lock_bh(list_lock);
2031
		hlist_for_each_entry_safe(tt_common_entry, node_tmp,
2032
					  head, hash_entry) {
2033
			hlist_del_rcu(&tt_common_entry->hash_entry);
2034 2035 2036
			tt_global = container_of(tt_common_entry,
						 struct batadv_tt_global_entry,
						 common);
2037
			batadv_tt_global_entry_put(tt_global);
2038 2039 2040 2041
		}
		spin_unlock_bh(list_lock);
	}

2042
	batadv_hash_destroy(hash);
2043

2044
	bat_priv->tt.global_hash = NULL;
2045 2046
}

2047 2048 2049
static bool
_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
		       struct batadv_tt_global_entry *tt_global_entry)
2050 2051 2052
{
	bool ret = false;

2053 2054
	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
	    tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
2055 2056
		ret = true;

2057 2058 2059 2060 2061
	/* check if the two clients are marked as isolated */
	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&
	    tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)
		ret = true;

2062 2063 2064
	return ret;
}

2065 2066 2067 2068 2069 2070 2071
/**
 * batadv_transtable_search - get the mesh destination for a given client
 * @bat_priv: the bat priv with all the soft interface information
 * @src: mac address of the source client
 * @addr: mac address of the destination client
 * @vid: VLAN identifier
 *
2072
 * Return: a pointer to the originator that was selected as destination in the
2073 2074 2075 2076 2077 2078
 * mesh for contacting the client 'addr', NULL otherwise.
 * In case of multiple originators serving the same client, the function returns
 * the best one (best in terms of metric towards the destination node).
 *
 * If the two clients are AP isolated the function returns NULL.
 */
2079
struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
2080 2081
						  const u8 *src,
						  const u8 *addr,
2082
						  unsigned short vid)
2083
{
2084 2085 2086
	struct batadv_tt_local_entry *tt_local_entry = NULL;
	struct batadv_tt_global_entry *tt_global_entry = NULL;
	struct batadv_orig_node *orig_node = NULL;
2087
	struct batadv_tt_orig_list_entry *best_entry;
2088

2089
	if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {
2090
		tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);
2091 2092
		if (!tt_local_entry ||
		    (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))
2093 2094
			goto out;
	}
2095

2096
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2097
	if (!tt_global_entry)
2098
		goto out;
2099

2100
	/* check whether the clients should not communicate due to AP
2101 2102
	 * isolation
	 */
2103 2104
	if (tt_local_entry &&
	    _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
2105 2106
		goto out;

2107
	rcu_read_lock();
2108
	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
2109
	/* found anything? */
2110 2111
	if (best_entry)
		orig_node = best_entry->orig_node;
2112
	if (orig_node && !kref_get_unless_zero(&orig_node->refcount))
2113 2114
		orig_node = NULL;
	rcu_read_unlock();
2115

2116
out:
2117
	if (tt_global_entry)
2118
		batadv_tt_global_entry_put(tt_global_entry);
2119
	if (tt_local_entry)
2120
		batadv_tt_local_entry_put(tt_local_entry);
2121

2122
	return orig_node;
2123
}
2124

2125 2126 2127 2128
/**
 * batadv_tt_global_crc - calculates the checksum of the local table belonging
 *  to the given orig_node
 * @bat_priv: the bat priv with all the soft interface information
2129
 * @orig_node: originator for which the CRC should be computed
2130
 * @vid: VLAN identifier for which the CRC32 has to be computed
2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146
 *
 * This function computes the checksum for the global table corresponding to a
 * specific originator. In particular, the checksum is computed as follows: For
 * each client connected to the originator the CRC32C of the MAC address and the
 * VID is computed and then all the CRC32Cs of the various clients are xor'ed
 * together.
 *
 * The idea behind is that CRC32C should be used as much as possible in order to
 * produce a unique hash of the table, but since the order which is used to feed
 * the CRC32C function affects the result and since every node in the network
 * probably sorts the clients differently, the hash function cannot be directly
 * computed over the entire table. Hence the CRC32C is used only on
 * the single client entry, while all the results are then xor'ed together
 * because the XOR operation can combine them all while trying to reduce the
 * noise as much as possible.
 *
2147
 * Return: the checksum of the global table of a given originator.
2148
 */
2149 2150 2151
static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
				struct batadv_orig_node *orig_node,
				unsigned short vid)
2152
{
2153
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2154 2155
	struct batadv_tt_common_entry *tt_common;
	struct batadv_tt_global_entry *tt_global;
2156
	struct hlist_head *head;
2157 2158
	u32 i, crc_tmp, crc = 0;
	u8 flags;
2159
	__be16 tmp_vid;
2160 2161 2162 2163 2164

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];

		rcu_read_lock();
2165
		hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2166 2167 2168
			tt_global = container_of(tt_common,
						 struct batadv_tt_global_entry,
						 common);
2169 2170 2171 2172 2173 2174
			/* compute the CRC only for entries belonging to the
			 * VLAN identified by the vid passed as parameter
			 */
			if (tt_common->vid != vid)
				continue;

2175 2176 2177 2178 2179
			/* Roaming clients are in the global table for
			 * consistency only. They don't have to be
			 * taken into account while computing the
			 * global crc
			 */
2180
			if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
2181
				continue;
2182 2183 2184 2185 2186 2187
			/* Temporary clients have not been announced yet, so
			 * they have to be skipped while computing the global
			 * crc
			 */
			if (tt_common->flags & BATADV_TT_CLIENT_TEMP)
				continue;
2188 2189 2190 2191

			/* find out if this global entry is announced by this
			 * originator
			 */
2192
			if (!batadv_tt_global_entry_has_orig(tt_global,
2193
							     orig_node))
2194 2195
				continue;

2196 2197 2198 2199 2200
			/* use network order to read the VID: this ensures that
			 * every node reads the bytes in the same order.
			 */
			tmp_vid = htons(tt_common->vid);
			crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2201 2202 2203 2204 2205 2206 2207

			/* compute the CRC on flags that have to be kept in sync
			 * among nodes
			 */
			flags = tt_common->flags & BATADV_TT_SYNC_MASK;
			crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));

2208
			crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2209 2210 2211 2212
		}
		rcu_read_unlock();
	}

2213
	return crc;
2214 2215
}

2216 2217 2218
/**
 * batadv_tt_local_crc - calculates the checksum of the local table
 * @bat_priv: the bat priv with all the soft interface information
2219
 * @vid: VLAN identifier for which the CRC32 has to be computed
2220 2221 2222 2223
 *
 * For details about the computation, please refer to the documentation for
 * batadv_tt_global_crc().
 *
2224
 * Return: the checksum of the local table
2225
 */
2226 2227
static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,
			       unsigned short vid)
2228
{
2229
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
2230
	struct batadv_tt_common_entry *tt_common;
2231
	struct hlist_head *head;
2232 2233
	u32 i, crc_tmp, crc = 0;
	u8 flags;
2234
	__be16 tmp_vid;
2235 2236 2237 2238 2239

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];

		rcu_read_lock();
2240
		hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2241 2242 2243 2244 2245 2246
			/* compute the CRC only for entries belonging to the
			 * VLAN identified by vid
			 */
			if (tt_common->vid != vid)
				continue;

2247
			/* not yet committed clients have not to be taken into
2248 2249
			 * account while computing the CRC
			 */
2250
			if (tt_common->flags & BATADV_TT_CLIENT_NEW)
2251
				continue;
2252

2253 2254 2255 2256 2257
			/* use network order to read the VID: this ensures that
			 * every node reads the bytes in the same order.
			 */
			tmp_vid = htons(tt_common->vid);
			crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2258 2259 2260 2261 2262 2263 2264

			/* compute the CRC on flags that have to be kept in sync
			 * among nodes
			 */
			flags = tt_common->flags & BATADV_TT_SYNC_MASK;
			crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));

2265
			crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2266 2267 2268 2269
		}
		rcu_read_unlock();
	}

2270
	return crc;
2271 2272
}

2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295
/**
 * batadv_tt_req_node_release - free tt_req node entry
 * @ref: kref pointer of the tt req_node entry
 */
static void batadv_tt_req_node_release(struct kref *ref)
{
	struct batadv_tt_req_node *tt_req_node;

	tt_req_node = container_of(ref, struct batadv_tt_req_node, refcount);

	kfree(tt_req_node);
}

/**
 * batadv_tt_req_node_put - decrement the tt_req_node refcounter and
 *  possibly release it
 * @tt_req_node: tt_req_node to be free'd
 */
static void batadv_tt_req_node_put(struct batadv_tt_req_node *tt_req_node)
{
	kref_put(&tt_req_node->refcount, batadv_tt_req_node_release);
}

2296
static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
2297
{
2298 2299
	struct batadv_tt_req_node *node;
	struct hlist_node *safe;
2300

2301
	spin_lock_bh(&bat_priv->tt.req_list_lock);
2302

2303 2304
	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
		hlist_del_init(&node->list);
2305
		batadv_tt_req_node_put(node);
2306 2307
	}

2308
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2309 2310
}

2311 2312
static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
				       struct batadv_orig_node *orig_node,
2313
				       const void *tt_buff,
2314
				       u16 tt_buff_len)
2315 2316
{
	/* Replace the old buffer only if I received something in the
2317 2318
	 * last OGM (the OGM could carry no changes)
	 */
2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
	spin_lock_bh(&orig_node->tt_buff_lock);
	if (tt_buff_len > 0) {
		kfree(orig_node->tt_buff);
		orig_node->tt_buff_len = 0;
		orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
		if (orig_node->tt_buff) {
			memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
			orig_node->tt_buff_len = tt_buff_len;
		}
	}
	spin_unlock_bh(&orig_node->tt_buff_lock);
}

2332
static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
2333
{
2334 2335
	struct batadv_tt_req_node *node;
	struct hlist_node *safe;
2336

2337
	spin_lock_bh(&bat_priv->tt.req_list_lock);
2338
	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2339 2340
		if (batadv_has_timed_out(node->issued_at,
					 BATADV_TT_REQUEST_TIMEOUT)) {
2341
			hlist_del_init(&node->list);
2342
			batadv_tt_req_node_put(node);
2343 2344
		}
	}
2345
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2346 2347
}

2348 2349 2350 2351 2352
/**
 * batadv_tt_req_node_new - search and possibly create a tt_req_node object
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: orig node this request is being issued for
 *
2353
 * Return: the pointer to the new tt_req_node struct if no request
2354
 * has already been issued for this orig_node, NULL otherwise.
2355
 */
2356
static struct batadv_tt_req_node *
2357
batadv_tt_req_node_new(struct batadv_priv *bat_priv,
2358
		       struct batadv_orig_node *orig_node)
2359
{
2360
	struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
2361

2362
	spin_lock_bh(&bat_priv->tt.req_list_lock);
2363
	hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
2364 2365
		if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
		    !batadv_has_timed_out(tt_req_node_tmp->issued_at,
2366
					  BATADV_TT_REQUEST_TIMEOUT))
2367 2368 2369 2370 2371 2372 2373
			goto unlock;
	}

	tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
	if (!tt_req_node)
		goto unlock;

2374
	kref_init(&tt_req_node->refcount);
2375
	ether_addr_copy(tt_req_node->addr, orig_node->orig);
2376 2377
	tt_req_node->issued_at = jiffies;

2378
	kref_get(&tt_req_node->refcount);
2379
	hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list);
2380
unlock:
2381
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2382 2383 2384
	return tt_req_node;
}

2385 2386 2387 2388 2389
/**
 * batadv_tt_local_valid - verify that given tt entry is a valid one
 * @entry_ptr: to be checked local tt entry
 * @data_ptr: not used but definition required to satisfy the callback prototype
 *
2390
 * Return: true if the entry is a valid, false otherwise.
2391
 */
2392
static bool batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)
2393
{
2394
	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2395

2396
	if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
2397 2398
		return false;
	return true;
2399 2400
}

2401 2402
static bool batadv_tt_global_valid(const void *entry_ptr,
				   const void *data_ptr)
2403
{
2404 2405 2406
	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
	const struct batadv_tt_global_entry *tt_global_entry;
	const struct batadv_orig_node *orig_node = data_ptr;
2407

2408 2409
	if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
	    tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
2410
		return false;
2411

2412 2413
	tt_global_entry = container_of(tt_common_entry,
				       struct batadv_tt_global_entry,
2414 2415
				       common);

2416
	return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);
2417 2418
}

2419
/**
2420 2421
 * batadv_tt_tvlv_generate - fill the tvlv buff with the tt entries from the
 *  specified tt hash
2422 2423 2424
 * @bat_priv: the bat priv with all the soft interface information
 * @hash: hash table containing the tt entries
 * @tt_len: expected tvlv tt data buffer length in number of bytes
2425
 * @tvlv_buff: pointer to the buffer to fill with the TT data
2426 2427 2428
 * @valid_cb: function to filter tt change entries
 * @cb_data: data passed to the filter function as argument
 */
2429 2430
static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
				    struct batadv_hashtable *hash,
2431
				    void *tvlv_buff, u16 tt_len,
2432 2433
				    bool (*valid_cb)(const void *,
						     const void *),
2434
				    void *cb_data)
2435
{
2436
	struct batadv_tt_common_entry *tt_common_entry;
2437
	struct batadv_tvlv_tt_change *tt_change;
2438
	struct hlist_head *head;
2439 2440
	u16 tt_tot, tt_num_entries = 0;
	u32 i;
2441

2442
	tt_tot = batadv_tt_entries(tt_len);
2443
	tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;
2444 2445 2446 2447 2448

	rcu_read_lock();
	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];

2449
		hlist_for_each_entry_rcu(tt_common_entry,
2450
					 head, hash_entry) {
2451
			if (tt_tot == tt_num_entries)
2452 2453
				break;

2454
			if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
2455 2456
				continue;

2457
			ether_addr_copy(tt_change->addr, tt_common_entry->addr);
2458
			tt_change->flags = tt_common_entry->flags;
2459
			tt_change->vid = htons(tt_common_entry->vid);
2460 2461
			memset(tt_change->reserved, 0,
			       sizeof(tt_change->reserved));
2462

2463
			tt_num_entries++;
2464 2465 2466 2467
			tt_change++;
		}
	}
	rcu_read_unlock();
2468
}
2469

2470 2471 2472 2473 2474 2475
/**
 * batadv_tt_global_check_crc - check if all the CRCs are correct
 * @orig_node: originator for which the CRCs have to be checked
 * @tt_vlan: pointer to the first tvlv VLAN entry
 * @num_vlan: number of tvlv VLAN entries
 *
2476
 * Return: true if all the received CRCs match the locally stored ones, false
2477 2478 2479 2480
 * otherwise
 */
static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,
				       struct batadv_tvlv_tt_vlan_data *tt_vlan,
2481
				       u16 num_vlan)
2482 2483 2484
{
	struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;
	struct batadv_orig_node_vlan *vlan;
2485
	int i, orig_num_vlan;
2486
	u32 crc;
2487 2488 2489 2490 2491 2492 2493 2494 2495

	/* check if each received CRC matches the locally stored one */
	for (i = 0; i < num_vlan; i++) {
		tt_vlan_tmp = tt_vlan + i;

		/* if orig_node is a backbone node for this VLAN, don't check
		 * the CRC as we ignore all the global entries over it
		 */
		if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,
2496 2497
						   orig_node->orig,
						   ntohs(tt_vlan_tmp->vid)))
2498 2499 2500 2501 2502 2503 2504
			continue;

		vlan = batadv_orig_node_vlan_get(orig_node,
						 ntohs(tt_vlan_tmp->vid));
		if (!vlan)
			return false;

2505
		crc = vlan->tt.crc;
2506
		batadv_orig_node_vlan_put(vlan);
2507 2508

		if (crc != ntohl(tt_vlan_tmp->crc))
2509 2510 2511
			return false;
	}

2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523
	/* check if any excess VLANs exist locally for the originator
	 * which are not mentioned in the TVLV from the originator.
	 */
	rcu_read_lock();
	orig_num_vlan = 0;
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list)
		orig_num_vlan++;
	rcu_read_unlock();

	if (orig_num_vlan > num_vlan)
		return false;

2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551
	return true;
}

/**
 * batadv_tt_local_update_crc - update all the local CRCs
 * @bat_priv: the bat priv with all the soft interface information
 */
static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)
{
	struct batadv_softif_vlan *vlan;

	/* recompute the global CRC for each VLAN */
	rcu_read_lock();
	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
		vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);
	}
	rcu_read_unlock();
}

/**
 * batadv_tt_global_update_crc - update all the global CRCs for this orig_node
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: the orig_node for which the CRCs have to be updated
 */
static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
					struct batadv_orig_node *orig_node)
{
	struct batadv_orig_node_vlan *vlan;
2552
	u32 crc;
2553 2554 2555

	/* recompute the global CRC for each VLAN */
	rcu_read_lock();
2556
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
2557 2558 2559
		/* if orig_node is a backbone node for this VLAN, don't compute
		 * the CRC as we ignore all the global entries over it
		 */
2560 2561
		if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
						   vlan->vid))
2562 2563 2564 2565 2566 2567
			continue;

		crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);
		vlan->tt.crc = crc;
	}
	rcu_read_unlock();
2568 2569
}

2570 2571 2572 2573 2574
/**
 * batadv_send_tt_request - send a TT Request message to a given node
 * @bat_priv: the bat priv with all the soft interface information
 * @dst_orig_node: the destination of the message
 * @ttvn: the version number that the source of the message is looking for
2575 2576
 * @tt_vlan: pointer to the first tvlv VLAN object to request
 * @num_vlan: number of tvlv VLAN entries
2577 2578
 * @full_table: ask for the entire translation table if true, while only for the
 *  last TT diff otherwise
2579 2580
 *
 * Return: true if the TT Request was sent, false otherwise
2581
 */
2582 2583 2584 2585 2586
static bool batadv_send_tt_request(struct batadv_priv *bat_priv,
				   struct batadv_orig_node *dst_orig_node,
				   u8 ttvn,
				   struct batadv_tvlv_tt_vlan_data *tt_vlan,
				   u16 num_vlan, bool full_table)
2587
{
2588
	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2589
	struct batadv_tt_req_node *tt_req_node = NULL;
2590 2591
	struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
	struct batadv_hard_iface *primary_if;
2592
	bool ret = false;
2593
	int i, size;
2594

2595
	primary_if = batadv_primary_if_get_selected(bat_priv);
2596 2597 2598 2599
	if (!primary_if)
		goto out;

	/* The new tt_req will be issued only if I'm not waiting for a
2600 2601
	 * reply from the same orig_node yet
	 */
2602
	tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);
2603 2604 2605
	if (!tt_req_node)
		goto out;

2606 2607
	size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
	tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
2608
	if (!tvlv_tt_data)
2609 2610
		goto out;

2611 2612
	tvlv_tt_data->flags = BATADV_TT_REQUEST;
	tvlv_tt_data->ttvn = ttvn;
2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625
	tvlv_tt_data->num_vlan = htons(num_vlan);

	/* send all the CRCs within the request. This is needed by intermediate
	 * nodes to ensure they have the correct table before replying
	 */
	tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);
	for (i = 0; i < num_vlan; i++) {
		tt_vlan_req->vid = tt_vlan->vid;
		tt_vlan_req->crc = tt_vlan->crc;

		tt_vlan_req++;
		tt_vlan++;
	}
2626 2627

	if (full_table)
2628
		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2629

2630
	batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",
2631
		   dst_orig_node->orig, full_table ? 'F' : '.');
2632

2633
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
2634 2635
	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
				 dst_orig_node->orig, BATADV_TVLV_TT, 1,
2636
				 tvlv_tt_data, size);
2637
	ret = true;
2638 2639 2640

out:
	if (primary_if)
2641
		batadv_hardif_put(primary_if);
2642

2643
	if (ret && tt_req_node) {
2644
		spin_lock_bh(&bat_priv->tt.req_list_lock);
2645 2646 2647 2648
		if (!hlist_unhashed(&tt_req_node->list)) {
			hlist_del_init(&tt_req_node->list);
			batadv_tt_req_node_put(tt_req_node);
		}
2649
		spin_unlock_bh(&bat_priv->tt.req_list_lock);
2650
	}
2651 2652 2653 2654

	if (tt_req_node)
		batadv_tt_req_node_put(tt_req_node);

2655
	kfree(tvlv_tt_data);
2656 2657 2658
	return ret;
}

2659 2660 2661 2662 2663 2664 2665 2666
/**
 * batadv_send_other_tt_response - send reply to tt request concerning another
 *  node's translation table
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_data: tt data containing the tt request information
 * @req_src: mac address of tt request sender
 * @req_dst: mac address of tt request recipient
 *
2667
 * Return: true if tt request reply was sent, false otherwise.
2668 2669 2670
 */
static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
					  struct batadv_tvlv_tt_data *tt_data,
2671
					  u8 *req_src, u8 *req_dst)
2672
{
2673
	struct batadv_orig_node *req_dst_orig_node;
2674
	struct batadv_orig_node *res_dst_orig_node = NULL;
2675
	struct batadv_tvlv_tt_change *tt_change;
2676
	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2677
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
2678
	bool ret = false, full_table;
2679 2680 2681
	u8 orig_ttvn, req_ttvn;
	u16 tvlv_len;
	s32 tt_len;
2682

2683
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2684
		   "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
2685
		   req_src, tt_data->ttvn, req_dst,
2686
		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2687 2688

	/* Let's get the orig node of the REAL destination */
2689
	req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
2690 2691 2692
	if (!req_dst_orig_node)
		goto out;

2693
	res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
2694 2695 2696
	if (!res_dst_orig_node)
		goto out;

2697
	orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);
2698
	req_ttvn = tt_data->ttvn;
2699

2700
	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
2701
	/* this node doesn't have the requested data */
2702
	if (orig_ttvn != req_ttvn ||
2703 2704
	    !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
					ntohs(tt_data->num_vlan)))
2705 2706
		goto out;

2707
	/* If the full table has been explicitly requested */
2708
	if (tt_data->flags & BATADV_TT_FULL_TABLE ||
2709 2710 2711 2712 2713
	    !req_dst_orig_node->tt_buff)
		full_table = true;
	else
		full_table = false;

2714 2715
	/* TT fragmentation hasn't been implemented yet, so send as many
	 * TT entries fit a single packet as possible only
2716
	 */
2717 2718 2719 2720
	if (!full_table) {
		spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
		tt_len = req_dst_orig_node->tt_buff_len;

2721 2722 2723 2724 2725
		tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
							      &tvlv_tt_data,
							      &tt_change,
							      &tt_len);
		if (!tt_len)
2726 2727 2728
			goto unlock;

		/* Copy the last orig_node's OGM buffer */
2729
		memcpy(tt_change, req_dst_orig_node->tt_buff,
2730 2731 2732
		       req_dst_orig_node->tt_buff_len);
		spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
	} else {
2733 2734 2735 2736 2737 2738 2739 2740 2741
		/* allocate the tvlv, put the tt_data and all the tt_vlan_data
		 * in the initial part
		 */
		tt_len = -1;
		tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
							      &tvlv_tt_data,
							      &tt_change,
							      &tt_len);
		if (!tt_len)
2742
			goto out;
2743 2744 2745 2746 2747 2748

		/* fill the rest of the tvlv with the real TT entries */
		batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,
					tt_change, tt_len,
					batadv_tt_global_valid,
					req_dst_orig_node);
2749 2750
	}

2751 2752 2753 2754 2755 2756 2757 2758 2759
	/* Don't send the response, if larger than fragmented packet. */
	tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;
	if (tt_len > atomic_read(&bat_priv->packet_size_max)) {
		net_ratelimited_function(batadv_info, bat_priv->soft_iface,
					 "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",
					 res_dst_orig_node->orig);
		goto out;
	}

2760 2761
	tvlv_tt_data->flags = BATADV_TT_RESPONSE;
	tvlv_tt_data->ttvn = req_ttvn;
2762 2763

	if (full_table)
2764
		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2765

2766
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2767 2768 2769
		   "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",
		   res_dst_orig_node->orig, req_dst_orig_node->orig,
		   full_table ? 'F' : '.', req_ttvn);
2770

2771
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2772

2773
	batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
2774 2775
				 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
				 tvlv_len);
2776

2777
	ret = true;
2778 2779 2780 2781 2782 2783 2784
	goto out;

unlock:
	spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);

out:
	if (res_dst_orig_node)
2785
		batadv_orig_node_put(res_dst_orig_node);
2786
	if (req_dst_orig_node)
2787
		batadv_orig_node_put(req_dst_orig_node);
2788
	kfree(tvlv_tt_data);
2789 2790
	return ret;
}
2791

2792 2793 2794 2795 2796 2797 2798
/**
 * batadv_send_my_tt_response - send reply to tt request concerning this node's
 *  translation table
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_data: tt data containing the tt request information
 * @req_src: mac address of tt request sender
 *
2799
 * Return: true if tt request reply was sent, false otherwise.
2800 2801 2802
 */
static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
				       struct batadv_tvlv_tt_data *tt_data,
2803
				       u8 *req_src)
2804
{
2805
	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2806
	struct batadv_hard_iface *primary_if = NULL;
2807 2808
	struct batadv_tvlv_tt_change *tt_change;
	struct batadv_orig_node *orig_node;
2809 2810
	u8 my_ttvn, req_ttvn;
	u16 tvlv_len;
2811
	bool full_table;
2812
	s32 tt_len;
2813

2814
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2815
		   "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
2816
		   req_src, tt_data->ttvn,
2817
		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2818

2819
	spin_lock_bh(&bat_priv->tt.commit_lock);
2820

2821
	my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2822
	req_ttvn = tt_data->ttvn;
2823

2824
	orig_node = batadv_orig_hash_find(bat_priv, req_src);
2825 2826 2827
	if (!orig_node)
		goto out;

2828
	primary_if = batadv_primary_if_get_selected(bat_priv);
2829 2830 2831 2832
	if (!primary_if)
		goto out;

	/* If the full table has been explicitly requested or the gap
2833 2834
	 * is too big send the whole local translation table
	 */
2835
	if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
2836
	    !bat_priv->tt.last_changeset)
2837 2838 2839 2840
		full_table = true;
	else
		full_table = false;

2841 2842
	/* TT fragmentation hasn't been implemented yet, so send as many
	 * TT entries fit a single packet as possible only
2843
	 */
2844
	if (!full_table) {
2845
		spin_lock_bh(&bat_priv->tt.last_changeset_lock);
2846

2847 2848 2849 2850 2851 2852
		tt_len = bat_priv->tt.last_changeset_len;
		tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
							     &tvlv_tt_data,
							     &tt_change,
							     &tt_len);
		if (!tt_len)
2853 2854
			goto unlock;

2855
		/* Copy the last orig_node's OGM buffer */
2856
		memcpy(tt_change, bat_priv->tt.last_changeset,
2857 2858
		       bat_priv->tt.last_changeset_len);
		spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2859
	} else {
2860
		req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2861

2862 2863 2864 2865 2866 2867 2868 2869 2870
		/* allocate the tvlv, put the tt_data and all the tt_vlan_data
		 * in the initial part
		 */
		tt_len = -1;
		tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
							     &tvlv_tt_data,
							     &tt_change,
							     &tt_len);
		if (!tt_len)
2871
			goto out;
2872 2873 2874 2875 2876

		/* fill the rest of the tvlv with the real TT entries */
		batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,
					tt_change, tt_len,
					batadv_tt_local_valid, NULL);
2877 2878
	}

2879 2880
	tvlv_tt_data->flags = BATADV_TT_RESPONSE;
	tvlv_tt_data->ttvn = req_ttvn;
2881 2882

	if (full_table)
2883
		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2884

2885
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2886 2887
		   "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
		   orig_node->orig, full_table ? 'F' : '.', req_ttvn);
2888

2889
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2890

2891
	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2892 2893
				 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
				 tvlv_len);
2894

2895 2896 2897
	goto out;

unlock:
2898
	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2899
out:
2900
	spin_unlock_bh(&bat_priv->tt.commit_lock);
2901
	if (orig_node)
2902
		batadv_orig_node_put(orig_node);
2903
	if (primary_if)
2904
		batadv_hardif_put(primary_if);
2905 2906
	kfree(tvlv_tt_data);
	/* The packet was for this host, so it doesn't need to be re-routed */
2907 2908 2909
	return true;
}

2910 2911 2912 2913 2914 2915 2916
/**
 * batadv_send_tt_response - send reply to tt request
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_data: tt data containing the tt request information
 * @req_src: mac address of tt request sender
 * @req_dst: mac address of tt request recipient
 *
2917
 * Return: true if tt request reply was sent, false otherwise.
2918 2919 2920
 */
static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
				    struct batadv_tvlv_tt_data *tt_data,
2921
				    u8 *req_src, u8 *req_dst)
2922
{
2923
	if (batadv_is_my_mac(bat_priv, req_dst))
2924
		return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
2925 2926
	return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
					     req_dst);
2927 2928
}

2929 2930
static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
				      struct batadv_orig_node *orig_node,
2931
				      struct batadv_tvlv_tt_change *tt_change,
2932
				      u16 tt_num_changes, u8 ttvn)
2933 2934
{
	int i;
2935
	int roams;
2936 2937

	for (i = 0; i < tt_num_changes; i++) {
2938 2939
		if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
			roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
2940 2941
			batadv_tt_global_del(bat_priv, orig_node,
					     (tt_change + i)->addr,
2942
					     ntohs((tt_change + i)->vid),
2943 2944
					     "tt removed by changes",
					     roams);
2945 2946
		} else {
			if (!batadv_tt_global_add(bat_priv, orig_node,
2947
						  (tt_change + i)->addr,
2948
						  ntohs((tt_change + i)->vid),
2949
						  (tt_change + i)->flags, ttvn))
2950 2951 2952 2953 2954 2955 2956
				/* In case of problem while storing a
				 * global_entry, we stop the updating
				 * procedure without committing the
				 * ttvn change. This will avoid to send
				 * corrupted data on tt_request
				 */
				return;
2957
		}
2958
	}
2959
	set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
2960 2961
}

2962
static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
2963
				  struct batadv_tvlv_tt_change *tt_change,
2964 2965
				  u8 ttvn, u8 *resp_src,
				  u16 num_entries)
2966
{
2967
	struct batadv_orig_node *orig_node;
2968

2969
	orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2970 2971 2972 2973
	if (!orig_node)
		goto out;

	/* Purge the old table first.. */
2974 2975
	batadv_tt_global_del_orig(bat_priv, orig_node, -1,
				  "Received full table");
2976

2977 2978
	_batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
				  ttvn);
2979 2980 2981 2982 2983 2984 2985

	spin_lock_bh(&orig_node->tt_buff_lock);
	kfree(orig_node->tt_buff);
	orig_node->tt_buff_len = 0;
	orig_node->tt_buff = NULL;
	spin_unlock_bh(&orig_node->tt_buff_lock);

2986
	atomic_set(&orig_node->last_ttvn, ttvn);
2987 2988 2989

out:
	if (orig_node)
2990
		batadv_orig_node_put(orig_node);
2991 2992
}

2993 2994
static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
				     struct batadv_orig_node *orig_node,
2995
				     u16 tt_num_changes, u8 ttvn,
2996
				     struct batadv_tvlv_tt_change *tt_change)
2997
{
2998 2999
	_batadv_tt_update_changes(bat_priv, orig_node, tt_change,
				  tt_num_changes, ttvn);
3000

3001 3002
	batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
				   batadv_tt_len(tt_num_changes));
3003 3004 3005
	atomic_set(&orig_node->last_ttvn, ttvn);
}

3006 3007 3008
/**
 * batadv_is_my_client - check if a client is served by the local node
 * @bat_priv: the bat priv with all the soft interface information
3009
 * @addr: the mac address of the client to check
3010 3011
 * @vid: VLAN identifier
 *
3012
 * Return: true if the client is served by this node, false otherwise.
3013
 */
3014
bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,
3015
			 unsigned short vid)
3016
{
3017
	struct batadv_tt_local_entry *tt_local_entry;
3018
	bool ret = false;
3019

3020
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3021 3022
	if (!tt_local_entry)
		goto out;
3023
	/* Check if the client has been logically deleted (but is kept for
3024 3025
	 * consistency purpose)
	 */
3026 3027
	if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
	    (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
3028
		goto out;
3029 3030
	ret = true;
out:
3031
	if (tt_local_entry)
3032
		batadv_tt_local_entry_put(tt_local_entry);
3033
	return ret;
3034 3035
}

3036 3037 3038 3039 3040 3041 3042 3043 3044
/**
 * batadv_handle_tt_response - process incoming tt reply
 * @bat_priv: the bat priv with all the soft interface information
 * @tt_data: tt data containing the tt request information
 * @resp_src: mac address of tt reply sender
 * @num_entries: number of tt change entries appended to the tt data
 */
static void batadv_handle_tt_response(struct batadv_priv *bat_priv,
				      struct batadv_tvlv_tt_data *tt_data,
3045
				      u8 *resp_src, u16 num_entries)
3046
{
3047 3048
	struct batadv_tt_req_node *node;
	struct hlist_node *safe;
3049
	struct batadv_orig_node *orig_node = NULL;
3050
	struct batadv_tvlv_tt_change *tt_change;
3051 3052
	u8 *tvlv_ptr = (u8 *)tt_data;
	u16 change_offset;
3053

3054
	batadv_dbg(BATADV_DBG_TT, bat_priv,
3055
		   "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
3056
		   resp_src, tt_data->ttvn, num_entries,
3057
		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3058

3059
	orig_node = batadv_orig_hash_find(bat_priv, resp_src);
3060 3061 3062
	if (!orig_node)
		goto out;

3063 3064
	spin_lock_bh(&orig_node->tt_lock);

3065 3066 3067 3068 3069 3070
	change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);
	change_offset *= ntohs(tt_data->num_vlan);
	change_offset += sizeof(*tt_data);
	tvlv_ptr += change_offset;

	tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;
3071
	if (tt_data->flags & BATADV_TT_FULL_TABLE) {
3072 3073
		batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
				      resp_src, num_entries);
3074
	} else {
3075 3076
		batadv_tt_update_changes(bat_priv, orig_node, num_entries,
					 tt_data->ttvn, tt_change);
3077
	}
3078

3079
	/* Recalculate the CRC for this orig_node and store it */
3080
	batadv_tt_global_update_crc(bat_priv, orig_node);
3081 3082 3083

	spin_unlock_bh(&orig_node->tt_lock);

3084
	/* Delete the tt_req_node from pending tt_requests list */
3085
	spin_lock_bh(&bat_priv->tt.req_list_lock);
3086
	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
3087
		if (!batadv_compare_eth(node->addr, resp_src))
3088
			continue;
3089
		hlist_del_init(&node->list);
3090
		batadv_tt_req_node_put(node);
3091
	}
3092

3093
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
3094 3095
out:
	if (orig_node)
3096
		batadv_orig_node_put(orig_node);
3097 3098
}

3099
static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
3100
{
3101
	struct batadv_tt_roam_node *node, *safe;
3102

3103
	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3104

3105
	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3106 3107 3108 3109
		list_del(&node->list);
		kfree(node);
	}

3110
	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3111 3112
}

3113
static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
3114
{
3115
	struct batadv_tt_roam_node *node, *safe;
3116

3117 3118
	spin_lock_bh(&bat_priv->tt.roam_list_lock);
	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3119 3120
		if (!batadv_has_timed_out(node->first_time,
					  BATADV_ROAMING_MAX_TIME))
3121 3122 3123 3124 3125
			continue;

		list_del(&node->list);
		kfree(node);
	}
3126
	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3127 3128
}

3129
/**
3130 3131 3132
 * batadv_tt_check_roam_count - check if a client has roamed too frequently
 * @bat_priv: the bat priv with all the soft interface information
 * @client: mac address of the roaming client
3133 3134
 *
 * This function checks whether the client already reached the
3135 3136 3137
 * maximum number of possible roaming phases. In this case the ROAMING_ADV
 * will not be sent.
 *
3138
 * Return: true if the ROAMING_ADV can be sent, false otherwise
3139
 */
3140
static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)
3141
{
3142
	struct batadv_tt_roam_node *tt_roam_node;
3143 3144
	bool ret = false;

3145
	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3146
	/* The new tt_req will be issued only if I'm not waiting for a
3147 3148
	 * reply from the same orig_node yet
	 */
3149
	list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
3150
		if (!batadv_compare_eth(tt_roam_node->addr, client))
3151 3152
			continue;

3153
		if (batadv_has_timed_out(tt_roam_node->first_time,
3154
					 BATADV_ROAMING_MAX_TIME))
3155 3156
			continue;

3157
		if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169
			/* Sorry, you roamed too many times! */
			goto unlock;
		ret = true;
		break;
	}

	if (!ret) {
		tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
		if (!tt_roam_node)
			goto unlock;

		tt_roam_node->first_time = jiffies;
3170 3171
		atomic_set(&tt_roam_node->counter,
			   BATADV_ROAMING_MAX_COUNT - 1);
3172
		ether_addr_copy(tt_roam_node->addr, client);
3173

3174
		list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3175 3176 3177 3178
		ret = true;
	}

unlock:
3179
	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3180 3181 3182
	return ret;
}

3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194
/**
 * batadv_send_roam_adv - send a roaming advertisement message
 * @bat_priv: the bat priv with all the soft interface information
 * @client: mac address of the roaming client
 * @vid: VLAN identifier
 * @orig_node: message destination
 *
 * Send a ROAMING_ADV message to the node which was previously serving this
 * client. This is done to inform the node that from now on all traffic destined
 * for this particular roamed client has to be forwarded to the sender of the
 * roaming message.
 */
3195
static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
3196
				 unsigned short vid,
3197
				 struct batadv_orig_node *orig_node)
3198
{
3199
	struct batadv_hard_iface *primary_if;
3200 3201 3202 3203 3204
	struct batadv_tvlv_roam_adv tvlv_roam;

	primary_if = batadv_primary_if_get_selected(bat_priv);
	if (!primary_if)
		goto out;
3205 3206

	/* before going on we have to check whether the client has
3207 3208
	 * already roamed to us too many times
	 */
3209
	if (!batadv_tt_check_roam_count(bat_priv, client))
3210 3211
		goto out;

3212
	batadv_dbg(BATADV_DBG_TT, bat_priv,
3213 3214
		   "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
		   orig_node->orig, client, BATADV_PRINT_VID(vid));
3215

3216
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3217

3218
	memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3219
	tvlv_roam.vid = htons(vid);
3220 3221 3222 3223

	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
				 orig_node->orig, BATADV_TVLV_ROAM, 1,
				 &tvlv_roam, sizeof(tvlv_roam));
3224 3225

out:
3226
	if (primary_if)
3227
		batadv_hardif_put(primary_if);
3228 3229
}

3230
static void batadv_tt_purge(struct work_struct *work)
3231
{
3232
	struct delayed_work *delayed_work;
3233
	struct batadv_priv_tt *priv_tt;
3234 3235
	struct batadv_priv *bat_priv;

G
Geliang Tang 已提交
3236
	delayed_work = to_delayed_work(work);
3237 3238
	priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
	bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3239

3240
	batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3241
	batadv_tt_global_purge(bat_priv);
3242 3243
	batadv_tt_req_purge(bat_priv);
	batadv_tt_roam_purge(bat_priv);
3244

3245 3246
	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
			   msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3247
}
3248

3249
void batadv_tt_free(struct batadv_priv *bat_priv)
3250
{
3251 3252 3253
	batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);

3254
	cancel_delayed_work_sync(&bat_priv->tt.work);
3255

3256 3257 3258 3259 3260
	batadv_tt_local_table_free(bat_priv);
	batadv_tt_global_table_free(bat_priv);
	batadv_tt_req_list_free(bat_priv);
	batadv_tt_changes_list_free(bat_priv);
	batadv_tt_roam_list_free(bat_priv);
3261

3262
	kfree(bat_priv->tt.last_changeset);
3263
}
3264

3265 3266 3267 3268 3269 3270 3271
/**
 * batadv_tt_local_set_flags - set or unset the specified flags on the local
 *  table and possibly count them in the TT size
 * @bat_priv: the bat priv with all the soft interface information
 * @flags: the flag to switch
 * @enable: whether to set or unset the flag
 * @count: whether to increase the TT size by the number of changed entries
3272
 */
3273 3274
static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,
				      bool enable, bool count)
3275
{
3276 3277
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
	struct batadv_tt_common_entry *tt_common_entry;
3278
	u16 changed_num = 0;
3279
	struct hlist_head *head;
3280
	u32 i;
3281 3282

	if (!hash)
3283
		return;
3284 3285 3286 3287 3288

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];

		rcu_read_lock();
3289
		hlist_for_each_entry_rcu(tt_common_entry,
3290
					 head, hash_entry) {
3291 3292 3293 3294 3295 3296 3297 3298 3299 3300
			if (enable) {
				if ((tt_common_entry->flags & flags) == flags)
					continue;
				tt_common_entry->flags |= flags;
			} else {
				if (!(tt_common_entry->flags & flags))
					continue;
				tt_common_entry->flags &= ~flags;
			}
			changed_num++;
3301 3302 3303 3304 3305 3306

			if (!count)
				continue;

			batadv_tt_local_size_inc(bat_priv,
						 tt_common_entry->vid);
3307 3308 3309 3310 3311
		}
		rcu_read_unlock();
	}
}

3312
/* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
3313
static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3314
{
3315
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3316 3317
	struct batadv_tt_common_entry *tt_common;
	struct batadv_tt_local_entry *tt_local;
3318
	struct hlist_node *node_tmp;
3319 3320
	struct hlist_head *head;
	spinlock_t *list_lock; /* protects write access to the hash lists */
3321
	u32 i;
3322 3323 3324 3325 3326 3327 3328 3329 3330

	if (!hash)
		return;

	for (i = 0; i < hash->size; i++) {
		head = &hash->table[i];
		list_lock = &hash->list_locks[i];

		spin_lock_bh(list_lock);
3331
		hlist_for_each_entry_safe(tt_common, node_tmp, head,
3332 3333
					  hash_entry) {
			if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3334 3335
				continue;

3336
			batadv_dbg(BATADV_DBG_TT, bat_priv,
3337 3338 3339
				   "Deleting local tt entry (%pM, vid: %d): pending\n",
				   tt_common->addr,
				   BATADV_PRINT_VID(tt_common->vid));
3340

3341
			batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3342
			hlist_del_rcu(&tt_common->hash_entry);
3343 3344 3345
			tt_local = container_of(tt_common,
						struct batadv_tt_local_entry,
						common);
3346

3347
			batadv_tt_local_entry_put(tt_local);
3348 3349 3350 3351 3352
		}
		spin_unlock_bh(list_lock);
	}
}

3353
/**
3354 3355
 * batadv_tt_local_commit_changes_nolock - commit all pending local tt changes
 *  which have been queued in the time since the last commit
3356
 * @bat_priv: the bat priv with all the soft interface information
3357 3358
 *
 * Caller must hold tt->commit_lock.
3359
 */
3360
static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3361
{
3362 3363
	lockdep_assert_held(&bat_priv->tt.commit_lock);

3364 3365 3366
	/* Update multicast addresses in local translation table */
	batadv_mcast_mla_update(bat_priv);

3367 3368 3369
	if (atomic_read(&bat_priv->tt.local_changes) < 1) {
		if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))
			batadv_tt_tvlv_container_update(bat_priv);
3370
		return;
3371
	}
3372

3373
	batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3374

3375
	batadv_tt_local_purge_pending_clients(bat_priv);
3376
	batadv_tt_local_update_crc(bat_priv);
3377 3378

	/* Increment the TTVN only once per OGM interval */
3379
	atomic_inc(&bat_priv->tt.vn);
3380
	batadv_dbg(BATADV_DBG_TT, bat_priv,
3381
		   "Local changes committed, updating to ttvn %u\n",
3382
		   (u8)atomic_read(&bat_priv->tt.vn));
3383 3384

	/* reset the sending counter */
3385
	atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3386
	batadv_tt_tvlv_container_update(bat_priv);
3387
}
3388

3389 3390 3391 3392 3393 3394 3395 3396 3397
/**
 * batadv_tt_local_commit_changes - commit all pending local tt changes which
 *  have been queued in the time since the last commit
 * @bat_priv: the bat priv with all the soft interface information
 */
void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)
{
	spin_lock_bh(&bat_priv->tt.commit_lock);
	batadv_tt_local_commit_changes_nolock(bat_priv);
3398
	spin_unlock_bh(&bat_priv->tt.commit_lock);
3399
}
3400

3401 3402
bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,
			   unsigned short vid)
3403
{
3404 3405
	struct batadv_tt_local_entry *tt_local_entry = NULL;
	struct batadv_tt_global_entry *tt_global_entry = NULL;
3406
	struct batadv_softif_vlan *vlan;
3407
	bool ret = false;
3408

3409
	vlan = batadv_softif_vlan_get(bat_priv, vid);
3410 3411 3412 3413
	if (!vlan)
		return false;

	if (!atomic_read(&vlan->ap_isolation))
3414
		goto out;
3415

3416
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3417 3418 3419
	if (!tt_local_entry)
		goto out;

3420
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3421 3422 3423
	if (!tt_global_entry)
		goto out;

3424
	if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3425 3426
		goto out;

3427
	ret = true;
3428 3429

out:
3430
	batadv_softif_vlan_put(vlan);
3431
	if (tt_global_entry)
3432
		batadv_tt_global_entry_put(tt_global_entry);
3433
	if (tt_local_entry)
3434
		batadv_tt_local_entry_put(tt_local_entry);
3435 3436
	return ret;
}
3437

3438 3439 3440 3441
/**
 * batadv_tt_update_orig - update global translation table with new tt
 *  information received via ogms
 * @bat_priv: the bat priv with all the soft interface information
3442 3443
 * @orig_node: the orig_node of the ogm
 * @tt_buff: pointer to the first tvlv VLAN entry
3444 3445
 * @tt_num_vlan: number of tvlv VLAN entries
 * @tt_change: pointer to the first entry in the TT buffer
3446 3447 3448 3449 3450
 * @tt_num_changes: number of tt changes inside the tt buffer
 * @ttvn: translation table version number of this changeset
 */
static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
				  struct batadv_orig_node *orig_node,
3451
				  const void *tt_buff, u16 tt_num_vlan,
3452
				  struct batadv_tvlv_tt_change *tt_change,
3453
				  u16 tt_num_changes, u8 ttvn)
3454
{
3455
	u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
3456
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
3457
	bool full_table = true;
3458
	bool has_tt_init;
3459

3460
	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
3461 3462
	has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,
			       &orig_node->capa_initialized);
3463

3464
	/* orig table not initialised AND first diff is in the OGM OR the ttvn
3465 3466
	 * increased by one -> we can apply the attached changes
	 */
3467
	if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
3468
		/* the OGM could not contain the changes due to their size or
3469 3470
		 * because they have already been sent BATADV_TT_OGM_APPEND_MAX
		 * times.
3471 3472
		 * In this case send a tt request
		 */
3473 3474 3475 3476 3477
		if (!tt_num_changes) {
			full_table = false;
			goto request_table;
		}

3478 3479
		spin_lock_bh(&orig_node->tt_lock);

3480
		batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
3481
					 ttvn, tt_change);
3482 3483 3484

		/* Even if we received the precomputed crc with the OGM, we
		 * prefer to recompute it to spot any possible inconsistency
3485 3486
		 * in the global table
		 */
3487
		batadv_tt_global_update_crc(bat_priv, orig_node);
3488

3489 3490
		spin_unlock_bh(&orig_node->tt_lock);

3491 3492 3493 3494 3495 3496 3497
		/* The ttvn alone is not enough to guarantee consistency
		 * because a single value could represent different states
		 * (due to the wrap around). Thus a node has to check whether
		 * the resulting table (after applying the changes) is still
		 * consistent or not. E.g. a node could disconnect while its
		 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
		 * checking the CRC value is mandatory to detect the
3498 3499
		 * inconsistency
		 */
3500 3501
		if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
						tt_num_vlan))
3502 3503 3504
			goto request_table;
	} else {
		/* if we missed more than one change or our tables are not
3505 3506
		 * in sync anymore -> request fresh tt data
		 */
3507
		if (!has_tt_init || ttvn != orig_ttvn ||
3508 3509
		    !batadv_tt_global_check_crc(orig_node, tt_vlan,
						tt_num_vlan)) {
3510
request_table:
3511
			batadv_dbg(BATADV_DBG_TT, bat_priv,
3512 3513 3514
				   "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",
				   orig_node->orig, ttvn, orig_ttvn,
				   tt_num_changes);
3515
			batadv_send_tt_request(bat_priv, orig_node, ttvn,
3516 3517
					       tt_vlan, tt_num_vlan,
					       full_table);
3518 3519 3520 3521
			return;
		}
	}
}
3522

3523 3524 3525 3526 3527 3528
/**
 * batadv_tt_global_client_is_roaming - check if a client is marked as roaming
 * @bat_priv: the bat priv with all the soft interface information
 * @addr: the mac address of the client to check
 * @vid: VLAN identifier
 *
3529
 * Return: true if we know that the client has moved from its old originator
3530 3531
 * to another one. This entry is still kept for consistency purposes and will be
 * deleted later by a DEL or because of timeout
3532
 */
3533
bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
3534
					u8 *addr, unsigned short vid)
3535
{
3536
	struct batadv_tt_global_entry *tt_global_entry;
3537 3538
	bool ret = false;

3539
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
3540 3541 3542
	if (!tt_global_entry)
		goto out;

3543
	ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3544
	batadv_tt_global_entry_put(tt_global_entry);
3545 3546 3547
out:
	return ret;
}
3548

3549 3550 3551
/**
 * batadv_tt_local_client_is_roaming - tells whether the client is roaming
 * @bat_priv: the bat priv with all the soft interface information
3552 3553
 * @addr: the mac address of the local client to query
 * @vid: VLAN identifier
3554
 *
3555
 * Return: true if the local client is known to be roaming (it is not served by
3556 3557 3558 3559
 * this node anymore) or not. If yes, the client is still present in the table
 * to keep the latter consistent with the node TTVN
 */
bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
3560
				       u8 *addr, unsigned short vid)
3561 3562 3563 3564
{
	struct batadv_tt_local_entry *tt_local_entry;
	bool ret = false;

3565
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3566 3567 3568 3569
	if (!tt_local_entry)
		goto out;

	ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3570
	batadv_tt_local_entry_put(tt_local_entry);
3571 3572 3573 3574
out:
	return ret;
}

3575 3576
bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
					  struct batadv_orig_node *orig_node,
3577
					  const unsigned char *addr,
3578
					  unsigned short vid)
3579 3580 3581
{
	bool ret = false;

3582
	if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
3583 3584 3585 3586 3587
				  BATADV_TT_CLIENT_TEMP,
				  atomic_read(&orig_node->last_ttvn)))
		goto out;

	batadv_dbg(BATADV_DBG_TT, bat_priv,
3588 3589
		   "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
		   addr, BATADV_PRINT_VID(vid), orig_node->orig);
3590 3591 3592 3593
	ret = true;
out:
	return ret;
}
3594

3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635
/**
 * batadv_tt_local_resize_to_mtu - resize the local translation table fit the
 *  maximum packet size that can be transported through the mesh
 * @soft_iface: netdev struct of the mesh interface
 *
 * Remove entries older than 'timeout' and half timeout if more entries need
 * to be removed.
 */
void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)
{
	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
	int packet_size_max = atomic_read(&bat_priv->packet_size_max);
	int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;
	bool reduced = false;

	spin_lock_bh(&bat_priv->tt.commit_lock);

	while (true) {
		table_size = batadv_tt_local_table_transmit_size(bat_priv);
		if (packet_size_max >= table_size)
			break;

		batadv_tt_local_purge(bat_priv, timeout);
		batadv_tt_local_purge_pending_clients(bat_priv);

		timeout /= 2;
		reduced = true;
		net_ratelimited_function(batadv_info, soft_iface,
					 "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",
					 packet_size_max);
	}

	/* commit these changes immediately, to avoid synchronization problem
	 * with the TTVN
	 */
	if (reduced)
		batadv_tt_local_commit_changes_nolock(bat_priv);

	spin_unlock_bh(&bat_priv->tt.commit_lock);
}

3636 3637 3638 3639 3640 3641 3642 3643 3644 3645
/**
 * batadv_tt_tvlv_ogm_handler_v1 - process incoming tt tvlv container
 * @bat_priv: the bat priv with all the soft interface information
 * @orig: the orig_node of the ogm
 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
 * @tvlv_value: tvlv buffer containing the gateway data
 * @tvlv_value_len: tvlv buffer length
 */
static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
					  struct batadv_orig_node *orig,
3646 3647
					  u8 flags, void *tvlv_value,
					  u16 tvlv_value_len)
3648
{
3649 3650
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
	struct batadv_tvlv_tt_change *tt_change;
3651
	struct batadv_tvlv_tt_data *tt_data;
3652
	u16 num_entries, num_vlan;
3653 3654 3655 3656 3657 3658 3659

	if (tvlv_value_len < sizeof(*tt_data))
		return;

	tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
	tvlv_value_len -= sizeof(*tt_data);

3660 3661 3662 3663 3664 3665 3666 3667 3668
	num_vlan = ntohs(tt_data->num_vlan);

	if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)
		return;

	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
	tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);
	tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;

3669
	num_entries = batadv_tt_entries(tvlv_value_len);
3670

3671 3672
	batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
			      num_entries, tt_data->ttvn);
3673 3674
}

3675 3676 3677 3678 3679 3680 3681 3682 3683
/**
 * batadv_tt_tvlv_unicast_handler_v1 - process incoming (unicast) tt tvlv
 *  container
 * @bat_priv: the bat priv with all the soft interface information
 * @src: mac address of tt tvlv sender
 * @dst: mac address of tt tvlv recipient
 * @tvlv_value: tvlv buffer containing the tt data
 * @tvlv_value_len: tvlv buffer length
 *
3684
 * Return: NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS
3685 3686 3687
 * otherwise.
 */
static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3688
					     u8 *src, u8 *dst,
3689
					     void *tvlv_value,
3690
					     u16 tvlv_value_len)
3691 3692
{
	struct batadv_tvlv_tt_data *tt_data;
3693
	u16 tt_vlan_len, tt_num_entries;
3694 3695 3696 3697 3698 3699 3700 3701 3702
	char tt_flag;
	bool ret;

	if (tvlv_value_len < sizeof(*tt_data))
		return NET_RX_SUCCESS;

	tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
	tvlv_value_len -= sizeof(*tt_data);

3703 3704 3705 3706 3707 3708 3709 3710
	tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);
	tt_vlan_len *= ntohs(tt_data->num_vlan);

	if (tvlv_value_len < tt_vlan_len)
		return NET_RX_SUCCESS;

	tvlv_value_len -= tt_vlan_len;
	tt_num_entries = batadv_tt_entries(tvlv_value_len);
3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737

	switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {
	case BATADV_TT_REQUEST:
		batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);

		/* If this node cannot provide a TT response the tt_request is
		 * forwarded
		 */
		ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);
		if (!ret) {
			if (tt_data->flags & BATADV_TT_FULL_TABLE)
				tt_flag = 'F';
			else
				tt_flag = '.';

			batadv_dbg(BATADV_DBG_TT, bat_priv,
				   "Routing TT_REQUEST to %pM [%c]\n",
				   dst, tt_flag);
			/* tvlv API will re-route the packet */
			return NET_RX_DROP;
		}
		break;
	case BATADV_TT_RESPONSE:
		batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);

		if (batadv_is_my_mac(bat_priv, dst)) {
			batadv_handle_tt_response(bat_priv, tt_data,
3738
						  src, tt_num_entries);
3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756
			return NET_RX_SUCCESS;
		}

		if (tt_data->flags & BATADV_TT_FULL_TABLE)
			tt_flag =  'F';
		else
			tt_flag = '.';

		batadv_dbg(BATADV_DBG_TT, bat_priv,
			   "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);

		/* tvlv API will re-route the packet */
		return NET_RX_DROP;
	}

	return NET_RX_SUCCESS;
}

3757 3758 3759 3760 3761 3762 3763 3764
/**
 * batadv_roam_tvlv_unicast_handler_v1 - process incoming tt roam tvlv container
 * @bat_priv: the bat priv with all the soft interface information
 * @src: mac address of tt tvlv sender
 * @dst: mac address of tt tvlv recipient
 * @tvlv_value: tvlv buffer containing the tt data
 * @tvlv_value_len: tvlv buffer length
 *
3765
 * Return: NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS
3766 3767 3768
 * otherwise.
 */
static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3769
					       u8 *src, u8 *dst,
3770
					       void *tvlv_value,
3771
					       u16 tvlv_value_len)
3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797
{
	struct batadv_tvlv_roam_adv *roaming_adv;
	struct batadv_orig_node *orig_node = NULL;

	/* If this node is not the intended recipient of the
	 * roaming advertisement the packet is forwarded
	 * (the tvlv API will re-route the packet).
	 */
	if (!batadv_is_my_mac(bat_priv, dst))
		return NET_RX_DROP;

	if (tvlv_value_len < sizeof(*roaming_adv))
		goto out;

	orig_node = batadv_orig_hash_find(bat_priv, src);
	if (!orig_node)
		goto out;

	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
	roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;

	batadv_dbg(BATADV_DBG_TT, bat_priv,
		   "Received ROAMING_ADV from %pM (client %pM)\n",
		   src, roaming_adv->client);

	batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,
3798
			     ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
3799 3800 3801 3802
			     atomic_read(&orig_node->last_ttvn) + 1);

out:
	if (orig_node)
3803
		batadv_orig_node_put(orig_node);
3804 3805 3806
	return NET_RX_SUCCESS;
}

3807 3808 3809 3810
/**
 * batadv_tt_init - initialise the translation table internals
 * @bat_priv: the bat priv with all the soft interface information
 *
3811
 * Return: 0 on success or negative error number in case of failure.
3812 3813 3814 3815 3816
 */
int batadv_tt_init(struct batadv_priv *bat_priv)
{
	int ret;

3817 3818 3819
	/* synchronized flags must be remote */
	BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));

3820 3821 3822 3823 3824 3825 3826 3827 3828
	ret = batadv_tt_local_init(bat_priv);
	if (ret < 0)
		return ret;

	ret = batadv_tt_global_init(bat_priv);
	if (ret < 0)
		return ret;

	batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,
3829 3830
				     batadv_tt_tvlv_unicast_handler_v1,
				     BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
3831

3832 3833 3834 3835
	batadv_tvlv_handler_register(bat_priv, NULL,
				     batadv_roam_tvlv_unicast_handler_v1,
				     BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);

3836 3837 3838 3839 3840 3841
	INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
			   msecs_to_jiffies(BATADV_TT_WORK_PERIOD));

	return 1;
}
3842 3843 3844 3845 3846 3847 3848

/**
 * batadv_tt_global_is_isolated - check if a client is marked as isolated
 * @bat_priv: the bat priv with all the soft interface information
 * @addr: the mac address of the client
 * @vid: the identifier of the VLAN where this client is connected
 *
3849
 * Return: true if the client is marked with the TT_CLIENT_ISOLA flag, false
3850 3851 3852
 * otherwise
 */
bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
3853
				  const u8 *addr, unsigned short vid)
3854 3855 3856 3857 3858 3859 3860 3861 3862 3863
{
	struct batadv_tt_global_entry *tt;
	bool ret;

	tt = batadv_tt_global_hash_find(bat_priv, addr, vid);
	if (!tt)
		return false;

	ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;

3864
	batadv_tt_global_entry_put(tt);
3865 3866 3867

	return ret;
}