translation-table.c 112.5 KB
Newer Older
1
/* Copyright (C) 2007-2015 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 34 35 36 37 38 39 40 41 42 43 44 45 46 47
#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>
#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 <net/net_namespace.h>

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

55 56 57 58
/* 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;

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

71
/* returns 1 if they are the same mac addr */
72
static int batadv_compare_tt(const struct hlist_node *node, const void *data2)
73
{
74
	const void *data1 = container_of(node, struct batadv_tt_common_entry,
75
					 hash_entry);
76

77
	return batadv_compare_eth(data1, data2);
78 79
}

80 81 82 83 84 85 86 87
/**
 * 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
 *
 * Returns the hash index where the object represented by 'data' should be
 * stored at.
 */
88
static inline u32 batadv_choose_tt(const void *data, u32 size)
89 90
{
	struct batadv_tt_common_entry *tt;
91
	u32 hash = 0;
92 93

	tt = (struct batadv_tt_common_entry *)data;
94 95
	hash = jhash(&tt->addr, ETH_ALEN, hash);
	hash = jhash(&tt->vid, sizeof(tt->vid), hash);
96 97 98 99 100 101 102 103 104 105 106 107 108

	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
 *
 * Returns a pointer to the tt_common struct belonging to the searched client if
 * found, NULL otherwise.
 */
109
static struct batadv_tt_common_entry *
110
batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,
111
		    unsigned short vid)
112 113
{
	struct hlist_head *head;
114
	struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;
115
	u32 index;
116 117 118 119

	if (!hash)
		return NULL;

120
	ether_addr_copy(to_search.addr, addr);
121 122 123
	to_search.vid = vid;

	index = batadv_choose_tt(&to_search, hash->size);
124 125 126
	head = &hash->table[index];

	rcu_read_lock();
127 128 129 130 131
	hlist_for_each_entry_rcu(tt, head, hash_entry) {
		if (!batadv_compare_eth(tt, addr))
			continue;

		if (tt->vid != vid)
132 133
			continue;

134
		if (!atomic_inc_not_zero(&tt->refcount))
135 136
			continue;

137
		tt_tmp = tt;
138 139 140 141
		break;
	}
	rcu_read_unlock();

142
	return tt_tmp;
143 144
}

145 146 147 148 149 150 151 152 153
/**
 * 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
 *
 * Returns a pointer to the corresponding tt_local_entry struct if the client is
 * found, NULL otherwise.
 */
154
static struct batadv_tt_local_entry *
155
batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
156
			  unsigned short vid)
157
{
158 159
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_local_entry *tt_local_entry = NULL;
160

161 162
	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
					      vid);
163 164
	if (tt_common_entry)
		tt_local_entry = container_of(tt_common_entry,
165 166
					      struct batadv_tt_local_entry,
					      common);
167 168
	return tt_local_entry;
}
169

170 171 172 173 174 175 176 177 178
/**
 * 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
 *
 * Returns a pointer to the corresponding tt_global_entry struct if the client
 * is found, NULL otherwise.
 */
179
static struct batadv_tt_global_entry *
180
batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
181
			   unsigned short vid)
182
{
183 184
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_global_entry *tt_global_entry = NULL;
185

186 187
	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
					      vid);
188 189
	if (tt_common_entry)
		tt_global_entry = container_of(tt_common_entry,
190 191
					       struct batadv_tt_global_entry,
					       common);
192
	return tt_global_entry;
193 194
}

195
static void
196
batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)
197
{
198 199
	if (atomic_dec_and_test(&tt_local_entry->common.refcount))
		kfree_rcu(tt_local_entry, common.rcu);
200 201
}

202 203 204 205 206
/**
 * batadv_tt_global_entry_free_ref - decrement the refcounter for a
 *  tt_global_entry and possibly free it
 * @tt_global_entry: the object to free
 */
207
static void
208
batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)
209
{
210
	if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {
211
		batadv_tt_global_del_orig_list(tt_global_entry);
212
		kfree_rcu(tt_global_entry, common.rcu);
213 214 215
	}
}

216 217 218 219 220 221 222 223 224 225
/**
 * batadv_tt_global_hash_count - count the number of orig entries
 * @hash: hash table containing the tt entries
 * @addr: the mac address of the client to count entries for
 * @vid: VLAN identifier
 *
 * Return the number of originators advertising the given address/data
 * (excluding ourself).
 */
int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
226
				const u8 *addr, unsigned short vid)
227 228 229 230 231 232 233 234 235 236 237 238 239 240
{
	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);
	batadv_tt_global_entry_free_ref(tt_global_entry);

	return count;
}

241
static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
242
{
243
	struct batadv_tt_orig_list_entry *orig_entry;
244

245
	orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);
246 247 248 249 250 251

	/* We are in an rcu callback here, therefore we cannot use
	 * batadv_orig_node_free_ref() and its call_rcu():
	 * An rcu_barrier() wouldn't wait for that to finish
	 */
	batadv_orig_node_free_ref_now(orig_entry->orig_node);
252 253 254
	kfree(orig_entry);
}

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
/**
 * 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);

	batadv_softif_vlan_free_ref(vlan);
}

/**
 * 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);
}

/**
 * batadv_tt_global_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
 * @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);
318
		hlist_del_init_rcu(&vlan->list);
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
		spin_unlock_bh(&orig_node->vlan_list_lock);
		batadv_orig_node_vlan_free_ref(vlan);
	}

	batadv_orig_node_vlan_free_ref(vlan);
}

/**
 * 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);
}

350
static void
351
batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)
352
{
353 354
	if (!atomic_dec_and_test(&orig_entry->refcount))
		return;
355

356
	call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);
357 358
}

359 360 361 362 363 364
/**
 * 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
 */
365
static void batadv_tt_local_event(struct batadv_priv *bat_priv,
366
				  struct batadv_tt_local_entry *tt_local_entry,
367
				  u8 event_flags)
368
{
369
	struct batadv_tt_change_node *tt_change_node, *entry, *safe;
370
	struct batadv_tt_common_entry *common = &tt_local_entry->common;
371
	u8 flags = common->flags | event_flags;
372 373
	bool event_removed = false;
	bool del_op_requested, del_op_entry;
374 375 376 377 378

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

379
	tt_change_node->change.flags = flags;
380 381
	memset(tt_change_node->change.reserved, 0,
	       sizeof(tt_change_node->change.reserved));
382
	ether_addr_copy(tt_change_node->change.addr, common->addr);
383
	tt_change_node->change.vid = htons(common->vid);
384

385
	del_op_requested = flags & BATADV_TT_CLIENT_DEL;
386 387

	/* check for ADD+DEL or DEL+ADD events */
388 389
	spin_lock_bh(&bat_priv->tt.changes_list_lock);
	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
390
				 list) {
391
		if (!batadv_compare_eth(entry->change.addr, common->addr))
392 393 394 395 396 397 398 399 400
			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
		 */
401
		del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
402 403 404 405
		if (!del_op_requested && del_op_entry)
			goto del;
		if (del_op_requested && !del_op_entry)
			goto del;
406 407 408 409 410 411 412

		/* 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;

413 414 415 416
		continue;
del:
		list_del(&entry->list);
		kfree(entry);
417
		kfree(tt_change_node);
418 419 420 421
		event_removed = true;
		goto unlock;
	}

422
	/* track the change in the OGMinterval list */
423
	list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);
424 425

unlock:
426
	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
427

428
	if (event_removed)
429
		atomic_dec(&bat_priv->tt.local_changes);
430
	else
431
		atomic_inc(&bat_priv->tt.local_changes);
432 433
}

434 435 436 437 438 439 440
/**
 * batadv_tt_len - compute length in bytes of given number of tt changes
 * @changes_num: number of tt changes
 *
 * Returns computed length in bytes.
 */
static int batadv_tt_len(int changes_num)
441
{
442
	return changes_num * sizeof(struct batadv_tvlv_tt_change);
443 444
}

445 446 447 448 449 450
/**
 * batadv_tt_entries - compute the number of entries fitting in tt_len bytes
 * @tt_len: available space
 *
 * Returns the number of entries.
 */
451
static u16 batadv_tt_entries(u16 tt_len)
452 453 454 455
{
	return tt_len / batadv_tt_len(1);
}

456 457 458 459 460 461 462 463 464
/**
 * 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
 *
 * Returns local translation table size in bytes.
 */
static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
{
465 466
	u16 num_vlan = 0;
	u16 tt_local_entries = 0;
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
	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);
}

486
static int batadv_tt_local_init(struct batadv_priv *bat_priv)
487
{
488
	if (bat_priv->tt.local_hash)
489
		return 0;
490

491
	bat_priv->tt.local_hash = batadv_hash_new(1024);
492

493
	if (!bat_priv->tt.local_hash)
494
		return -ENOMEM;
495

496 497 498
	batadv_hash_set_lock_class(bat_priv->tt.local_hash,
				   &batadv_tt_local_hash_lock_class_key);

499
	return 0;
500 501
}

502 503 504 505 506
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,
507 508 509
		   "Deleting global tt entry %pM (vid: %d): %s\n",
		   tt_global->common.addr,
		   BATADV_PRINT_VID(tt_global->common.vid), message);
510 511

	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
512
			   batadv_choose_tt, &tt_global->common);
513 514 515
	batadv_tt_global_entry_free_ref(tt_global);
}

516 517 518 519 520 521 522 523
/**
 * 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)
524 525
 * @mark: the value contained in the skb->mark field of the received packet (if
 *  any)
526 527
 *
 * Returns true if the client was successfully added, false otherwise.
528
 */
529 530
bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,
			 unsigned short vid, int ifindex, u32 mark)
531
{
532
	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
533
	struct batadv_tt_local_entry *tt_local;
534
	struct batadv_tt_global_entry *tt_global = NULL;
535
	struct batadv_softif_vlan *vlan;
536
	struct net_device *in_dev = NULL;
537
	struct hlist_head *head;
538
	struct batadv_tt_orig_list_entry *orig_entry;
539
	int hash_added, table_size, packet_size_max;
540 541
	bool ret = false;
	bool roamed_back = false;
542 543
	u8 remote_flags;
	u32 match_mark;
544

545 546 547
	if (ifindex != BATADV_NULL_IFINDEX)
		in_dev = dev_get_by_index(&init_net, ifindex);

548
	tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);
549 550 551

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

553 554
	if (tt_local) {
		tt_local->last_seen = jiffies;
555 556
		if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
			batadv_dbg(BATADV_DBG_TT, bat_priv,
557 558
				   "Re-adding pending client %pM (vid: %d)\n",
				   addr, BATADV_PRINT_VID(vid));
559 560 561 562 563 564 565 566 567 568 569
			/* 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,
570 571
				   "Roaming client %pM (vid: %d) came back to its original location\n",
				   addr, BATADV_PRINT_VID(vid));
572 573 574 575 576 577 578 579 580
			/* 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;
581 582
	}

583 584 585 586 587 588 589 590 591 592 593
	/* 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;
	}

594 595
	tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);
	if (!tt_local)
596
		goto out;
597

598 599
	/* increase the refcounter of the related vlan */
	vlan = batadv_softif_vlan_get(bat_priv, vid);
600
	if (WARN(!vlan, "adding TT local entry %pM to non-existent VLAN %d",
601 602 603
		 addr, BATADV_PRINT_VID(vid))) {
		kfree(tt_local);
		tt_local = NULL;
604
		goto out;
605
	}
606

607
	batadv_dbg(BATADV_DBG_TT, bat_priv,
608 609
		   "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",
		   addr, BATADV_PRINT_VID(vid),
610
		   (u8)atomic_read(&bat_priv->tt.vn));
611

612
	ether_addr_copy(tt_local->common.addr, addr);
613 614 615 616 617
	/* 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;
618
	tt_local->common.vid = vid;
619
	if (batadv_is_wifi_netdev(in_dev))
620 621 622 623
		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
	atomic_set(&tt_local->common.refcount, 2);
	tt_local->last_seen = jiffies;
	tt_local->common.added_at = tt_local->last_seen;
624

625 626 627 628 629
	/* 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))
630
		tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;
631

632
	hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
633
				     batadv_choose_tt, &tt_local->common,
634
				     &tt_local->common.hash_entry);
635 636 637

	if (unlikely(hash_added != 0)) {
		/* remove the reference for the hash */
638
		batadv_tt_local_entry_free_ref(tt_local);
639
		batadv_softif_vlan_free_ref(vlan);
640 641 642
		goto out;
	}

643
add_event:
644
	batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
645

646 647 648 649 650
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)) {
651
		/* These node are probably going to update their tt table */
652
		head = &tt_global->orig_list;
653
		rcu_read_lock();
654
		hlist_for_each_entry_rcu(orig_entry, head, list) {
655
			batadv_send_roam_adv(bat_priv, tt_global->common.addr,
656
					     tt_global->common.vid,
657
					     orig_entry->orig_node);
658 659
		}
		rcu_read_unlock();
660 661 662 663 664 665 666 667 668 669 670
		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;
		}
671
	}
672

673 674 675 676 677 678 679 680 681
	/* 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;
682

683 684 685 686 687 688 689 690 691 692 693
	/* 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;

694 695 696 697 698 699 700
	/* 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;
701
out:
702 703
	if (in_dev)
		dev_put(in_dev);
704 705 706 707
	if (tt_local)
		batadv_tt_local_entry_free_ref(tt_local);
	if (tt_global)
		batadv_tt_global_entry_free_ref(tt_global);
708
	return ret;
709 710
}

711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
/**
 * 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.
 *
 * Return the size of the allocated buffer or 0 in case of failure.
 */
729
static u16
730 731 732
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,
733
				   s32 *tt_len)
734
{
735 736 737 738
	u16 num_vlan = 0;
	u16 num_entries = 0;
	u16 change_offset;
	u16 tvlv_len;
739 740
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
	struct batadv_orig_node_vlan *vlan;
741
	u8 *tt_change_ptr;
742 743

	rcu_read_lock();
744
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
		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);
770
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
771 772 773 774 775 776
		tt_vlan->vid = htons(vlan->vid);
		tt_vlan->crc = htonl(vlan->tt.crc);

		tt_vlan++;
	}

777
	tt_change_ptr = (u8 *)*tt_data + change_offset;
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
	*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.
 *
 * Return the size of the allocated buffer or 0 in case of failure.
 */
803
static u16
804 805 806
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,
807
				  s32 *tt_len)
808 809 810
{
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
	struct batadv_softif_vlan *vlan;
811 812 813
	u16 num_vlan = 0;
	u16 num_entries = 0;
	u16 tvlv_len;
814
	u8 *tt_change_ptr;
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
	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++;
	}

851
	tt_change_ptr = (u8 *)*tt_data + change_offset;
852 853 854 855 856 857 858
	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;

out:
	rcu_read_unlock();
	return tvlv_len;
}

859 860 861 862 863 864
/**
 * 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)
865
{
866 867 868
	struct batadv_tt_change_node *entry, *safe;
	struct batadv_tvlv_tt_data *tt_data;
	struct batadv_tvlv_tt_change *tt_change;
869
	int tt_diff_len, tt_change_len = 0;
870 871
	int tt_diff_entries_num = 0;
	int tt_diff_entries_count = 0;
872
	u16 tvlv_len;
873

874 875
	tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
	tt_diff_len = batadv_tt_len(tt_diff_entries_num);
876 877 878 879

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

883 884 885
	tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
						     &tt_change, &tt_diff_len);
	if (!tvlv_len)
886
		return;
887

888
	tt_data->flags = BATADV_TT_OGM_DIFF;
889

890 891
	if (tt_diff_len == 0)
		goto container_register;
892

893 894
	spin_lock_bh(&bat_priv->tt.changes_list_lock);
	atomic_set(&bat_priv->tt.local_changes, 0);
895

896
	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
897
				 list) {
898 899 900 901 902
		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++;
903
		}
904 905
		list_del(&entry->list);
		kfree(entry);
906
	}
907
	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
908 909

	/* Keep the buffer for possible tt_request */
910 911 912 913
	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;
914
	tt_change_len = batadv_tt_len(tt_diff_entries_count);
915
	/* check whether this new OGM has no changes due to size problems */
916
	if (tt_diff_entries_count > 0) {
917
		/* if kmalloc() fails we will reply with the full table
918 919
		 * instead of providing the diff
		 */
920
		bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);
921
		if (bat_priv->tt.last_changeset) {
922 923 924
			memcpy(bat_priv->tt.last_changeset,
			       tt_change, tt_change_len);
			bat_priv->tt.last_changeset_len = tt_diff_len;
925 926
		}
	}
927
	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
928

929 930
container_register:
	batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,
931
				       tvlv_len);
932
	kfree(tt_data);
933 934
}

935
int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
936 937
{
	struct net_device *net_dev = (struct net_device *)seq->private;
938
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
939
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
940
	struct batadv_tt_common_entry *tt_common_entry;
941
	struct batadv_tt_local_entry *tt_local;
942
	struct batadv_hard_iface *primary_if;
943
	struct batadv_softif_vlan *vlan;
944
	struct hlist_head *head;
945
	unsigned short vid;
946
	u32 i;
947 948 949 950
	int last_seen_secs;
	int last_seen_msecs;
	unsigned long last_seen_jiffies;
	bool no_purge;
951
	u16 np_flag = BATADV_TT_CLIENT_NOPURGE;
952

953 954
	primary_if = batadv_seq_print_text_primary_if_get(seq);
	if (!primary_if)
955
		goto out;
956

957
	seq_printf(seq,
958
		   "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
959
		   net_dev->name, (u8)atomic_read(&bat_priv->tt.vn));
960
	seq_printf(seq, "       %-13s  %s %-8s %-9s (%-10s)\n", "Client", "VID",
961
		   "Flags", "Last seen", "CRC");
962 963 964 965

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

966
		rcu_read_lock();
967
		hlist_for_each_entry_rcu(tt_common_entry,
968
					 head, hash_entry) {
969 970 971
			tt_local = container_of(tt_common_entry,
						struct batadv_tt_local_entry,
						common);
972
			vid = tt_common_entry->vid;
973 974 975 976 977 978 979
			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;

980 981 982 983 984 985 986 987
			vlan = batadv_softif_vlan_get(bat_priv, vid);
			if (!vlan) {
				seq_printf(seq, "Cannot retrieve VLAN %d\n",
					   BATADV_PRINT_VID(vid));
				continue;
			}

			seq_printf(seq,
988
				   " * %pM %4i [%c%c%c%c%c%c] %3u.%03u   (%#.8x)\n",
989
				   tt_common_entry->addr,
990
				   BATADV_PRINT_VID(tt_common_entry->vid),
991 992
				   ((tt_common_entry->flags &
				     BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
993
				   no_purge ? 'P' : '.',
994 995 996 997 998 999 1000 1001
				   ((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' : '.'),
1002
				   no_purge ? 0 : last_seen_secs,
1003 1004 1005 1006
				   no_purge ? 0 : last_seen_msecs,
				   vlan->tt.crc);

			batadv_softif_vlan_free_ref(vlan);
1007
		}
1008
		rcu_read_unlock();
1009
	}
1010 1011
out:
	if (primary_if)
1012
		batadv_hardif_free_ref(primary_if);
1013
	return 0;
1014 1015
}

1016 1017 1018
static void
batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
			    struct batadv_tt_local_entry *tt_local_entry,
1019
			    u16 flags, const char *message)
1020
{
1021
	batadv_tt_local_event(bat_priv, tt_local_entry, flags);
1022

1023 1024
	/* 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
1025 1026
	 * response issued before the net ttvn increment (consistency check)
	 */
1027
	tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
1028

1029
	batadv_dbg(BATADV_DBG_TT, bat_priv,
1030 1031 1032
		   "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);
1033 1034
}

1035 1036 1037 1038
/**
 * 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
1039
 * @vid: VLAN identifier
1040 1041 1042 1043 1044
 * @message: message to append to the log on deletion
 * @roaming: true if the deletion is due to a roaming event
 *
 * Returns the flags assigned to the local entry before being deleted
 */
1045 1046 1047
u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,
			   unsigned short vid, const char *message,
			   bool roaming)
1048
{
1049
	struct batadv_tt_local_entry *tt_local_entry;
1050
	u16 flags, curr_flags = BATADV_NO_FLAGS;
1051
	struct batadv_softif_vlan *vlan;
1052
	void *tt_entry_exists;
1053

1054
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
1055 1056 1057
	if (!tt_local_entry)
		goto out;

1058 1059
	curr_flags = tt_local_entry->common.flags;

1060
	flags = BATADV_TT_CLIENT_DEL;
1061 1062 1063 1064
	/* 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
	 */
1065
	if (roaming) {
1066
		flags |= BATADV_TT_CLIENT_ROAM;
1067 1068 1069
		/* mark the local client as ROAMed */
		tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
	}
1070

1071 1072 1073 1074 1075 1076 1077 1078
	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
	 */
1079
	batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
1080 1081 1082 1083 1084 1085 1086 1087 1088

	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 */
1089
	batadv_tt_local_entry_free_ref(tt_local_entry);
1090

1091 1092
	/* decrease the reference held for this vlan */
	vlan = batadv_softif_vlan_get(bat_priv, vid);
1093 1094 1095
	if (!vlan)
		goto out;

1096 1097 1098
	batadv_softif_vlan_free_ref(vlan);
	batadv_softif_vlan_free_ref(vlan);

1099 1100
out:
	if (tt_local_entry)
1101
		batadv_tt_local_entry_free_ref(tt_local_entry);
1102 1103

	return curr_flags;
1104 1105
}

1106 1107 1108 1109 1110 1111 1112
/**
 * 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
 */
1113
static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
1114 1115
				       struct hlist_head *head,
				       int timeout)
1116
{
1117 1118
	struct batadv_tt_local_entry *tt_local_entry;
	struct batadv_tt_common_entry *tt_common_entry;
1119
	struct hlist_node *node_tmp;
1120

1121
	hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
1122 1123
				  hash_entry) {
		tt_local_entry = container_of(tt_common_entry,
1124 1125
					      struct batadv_tt_local_entry,
					      common);
1126 1127 1128 1129 1130 1131 1132
		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;

1133
		if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))
1134 1135 1136 1137 1138 1139 1140
			continue;

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

1141 1142 1143 1144 1145 1146 1147 1148
/**
 * 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)
1149
{
1150
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1151
	struct hlist_head *head;
1152
	spinlock_t *list_lock; /* protects write access to the hash lists */
1153
	u32 i;
1154 1155 1156

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

1159
		spin_lock_bh(list_lock);
1160
		batadv_tt_local_purge_list(bat_priv, head, timeout);
1161
		spin_unlock_bh(list_lock);
1162 1163 1164
	}
}

1165
static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
1166
{
1167
	struct batadv_hashtable *hash;
1168
	spinlock_t *list_lock; /* protects write access to the hash lists */
1169 1170
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_local_entry *tt_local;
1171
	struct batadv_softif_vlan *vlan;
1172
	struct hlist_node *node_tmp;
1173
	struct hlist_head *head;
1174
	u32 i;
1175

1176
	if (!bat_priv->tt.local_hash)
1177 1178
		return;

1179
	hash = bat_priv->tt.local_hash;
1180 1181 1182 1183 1184 1185

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

		spin_lock_bh(list_lock);
1186
		hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1187
					  head, hash_entry) {
1188
			hlist_del_rcu(&tt_common_entry->hash_entry);
1189 1190 1191
			tt_local = container_of(tt_common_entry,
						struct batadv_tt_local_entry,
						common);
1192 1193 1194 1195

			/* decrease the reference held for this vlan */
			vlan = batadv_softif_vlan_get(bat_priv,
						      tt_common_entry->vid);
1196 1197 1198 1199
			if (vlan) {
				batadv_softif_vlan_free_ref(vlan);
				batadv_softif_vlan_free_ref(vlan);
			}
1200

1201
			batadv_tt_local_entry_free_ref(tt_local);
1202 1203 1204 1205
		}
		spin_unlock_bh(list_lock);
	}

1206
	batadv_hash_destroy(hash);
1207

1208
	bat_priv->tt.local_hash = NULL;
1209 1210
}

1211
static int batadv_tt_global_init(struct batadv_priv *bat_priv)
1212
{
1213
	if (bat_priv->tt.global_hash)
1214
		return 0;
1215

1216
	bat_priv->tt.global_hash = batadv_hash_new(1024);
1217

1218
	if (!bat_priv->tt.global_hash)
1219
		return -ENOMEM;
1220

1221 1222 1223
	batadv_hash_set_lock_class(bat_priv->tt.global_hash,
				   &batadv_tt_global_hash_lock_class_key);

1224
	return 0;
1225 1226
}

1227
static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
1228
{
1229
	struct batadv_tt_change_node *entry, *safe;
1230

1231
	spin_lock_bh(&bat_priv->tt.changes_list_lock);
1232

1233
	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1234 1235 1236 1237
				 list) {
		list_del(&entry->list);
		kfree(entry);
	}
1238

1239 1240
	atomic_set(&bat_priv->tt.local_changes, 0);
	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1241
}
1242

1243 1244 1245 1246
/* retrieves the orig_tt_list_entry belonging to orig_node from the
 * batadv_tt_global_entry list
 *
 * returns it with an increased refcounter, NULL if not found
1247
 */
1248 1249 1250
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)
1251
{
1252
	struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
1253 1254 1255 1256
	const struct hlist_head *head;

	rcu_read_lock();
	head = &entry->orig_list;
1257
	hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
1258 1259 1260 1261 1262 1263 1264
		if (tmp_orig_entry->orig_node != orig_node)
			continue;
		if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))
			continue;

		orig_entry = tmp_orig_entry;
		break;
1265 1266
	}
	rcu_read_unlock();
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286

	return orig_entry;
}

/* find out if an orig_node is already in the list of a tt_global_entry.
 * returns true if found, false otherwise
 */
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;
		batadv_tt_orig_list_entry_free_ref(orig_entry);
	}

1287 1288 1289
	return found;
}

1290
static void
1291
batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
1292
				struct batadv_orig_node *orig_node, int ttvn)
1293
{
1294
	struct batadv_tt_orig_list_entry *orig_entry;
1295

1296
	orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);
1297 1298 1299 1300 1301
	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;
1302
		goto out;
1303
	}
1304

1305 1306
	orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
	if (!orig_entry)
1307
		goto out;
1308 1309 1310

	INIT_HLIST_NODE(&orig_entry->list);
	atomic_inc(&orig_node->refcount);
1311
	batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
1312 1313
	orig_entry->orig_node = orig_node;
	orig_entry->ttvn = ttvn;
1314
	atomic_set(&orig_entry->refcount, 2);
1315

1316
	spin_lock_bh(&tt_global->list_lock);
1317
	hlist_add_head_rcu(&orig_entry->list,
1318 1319
			   &tt_global->orig_list);
	spin_unlock_bh(&tt_global->list_lock);
1320 1321
	atomic_inc(&tt_global->orig_list_count);

1322 1323 1324
out:
	if (orig_entry)
		batadv_tt_orig_list_entry_free_ref(orig_entry);
1325 1326
}

1327 1328 1329 1330 1331
/**
 * 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
1332
 * @vid: VLAN identifier
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
 * @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.
1343 1344
 *
 * Return true if the new entry has been added, false otherwise
1345
 */
1346 1347
static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
				 struct batadv_orig_node *orig_node,
1348
				 const unsigned char *tt_addr,
1349
				 unsigned short vid, u16 flags, u8 ttvn)
1350
{
1351 1352
	struct batadv_tt_global_entry *tt_global_entry;
	struct batadv_tt_local_entry *tt_local_entry;
1353
	bool ret = false;
1354
	int hash_added;
1355
	struct batadv_tt_common_entry *common;
1356
	u16 local_flags;
1357

1358 1359 1360 1361
	/* ignore global entries from backbone nodes */
	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
		return true;

1362 1363
	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);
1364 1365 1366 1367 1368 1369 1370 1371

	/* 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;
1372 1373

	if (!tt_global_entry) {
1374
		tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);
1375
		if (!tt_global_entry)
1376 1377
			goto out;

1378
		common = &tt_global_entry->common;
1379
		ether_addr_copy(common->addr, tt_addr);
1380
		common->vid = vid;
1381

1382
		common->flags = flags;
1383
		tt_global_entry->roam_at = 0;
1384 1385 1386 1387 1388 1389
		/* 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;
1390
		atomic_set(&common->refcount, 2);
1391
		common->added_at = jiffies;
1392 1393

		INIT_HLIST_HEAD(&tt_global_entry->orig_list);
1394
		atomic_set(&tt_global_entry->orig_list_count, 0);
1395
		spin_lock_init(&tt_global_entry->list_lock);
1396

1397
		hash_added = batadv_hash_add(bat_priv->tt.global_hash,
1398
					     batadv_compare_tt,
1399
					     batadv_choose_tt, common,
1400
					     &common->hash_entry);
1401 1402 1403

		if (unlikely(hash_added != 0)) {
			/* remove the reference for the hash */
1404
			batadv_tt_global_entry_free_ref(tt_global_entry);
1405 1406
			goto out_remove;
		}
1407
	} else {
1408
		common = &tt_global_entry->common;
1409 1410
		/* If there is already a global entry, we can use this one for
		 * our processing.
1411 1412 1413 1414 1415 1416 1417
		 * 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
1418
		 */
1419 1420 1421 1422 1423 1424 1425 1426 1427
		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;
		}
1428 1429

		/* if the client was temporary added before receiving the first
1430 1431 1432 1433
		 * 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.
1434
		 */
1435 1436 1437 1438
		if (common->flags & BATADV_TT_CLIENT_TEMP) {
			batadv_tt_global_del_orig_list(tt_global_entry);
			common->flags &= ~BATADV_TT_CLIENT_TEMP;
		}
1439

1440 1441 1442 1443 1444 1445
		/* the change can carry possible "attribute" flags like the
		 * TT_CLIENT_WIFI, therefore they have to be copied in the
		 * client entry
		 */
		tt_global_entry->common.flags |= flags;

1446 1447
		/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
		 * one originator left in the list and we previously received a
1448 1449 1450 1451 1452
		 * delete + roaming change for this originator.
		 *
		 * We should first delete the old originator before adding the
		 * new one.
		 */
1453
		if (common->flags & BATADV_TT_CLIENT_ROAM) {
1454
			batadv_tt_global_del_orig_list(tt_global_entry);
1455
			common->flags &= ~BATADV_TT_CLIENT_ROAM;
1456
			tt_global_entry->roam_at = 0;
1457 1458
		}
	}
1459
add_orig_entry:
1460
	/* add the new orig_entry (if needed) or update it */
1461
	batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);
1462

1463
	batadv_dbg(BATADV_DBG_TT, bat_priv,
1464 1465 1466
		   "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
		   common->addr, BATADV_PRINT_VID(common->vid),
		   orig_node->orig);
1467
	ret = true;
1468

1469
out_remove:
1470 1471 1472 1473 1474
	/* Do not remove multicast addresses from the local hash on
	 * global additions
	 */
	if (is_multicast_ether_addr(tt_addr))
		goto out;
1475

1476
	/* remove address from local hash if present */
1477
	local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,
1478
					     "global tt received",
1479
					     flags & BATADV_TT_CLIENT_ROAM);
1480 1481
	tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;

1482 1483 1484 1485 1486 1487
	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;

1488 1489
out:
	if (tt_global_entry)
1490
		batadv_tt_global_entry_free_ref(tt_global_entry);
1491 1492
	if (tt_local_entry)
		batadv_tt_local_entry_free_ref(tt_local_entry);
1493
	return ret;
1494 1495
}

1496 1497
/**
 * batadv_transtable_best_orig - Get best originator list entry from tt entry
1498
 * @bat_priv: the bat priv with all the soft interface information
1499 1500 1501 1502 1503 1504
 * @tt_global_entry: global translation table entry to be analyzed
 *
 * This functon assumes the caller holds rcu_read_lock().
 * Returns best originator list entry or NULL on errors.
 */
static struct batadv_tt_orig_list_entry *
1505 1506
batadv_transtable_best_orig(struct batadv_priv *bat_priv,
			    struct batadv_tt_global_entry *tt_global_entry)
1507
{
1508 1509
	struct batadv_neigh_node *router, *best_router = NULL;
	struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
1510 1511 1512 1513
	struct hlist_head *head;
	struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;

	head = &tt_global_entry->orig_list;
1514
	hlist_for_each_entry_rcu(orig_entry, head, list) {
1515 1516
		router = batadv_orig_router_get(orig_entry->orig_node,
						BATADV_IF_DEFAULT);
1517 1518 1519
		if (!router)
			continue;

1520
		if (best_router &&
1521 1522
		    bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT,
				       best_router, BATADV_IF_DEFAULT) <= 0) {
1523 1524
			batadv_neigh_node_free_ref(router);
			continue;
1525 1526
		}

1527 1528 1529 1530 1531 1532
		/* release the refcount for the "old" best */
		if (best_router)
			batadv_neigh_node_free_ref(best_router);

		best_entry = orig_entry;
		best_router = router;
1533 1534
	}

1535 1536 1537
	if (best_router)
		batadv_neigh_node_free_ref(best_router);

1538 1539 1540
	return best_entry;
}

1541 1542 1543
/**
 * batadv_tt_global_print_entry - print all orig nodes who announce the address
 *  for this global entry
1544
 * @bat_priv: the bat priv with all the soft interface information
1545 1546 1547 1548
 * @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().
1549
 */
1550
static void
1551 1552
batadv_tt_global_print_entry(struct batadv_priv *bat_priv,
			     struct batadv_tt_global_entry *tt_global_entry,
1553
			     struct seq_file *seq)
1554
{
1555
	struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
1556
	struct batadv_tt_common_entry *tt_common_entry;
1557 1558
	struct batadv_orig_node_vlan *vlan;
	struct hlist_head *head;
1559 1560
	u8 last_ttvn;
	u16 flags;
1561 1562

	tt_common_entry = &tt_global_entry->common;
1563 1564
	flags = tt_common_entry->flags;

1565
	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
1566
	if (best_entry) {
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
		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;
		}

1577
		last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);
1578
		seq_printf(seq,
1579
			   " %c %pM %4i   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1580
			   '*', tt_global_entry->common.addr,
1581
			   BATADV_PRINT_VID(tt_global_entry->common.vid),
1582
			   best_entry->ttvn, best_entry->orig_node->orig,
1583
			   last_ttvn, vlan->tt.crc,
1584 1585 1586 1587
			   ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
			   ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
			   ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
			   ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1588 1589

		batadv_orig_node_vlan_free_ref(vlan);
1590
	}
1591

1592
print_list:
1593 1594
	head = &tt_global_entry->orig_list;

1595
	hlist_for_each_entry_rcu(orig_entry, head, list) {
1596 1597 1598
		if (best_entry == orig_entry)
			continue;

1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
		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;
		}

1609
		last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);
1610
		seq_printf(seq,
1611
			   " %c %pM %4d   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1612
			   '+', tt_global_entry->common.addr,
1613
			   BATADV_PRINT_VID(tt_global_entry->common.vid),
1614
			   orig_entry->ttvn, orig_entry->orig_node->orig,
1615
			   last_ttvn, vlan->tt.crc,
1616 1617 1618 1619
			   ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
			   ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
			   ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
			   ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1620 1621

		batadv_orig_node_vlan_free_ref(vlan);
1622 1623 1624
	}
}

1625
int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
1626 1627
{
	struct net_device *net_dev = (struct net_device *)seq->private;
1628
	struct batadv_priv *bat_priv = netdev_priv(net_dev);
1629
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1630 1631 1632
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_global_entry *tt_global;
	struct batadv_hard_iface *primary_if;
1633
	struct hlist_head *head;
1634
	u32 i;
1635

1636 1637
	primary_if = batadv_seq_print_text_primary_if_get(seq);
	if (!primary_if)
1638
		goto out;
1639

1640 1641
	seq_printf(seq,
		   "Globally announced TT entries received via the mesh %s\n",
1642
		   net_dev->name);
1643 1644 1645
	seq_printf(seq, "       %-13s  %s  %s       %-15s %s (%-10s) %s\n",
		   "Client", "VID", "(TTVN)", "Originator", "(Curr TTVN)",
		   "CRC", "Flags");
1646 1647 1648 1649

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

1650
		rcu_read_lock();
1651
		hlist_for_each_entry_rcu(tt_common_entry,
1652
					 head, hash_entry) {
1653 1654 1655
			tt_global = container_of(tt_common_entry,
						 struct batadv_tt_global_entry,
						 common);
1656
			batadv_tt_global_print_entry(bat_priv, tt_global, seq);
1657
		}
1658
		rcu_read_unlock();
1659
	}
1660 1661
out:
	if (primary_if)
1662
		batadv_hardif_free_ref(primary_if);
1663
	return 0;
1664 1665
}

1666
/**
1667
 * _batadv_tt_global_del_orig_entry - remove and free an orig_entry
1668 1669 1670 1671 1672
 * @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.
1673 1674 1675
 *
 * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is
 * part of a list.
1676 1677
 */
static void
1678 1679
_batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
				 struct batadv_tt_orig_list_entry *orig_entry)
1680
{
1681 1682
	lockdep_assert_held(&tt_global_entry->list_lock);

1683 1684 1685
	batadv_tt_global_size_dec(orig_entry->orig_node,
				  tt_global_entry->common.vid);
	atomic_dec(&tt_global_entry->orig_list_count);
1686 1687 1688
	/* requires holding tt_global_entry->list_lock and orig_entry->list
	 * being part of a list
	 */
1689 1690 1691 1692
	hlist_del_rcu(&orig_entry->list);
	batadv_tt_orig_list_entry_free_ref(orig_entry);
}

1693
/* deletes the orig list of a tt_global_entry */
1694
static void
1695
batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
1696
{
1697
	struct hlist_head *head;
1698
	struct hlist_node *safe;
1699
	struct batadv_tt_orig_list_entry *orig_entry;
1700

1701 1702
	spin_lock_bh(&tt_global_entry->list_lock);
	head = &tt_global_entry->orig_list;
1703
	hlist_for_each_entry_safe(orig_entry, safe, head, list)
1704
		_batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);
1705 1706 1707
	spin_unlock_bh(&tt_global_entry->list_lock);
}

1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
/**
 * 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.
 */
1718
static void
1719 1720 1721 1722
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)
1723 1724
{
	struct hlist_head *head;
1725
	struct hlist_node *safe;
1726
	struct batadv_tt_orig_list_entry *orig_entry;
1727
	unsigned short vid;
1728 1729 1730

	spin_lock_bh(&tt_global_entry->list_lock);
	head = &tt_global_entry->orig_list;
1731
	hlist_for_each_entry_safe(orig_entry, safe, head, list) {
1732
		if (orig_entry->orig_node == orig_node) {
1733
			vid = tt_global_entry->common.vid;
1734
			batadv_dbg(BATADV_DBG_TT, bat_priv,
1735
				   "Deleting %pM from global tt entry %pM (vid: %d): %s\n",
1736
				   orig_node->orig,
1737 1738
				   tt_global_entry->common.addr,
				   BATADV_PRINT_VID(vid), message);
1739 1740
			_batadv_tt_global_del_orig_entry(tt_global_entry,
							 orig_entry);
1741 1742 1743 1744 1745 1746
		}
	}
	spin_unlock_bh(&tt_global_entry->list_lock);
}

/* If the client is to be deleted, we check if it is the last origantor entry
1747 1748
 * 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.
1749
 */
1750
static void
1751 1752 1753 1754
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)
1755 1756 1757
{
	bool last_entry = true;
	struct hlist_head *head;
1758
	struct batadv_tt_orig_list_entry *orig_entry;
1759 1760 1761 1762 1763 1764 1765

	/* 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;
1766
	hlist_for_each_entry_rcu(orig_entry, head, list) {
1767 1768 1769 1770 1771 1772 1773 1774 1775
		if (orig_entry->orig_node != orig_node) {
			last_entry = false;
			break;
		}
	}
	rcu_read_unlock();

	if (last_entry) {
		/* its the last one, mark for roaming. */
1776
		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1777 1778 1779 1780 1781
		tt_global_entry->roam_at = jiffies;
	} else
		/* there is another entry, we can simply delete this
		 * one and can still use the other one.
		 */
1782 1783
		batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
					       orig_node, message);
1784 1785
}

1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
/**
 * 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
 */
1796 1797
static void batadv_tt_global_del(struct batadv_priv *bat_priv,
				 struct batadv_orig_node *orig_node,
1798
				 const unsigned char *addr, unsigned short vid,
1799
				 const char *message, bool roaming)
1800
{
1801
	struct batadv_tt_global_entry *tt_global_entry;
1802
	struct batadv_tt_local_entry *local_entry = NULL;
1803

1804
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
1805
	if (!tt_global_entry)
1806
		goto out;
1807

1808
	if (!roaming) {
1809 1810
		batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
					       orig_node, message);
1811 1812

		if (hlist_empty(&tt_global_entry->orig_list))
1813 1814
			batadv_tt_global_free(bat_priv, tt_global_entry,
					      message);
1815 1816 1817

		goto out;
	}
1818 1819 1820

	/* if we are deleting a global entry due to a roam
	 * event, there are two possibilities:
1821 1822
	 * 1) the client roamed from node A to node B => if there
	 *    is only one originator left for this client, we mark
1823
	 *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we
1824 1825
	 *    wait for node B to claim it. In case of timeout
	 *    the entry is purged.
1826 1827 1828
	 *
	 *    If there are other originators left, we directly delete
	 *    the originator.
1829
	 * 2) the client roamed to us => we can directly delete
1830 1831
	 *    the global entry, since it is useless now.
	 */
1832
	local_entry = batadv_tt_local_hash_find(bat_priv,
1833 1834
						tt_global_entry->common.addr,
						vid);
1835
	if (local_entry) {
1836
		/* local entry exists, case 2: client roamed to us. */
1837
		batadv_tt_global_del_orig_list(tt_global_entry);
1838
		batadv_tt_global_free(bat_priv, tt_global_entry, message);
1839 1840
	} else
		/* no local entry exists, case 1: check for roaming */
1841 1842
		batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
					     orig_node, message);
1843

1844
out:
1845
	if (tt_global_entry)
1846 1847 1848
		batadv_tt_global_entry_free_ref(tt_global_entry);
	if (local_entry)
		batadv_tt_local_entry_free_ref(local_entry);
1849 1850
}

1851 1852 1853 1854 1855 1856 1857 1858 1859
/**
 * 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"
 */
1860 1861
void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
			       struct batadv_orig_node *orig_node,
1862
			       s32 match_vid,
1863
			       const char *message)
1864
{
1865 1866
	struct batadv_tt_global_entry *tt_global;
	struct batadv_tt_common_entry *tt_common_entry;
1867
	u32 i;
1868
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1869
	struct hlist_node *safe;
1870
	struct hlist_head *head;
1871
	spinlock_t *list_lock; /* protects write access to the hash lists */
1872
	unsigned short vid;
1873

1874 1875 1876
	if (!hash)
		return;

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

1881
		spin_lock_bh(list_lock);
1882
		hlist_for_each_entry_safe(tt_common_entry, safe,
1883
					  head, hash_entry) {
1884 1885 1886 1887
			/* remove only matching entries */
			if (match_vid >= 0 && tt_common_entry->vid != match_vid)
				continue;

1888 1889 1890
			tt_global = container_of(tt_common_entry,
						 struct batadv_tt_global_entry,
						 common);
1891

1892 1893
			batadv_tt_global_del_orig_node(bat_priv, tt_global,
						       orig_node, message);
1894

1895
			if (hlist_empty(&tt_global->orig_list)) {
1896
				vid = tt_global->common.vid;
1897
				batadv_dbg(BATADV_DBG_TT, bat_priv,
1898 1899 1900
					   "Deleting global tt entry %pM (vid: %d): %s\n",
					   tt_global->common.addr,
					   BATADV_PRINT_VID(vid), message);
1901
				hlist_del_rcu(&tt_common_entry->hash_entry);
1902
				batadv_tt_global_entry_free_ref(tt_global);
1903
			}
1904
		}
1905
		spin_unlock_bh(list_lock);
1906
	}
1907
	clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
1908 1909
}

1910 1911
static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
				      char **msg)
1912
{
1913 1914 1915
	bool purge = false;
	unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
	unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;
1916

1917 1918 1919 1920 1921
	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";
	}
1922

1923 1924 1925 1926
	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";
1927
	}
1928 1929

	return purge;
1930 1931
}

1932
static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
1933
{
1934
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1935
	struct hlist_head *head;
1936
	struct hlist_node *node_tmp;
1937
	spinlock_t *list_lock; /* protects write access to the hash lists */
1938
	u32 i;
1939 1940 1941
	char *msg = NULL;
	struct batadv_tt_common_entry *tt_common;
	struct batadv_tt_global_entry *tt_global;
1942 1943 1944

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

1947
		spin_lock_bh(list_lock);
1948
		hlist_for_each_entry_safe(tt_common, node_tmp, head,
1949 1950 1951 1952 1953 1954 1955 1956 1957
					  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,
1958 1959 1960 1961
				   "Deleting global tt entry %pM (vid: %d): %s\n",
				   tt_global->common.addr,
				   BATADV_PRINT_VID(tt_global->common.vid),
				   msg);
1962

1963
			hlist_del_rcu(&tt_common->hash_entry);
1964 1965 1966

			batadv_tt_global_entry_free_ref(tt_global);
		}
1967
		spin_unlock_bh(list_lock);
1968 1969 1970
	}
}

1971
static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
1972
{
1973
	struct batadv_hashtable *hash;
1974
	spinlock_t *list_lock; /* protects write access to the hash lists */
1975 1976
	struct batadv_tt_common_entry *tt_common_entry;
	struct batadv_tt_global_entry *tt_global;
1977
	struct hlist_node *node_tmp;
1978
	struct hlist_head *head;
1979
	u32 i;
1980

1981
	if (!bat_priv->tt.global_hash)
1982 1983
		return;

1984
	hash = bat_priv->tt.global_hash;
1985 1986 1987 1988 1989 1990

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

		spin_lock_bh(list_lock);
1991
		hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1992
					  head, hash_entry) {
1993
			hlist_del_rcu(&tt_common_entry->hash_entry);
1994 1995 1996 1997
			tt_global = container_of(tt_common_entry,
						 struct batadv_tt_global_entry,
						 common);
			batadv_tt_global_entry_free_ref(tt_global);
1998 1999 2000 2001
		}
		spin_unlock_bh(list_lock);
	}

2002
	batadv_hash_destroy(hash);
2003

2004
	bat_priv->tt.global_hash = NULL;
2005 2006
}

2007 2008 2009
static bool
_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
		       struct batadv_tt_global_entry *tt_global_entry)
2010 2011 2012
{
	bool ret = false;

2013 2014
	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
	    tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
2015 2016
		ret = true;

2017 2018 2019 2020 2021
	/* 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;

2022 2023 2024
	return ret;
}

2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
/**
 * 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
 *
 * Returns a pointer to the originator that was selected as destination in the
 * 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.
 */
2039
struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
2040 2041
						  const u8 *src,
						  const u8 *addr,
2042
						  unsigned short vid)
2043
{
2044 2045 2046
	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;
2047
	struct batadv_tt_orig_list_entry *best_entry;
2048

2049
	if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {
2050
		tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);
2051 2052
		if (!tt_local_entry ||
		    (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))
2053 2054
			goto out;
	}
2055

2056
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2057
	if (!tt_global_entry)
2058
		goto out;
2059

2060
	/* check whether the clients should not communicate due to AP
2061 2062
	 * isolation
	 */
2063 2064
	if (tt_local_entry &&
	    _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
2065 2066
		goto out;

2067
	rcu_read_lock();
2068
	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
2069
	/* found anything? */
2070 2071
	if (best_entry)
		orig_node = best_entry->orig_node;
2072 2073 2074
	if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))
		orig_node = NULL;
	rcu_read_unlock();
2075

2076
out:
2077
	if (tt_global_entry)
2078
		batadv_tt_global_entry_free_ref(tt_global_entry);
2079
	if (tt_local_entry)
2080
		batadv_tt_local_entry_free_ref(tt_local_entry);
2081

2082
	return orig_node;
2083
}
2084

2085 2086 2087 2088
/**
 * 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
2089
 * @orig_node: originator for which the CRC should be computed
2090
 * @vid: VLAN identifier for which the CRC32 has to be computed
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107
 *
 * 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.
 *
 * Returns the checksum of the global table of a given originator.
2108
 */
2109 2110 2111
static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
				struct batadv_orig_node *orig_node,
				unsigned short vid)
2112
{
2113
	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2114 2115
	struct batadv_tt_common_entry *tt_common;
	struct batadv_tt_global_entry *tt_global;
2116
	struct hlist_head *head;
2117 2118
	u32 i, crc_tmp, crc = 0;
	u8 flags;
2119
	__be16 tmp_vid;
2120 2121 2122 2123 2124

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

		rcu_read_lock();
2125
		hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2126 2127 2128
			tt_global = container_of(tt_common,
						 struct batadv_tt_global_entry,
						 common);
2129 2130 2131 2132 2133 2134
			/* compute the CRC only for entries belonging to the
			 * VLAN identified by the vid passed as parameter
			 */
			if (tt_common->vid != vid)
				continue;

2135 2136 2137 2138 2139
			/* Roaming clients are in the global table for
			 * consistency only. They don't have to be
			 * taken into account while computing the
			 * global crc
			 */
2140
			if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
2141
				continue;
2142 2143 2144 2145 2146 2147
			/* 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;
2148 2149 2150 2151

			/* find out if this global entry is announced by this
			 * originator
			 */
2152
			if (!batadv_tt_global_entry_has_orig(tt_global,
2153
							     orig_node))
2154 2155
				continue;

2156 2157 2158 2159 2160
			/* 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));
2161 2162 2163 2164 2165 2166 2167

			/* 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));

2168
			crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2169 2170 2171 2172
		}
		rcu_read_unlock();
	}

2173
	return crc;
2174 2175
}

2176 2177 2178
/**
 * batadv_tt_local_crc - calculates the checksum of the local table
 * @bat_priv: the bat priv with all the soft interface information
2179
 * @vid: VLAN identifier for which the CRC32 has to be computed
2180 2181 2182 2183 2184
 *
 * For details about the computation, please refer to the documentation for
 * batadv_tt_global_crc().
 *
 * Returns the checksum of the local table
2185
 */
2186 2187
static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,
			       unsigned short vid)
2188
{
2189
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
2190
	struct batadv_tt_common_entry *tt_common;
2191
	struct hlist_head *head;
2192 2193
	u32 i, crc_tmp, crc = 0;
	u8 flags;
2194
	__be16 tmp_vid;
2195 2196 2197 2198 2199

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

		rcu_read_lock();
2200
		hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2201 2202 2203 2204 2205 2206
			/* compute the CRC only for entries belonging to the
			 * VLAN identified by vid
			 */
			if (tt_common->vid != vid)
				continue;

2207
			/* not yet committed clients have not to be taken into
2208 2209
			 * account while computing the CRC
			 */
2210
			if (tt_common->flags & BATADV_TT_CLIENT_NEW)
2211
				continue;
2212

2213 2214 2215 2216 2217
			/* 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));
2218 2219 2220 2221 2222 2223 2224

			/* 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));

2225
			crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2226 2227 2228 2229
		}
		rcu_read_unlock();
	}

2230
	return crc;
2231 2232
}

2233
static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
2234
{
2235 2236
	struct batadv_tt_req_node *node;
	struct hlist_node *safe;
2237

2238
	spin_lock_bh(&bat_priv->tt.req_list_lock);
2239

2240 2241
	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
		hlist_del_init(&node->list);
2242 2243 2244
		kfree(node);
	}

2245
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2246 2247
}

2248 2249
static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
				       struct batadv_orig_node *orig_node,
2250
				       const void *tt_buff,
2251
				       u16 tt_buff_len)
2252 2253
{
	/* Replace the old buffer only if I received something in the
2254 2255
	 * last OGM (the OGM could carry no changes)
	 */
2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
	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);
}

2269
static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
2270
{
2271 2272
	struct batadv_tt_req_node *node;
	struct hlist_node *safe;
2273

2274
	spin_lock_bh(&bat_priv->tt.req_list_lock);
2275
	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2276 2277
		if (batadv_has_timed_out(node->issued_at,
					 BATADV_TT_REQUEST_TIMEOUT)) {
2278
			hlist_del_init(&node->list);
2279 2280 2281
			kfree(node);
		}
	}
2282
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2283 2284
}

2285 2286 2287 2288 2289 2290 2291
/**
 * 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
 *
 * Returns the pointer to the new tt_req_node struct if no request
 * has already been issued for this orig_node, NULL otherwise.
2292
 */
2293
static struct batadv_tt_req_node *
2294
batadv_tt_req_node_new(struct batadv_priv *bat_priv,
2295
		       struct batadv_orig_node *orig_node)
2296
{
2297
	struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
2298

2299
	spin_lock_bh(&bat_priv->tt.req_list_lock);
2300
	hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
2301 2302
		if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
		    !batadv_has_timed_out(tt_req_node_tmp->issued_at,
2303
					  BATADV_TT_REQUEST_TIMEOUT))
2304 2305 2306 2307 2308 2309 2310
			goto unlock;
	}

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

2311
	ether_addr_copy(tt_req_node->addr, orig_node->orig);
2312 2313
	tt_req_node->issued_at = jiffies;

2314
	hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list);
2315
unlock:
2316
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2317 2318 2319
	return tt_req_node;
}

2320 2321 2322 2323 2324 2325 2326 2327
/**
 * 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
 *
 * Returns 1 if the entry is a valid, 0 otherwise.
 */
static int batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)
2328
{
2329
	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2330

2331
	if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
2332 2333 2334 2335
		return 0;
	return 1;
}

2336 2337
static int batadv_tt_global_valid(const void *entry_ptr,
				  const void *data_ptr)
2338
{
2339 2340 2341
	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;
2342

2343 2344
	if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
	    tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
2345 2346
		return 0;

2347 2348
	tt_global_entry = container_of(tt_common_entry,
				       struct batadv_tt_global_entry,
2349 2350
				       common);

2351
	return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);
2352 2353
}

2354
/**
2355 2356
 * batadv_tt_tvlv_generate - fill the tvlv buff with the tt entries from the
 *  specified tt hash
2357 2358 2359
 * @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
2360
 * @tvlv_buff: pointer to the buffer to fill with the TT data
2361 2362 2363
 * @valid_cb: function to filter tt change entries
 * @cb_data: data passed to the filter function as argument
 */
2364 2365
static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
				    struct batadv_hashtable *hash,
2366
				    void *tvlv_buff, u16 tt_len,
2367 2368
				    int (*valid_cb)(const void *, const void *),
				    void *cb_data)
2369
{
2370
	struct batadv_tt_common_entry *tt_common_entry;
2371
	struct batadv_tvlv_tt_change *tt_change;
2372
	struct hlist_head *head;
2373 2374
	u16 tt_tot, tt_num_entries = 0;
	u32 i;
2375

2376
	tt_tot = batadv_tt_entries(tt_len);
2377
	tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;
2378 2379 2380 2381 2382

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

2383
		hlist_for_each_entry_rcu(tt_common_entry,
2384
					 head, hash_entry) {
2385
			if (tt_tot == tt_num_entries)
2386 2387
				break;

2388
			if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
2389 2390
				continue;

2391
			ether_addr_copy(tt_change->addr, tt_common_entry->addr);
2392
			tt_change->flags = tt_common_entry->flags;
2393
			tt_change->vid = htons(tt_common_entry->vid);
2394 2395
			memset(tt_change->reserved, 0,
			       sizeof(tt_change->reserved));
2396

2397
			tt_num_entries++;
2398 2399 2400 2401
			tt_change++;
		}
	}
	rcu_read_unlock();
2402
}
2403

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
/**
 * 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
 * @create: if true, create VLAN objects if not found
 *
 * Return true if all the received CRCs match the locally stored ones, false
 * otherwise
 */
static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,
				       struct batadv_tvlv_tt_vlan_data *tt_vlan,
2416
				       u16 num_vlan)
2417 2418 2419
{
	struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;
	struct batadv_orig_node_vlan *vlan;
2420
	u32 crc;
2421 2422 2423 2424 2425 2426 2427 2428 2429 2430
	int i;

	/* 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,
2431 2432
						   orig_node->orig,
						   ntohs(tt_vlan_tmp->vid)))
2433 2434 2435 2436 2437 2438 2439
			continue;

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

2440 2441 2442 2443
		crc = vlan->tt.crc;
		batadv_orig_node_vlan_free_ref(vlan);

		if (crc != ntohl(tt_vlan_tmp->crc))
2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
			return false;
	}

	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;
2475
	u32 crc;
2476 2477 2478

	/* recompute the global CRC for each VLAN */
	rcu_read_lock();
2479
	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
2480 2481 2482
		/* if orig_node is a backbone node for this VLAN, don't compute
		 * the CRC as we ignore all the global entries over it
		 */
2483 2484
		if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
						   vlan->vid))
2485 2486 2487 2488 2489 2490
			continue;

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

2493 2494 2495 2496 2497
/**
 * 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
2498 2499
 * @tt_vlan: pointer to the first tvlv VLAN object to request
 * @num_vlan: number of tvlv VLAN entries
2500 2501 2502
 * @full_table: ask for the entire translation table if true, while only for the
 *  last TT diff otherwise
 */
2503 2504
static int batadv_send_tt_request(struct batadv_priv *bat_priv,
				  struct batadv_orig_node *dst_orig_node,
2505
				  u8 ttvn,
2506
				  struct batadv_tvlv_tt_vlan_data *tt_vlan,
2507
				  u16 num_vlan, bool full_table)
2508
{
2509
	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2510
	struct batadv_tt_req_node *tt_req_node = NULL;
2511 2512
	struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
	struct batadv_hard_iface *primary_if;
2513
	bool ret = false;
2514
	int i, size;
2515

2516
	primary_if = batadv_primary_if_get_selected(bat_priv);
2517 2518 2519 2520
	if (!primary_if)
		goto out;

	/* The new tt_req will be issued only if I'm not waiting for a
2521 2522
	 * reply from the same orig_node yet
	 */
2523
	tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);
2524 2525 2526
	if (!tt_req_node)
		goto out;

2527 2528
	size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
	tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
2529
	if (!tvlv_tt_data)
2530 2531
		goto out;

2532 2533
	tvlv_tt_data->flags = BATADV_TT_REQUEST;
	tvlv_tt_data->ttvn = ttvn;
2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546
	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++;
	}
2547 2548

	if (full_table)
2549
		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2550

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

2554
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
2555 2556
	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
				 dst_orig_node->orig, BATADV_TVLV_TT, 1,
2557
				 tvlv_tt_data, size);
2558
	ret = true;
2559 2560 2561

out:
	if (primary_if)
2562
		batadv_hardif_free_ref(primary_if);
2563
	if (ret && tt_req_node) {
2564
		spin_lock_bh(&bat_priv->tt.req_list_lock);
2565 2566
		/* hlist_del_init() verifies tt_req_node still is in the list */
		hlist_del_init(&tt_req_node->list);
2567
		spin_unlock_bh(&bat_priv->tt.req_list_lock);
2568 2569
		kfree(tt_req_node);
	}
2570
	kfree(tvlv_tt_data);
2571 2572 2573
	return ret;
}

2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585
/**
 * 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
 *
 * Returns true if tt request reply was sent, false otherwise.
 */
static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
					  struct batadv_tvlv_tt_data *tt_data,
2586
					  u8 *req_src, u8 *req_dst)
2587
{
2588
	struct batadv_orig_node *req_dst_orig_node;
2589
	struct batadv_orig_node *res_dst_orig_node = NULL;
2590
	struct batadv_tvlv_tt_change *tt_change;
2591
	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2592
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
2593
	bool ret = false, full_table;
2594 2595 2596
	u8 orig_ttvn, req_ttvn;
	u16 tvlv_len;
	s32 tt_len;
2597

2598
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2599
		   "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
2600
		   req_src, tt_data->ttvn, req_dst,
2601
		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2602 2603

	/* Let's get the orig node of the REAL destination */
2604
	req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
2605 2606 2607
	if (!req_dst_orig_node)
		goto out;

2608
	res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
2609 2610 2611
	if (!res_dst_orig_node)
		goto out;

2612
	orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);
2613
	req_ttvn = tt_data->ttvn;
2614

2615
	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
2616
	/* this node doesn't have the requested data */
2617
	if (orig_ttvn != req_ttvn ||
2618 2619
	    !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
					ntohs(tt_data->num_vlan)))
2620 2621
		goto out;

2622
	/* If the full table has been explicitly requested */
2623
	if (tt_data->flags & BATADV_TT_FULL_TABLE ||
2624 2625 2626 2627 2628
	    !req_dst_orig_node->tt_buff)
		full_table = true;
	else
		full_table = false;

2629 2630
	/* TT fragmentation hasn't been implemented yet, so send as many
	 * TT entries fit a single packet as possible only
2631
	 */
2632 2633 2634 2635
	if (!full_table) {
		spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
		tt_len = req_dst_orig_node->tt_buff_len;

2636 2637 2638 2639 2640
		tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
							      &tvlv_tt_data,
							      &tt_change,
							      &tt_len);
		if (!tt_len)
2641 2642 2643
			goto unlock;

		/* Copy the last orig_node's OGM buffer */
2644
		memcpy(tt_change, req_dst_orig_node->tt_buff,
2645 2646 2647
		       req_dst_orig_node->tt_buff_len);
		spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
	} else {
2648 2649 2650 2651 2652 2653 2654 2655 2656
		/* 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)
2657
			goto out;
2658 2659 2660 2661 2662 2663

		/* 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);
2664 2665
	}

2666 2667 2668 2669 2670 2671 2672 2673 2674
	/* 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;
	}

2675 2676
	tvlv_tt_data->flags = BATADV_TT_RESPONSE;
	tvlv_tt_data->ttvn = req_ttvn;
2677 2678

	if (full_table)
2679
		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2680

2681
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2682 2683 2684
		   "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);
2685

2686
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2687

2688
	batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
2689 2690
				 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
				 tvlv_len);
2691

2692
	ret = true;
2693 2694 2695 2696 2697 2698 2699
	goto out;

unlock:
	spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);

out:
	if (res_dst_orig_node)
2700
		batadv_orig_node_free_ref(res_dst_orig_node);
2701
	if (req_dst_orig_node)
2702
		batadv_orig_node_free_ref(req_dst_orig_node);
2703
	kfree(tvlv_tt_data);
2704 2705
	return ret;
}
2706

2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717
/**
 * 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
 *
 * Returns true if tt request reply was sent, false otherwise.
 */
static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
				       struct batadv_tvlv_tt_data *tt_data,
2718
				       u8 *req_src)
2719
{
2720
	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2721
	struct batadv_hard_iface *primary_if = NULL;
2722 2723
	struct batadv_tvlv_tt_change *tt_change;
	struct batadv_orig_node *orig_node;
2724 2725
	u8 my_ttvn, req_ttvn;
	u16 tvlv_len;
2726
	bool full_table;
2727
	s32 tt_len;
2728

2729
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2730
		   "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
2731
		   req_src, tt_data->ttvn,
2732
		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2733

2734
	spin_lock_bh(&bat_priv->tt.commit_lock);
2735

2736
	my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2737
	req_ttvn = tt_data->ttvn;
2738

2739
	orig_node = batadv_orig_hash_find(bat_priv, req_src);
2740 2741 2742
	if (!orig_node)
		goto out;

2743
	primary_if = batadv_primary_if_get_selected(bat_priv);
2744 2745 2746 2747
	if (!primary_if)
		goto out;

	/* If the full table has been explicitly requested or the gap
2748 2749
	 * is too big send the whole local translation table
	 */
2750
	if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
2751
	    !bat_priv->tt.last_changeset)
2752 2753 2754 2755
		full_table = true;
	else
		full_table = false;

2756 2757
	/* TT fragmentation hasn't been implemented yet, so send as many
	 * TT entries fit a single packet as possible only
2758
	 */
2759
	if (!full_table) {
2760
		spin_lock_bh(&bat_priv->tt.last_changeset_lock);
2761

2762 2763 2764 2765 2766 2767
		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)
2768 2769
			goto unlock;

2770
		/* Copy the last orig_node's OGM buffer */
2771
		memcpy(tt_change, bat_priv->tt.last_changeset,
2772 2773
		       bat_priv->tt.last_changeset_len);
		spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2774
	} else {
2775
		req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2776

2777 2778 2779 2780 2781 2782 2783 2784 2785
		/* 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)
2786
			goto out;
2787 2788 2789 2790 2791

		/* 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);
2792 2793
	}

2794 2795
	tvlv_tt_data->flags = BATADV_TT_RESPONSE;
	tvlv_tt_data->ttvn = req_ttvn;
2796 2797

	if (full_table)
2798
		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2799

2800
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2801 2802
		   "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
		   orig_node->orig, full_table ? 'F' : '.', req_ttvn);
2803

2804
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2805

2806
	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2807 2808
				 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
				 tvlv_len);
2809

2810 2811 2812
	goto out;

unlock:
2813
	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2814
out:
2815
	spin_unlock_bh(&bat_priv->tt.commit_lock);
2816
	if (orig_node)
2817
		batadv_orig_node_free_ref(orig_node);
2818
	if (primary_if)
2819
		batadv_hardif_free_ref(primary_if);
2820 2821
	kfree(tvlv_tt_data);
	/* The packet was for this host, so it doesn't need to be re-routed */
2822 2823 2824
	return true;
}

2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835
/**
 * 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
 *
 * Returns true if tt request reply was sent, false otherwise.
 */
static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
				    struct batadv_tvlv_tt_data *tt_data,
2836
				    u8 *req_src, u8 *req_dst)
2837
{
2838
	if (batadv_is_my_mac(bat_priv, req_dst))
2839
		return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
2840 2841
	return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
					     req_dst);
2842 2843
}

2844 2845
static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
				      struct batadv_orig_node *orig_node,
2846
				      struct batadv_tvlv_tt_change *tt_change,
2847
				      u16 tt_num_changes, u8 ttvn)
2848 2849
{
	int i;
2850
	int roams;
2851 2852

	for (i = 0; i < tt_num_changes; i++) {
2853 2854
		if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
			roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
2855 2856
			batadv_tt_global_del(bat_priv, orig_node,
					     (tt_change + i)->addr,
2857
					     ntohs((tt_change + i)->vid),
2858 2859
					     "tt removed by changes",
					     roams);
2860 2861
		} else {
			if (!batadv_tt_global_add(bat_priv, orig_node,
2862
						  (tt_change + i)->addr,
2863
						  ntohs((tt_change + i)->vid),
2864
						  (tt_change + i)->flags, ttvn))
2865 2866 2867 2868 2869 2870 2871
				/* 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;
2872
		}
2873
	}
2874
	set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
2875 2876
}

2877
static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
2878
				  struct batadv_tvlv_tt_change *tt_change,
2879 2880
				  u8 ttvn, u8 *resp_src,
				  u16 num_entries)
2881
{
2882
	struct batadv_orig_node *orig_node;
2883

2884
	orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2885 2886 2887 2888
	if (!orig_node)
		goto out;

	/* Purge the old table first.. */
2889 2890
	batadv_tt_global_del_orig(bat_priv, orig_node, -1,
				  "Received full table");
2891

2892 2893
	_batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
				  ttvn);
2894 2895 2896 2897 2898 2899 2900

	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);

2901
	atomic_set(&orig_node->last_ttvn, ttvn);
2902 2903 2904

out:
	if (orig_node)
2905
		batadv_orig_node_free_ref(orig_node);
2906 2907
}

2908 2909
static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
				     struct batadv_orig_node *orig_node,
2910
				     u16 tt_num_changes, u8 ttvn,
2911
				     struct batadv_tvlv_tt_change *tt_change)
2912
{
2913 2914
	_batadv_tt_update_changes(bat_priv, orig_node, tt_change,
				  tt_num_changes, ttvn);
2915

2916 2917
	batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
				   batadv_tt_len(tt_num_changes));
2918 2919 2920
	atomic_set(&orig_node->last_ttvn, ttvn);
}

2921 2922 2923
/**
 * 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
2924
 * @addr: the mac address of the client to check
2925 2926 2927 2928
 * @vid: VLAN identifier
 *
 * Returns true if the client is served by this node, false otherwise.
 */
2929
bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,
2930
			 unsigned short vid)
2931
{
2932
	struct batadv_tt_local_entry *tt_local_entry;
2933
	bool ret = false;
2934

2935
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
2936 2937
	if (!tt_local_entry)
		goto out;
2938
	/* Check if the client has been logically deleted (but is kept for
2939 2940
	 * consistency purpose)
	 */
2941 2942
	if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
	    (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
2943
		goto out;
2944 2945
	ret = true;
out:
2946
	if (tt_local_entry)
2947
		batadv_tt_local_entry_free_ref(tt_local_entry);
2948
	return ret;
2949 2950
}

2951 2952 2953 2954 2955 2956 2957 2958 2959
/**
 * 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,
2960
				      u8 *resp_src, u16 num_entries)
2961
{
2962 2963
	struct batadv_tt_req_node *node;
	struct hlist_node *safe;
2964
	struct batadv_orig_node *orig_node = NULL;
2965
	struct batadv_tvlv_tt_change *tt_change;
2966 2967
	u8 *tvlv_ptr = (u8 *)tt_data;
	u16 change_offset;
2968

2969
	batadv_dbg(BATADV_DBG_TT, bat_priv,
2970
		   "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
2971
		   resp_src, tt_data->ttvn, num_entries,
2972
		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2973

2974
	orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2975 2976 2977
	if (!orig_node)
		goto out;

2978 2979
	spin_lock_bh(&orig_node->tt_lock);

2980 2981 2982 2983 2984 2985
	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;
2986
	if (tt_data->flags & BATADV_TT_FULL_TABLE) {
2987 2988
		batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
				      resp_src, num_entries);
2989
	} else {
2990 2991
		batadv_tt_update_changes(bat_priv, orig_node, num_entries,
					 tt_data->ttvn, tt_change);
2992
	}
2993

2994
	/* Recalculate the CRC for this orig_node and store it */
2995
	batadv_tt_global_update_crc(bat_priv, orig_node);
2996 2997 2998

	spin_unlock_bh(&orig_node->tt_lock);

2999
	/* Delete the tt_req_node from pending tt_requests list */
3000
	spin_lock_bh(&bat_priv->tt.req_list_lock);
3001
	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
3002
		if (!batadv_compare_eth(node->addr, resp_src))
3003
			continue;
3004
		hlist_del_init(&node->list);
3005 3006
		kfree(node);
	}
3007

3008
	spin_unlock_bh(&bat_priv->tt.req_list_lock);
3009 3010
out:
	if (orig_node)
3011
		batadv_orig_node_free_ref(orig_node);
3012 3013
}

3014
static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
3015
{
3016
	struct batadv_tt_roam_node *node, *safe;
3017

3018
	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3019

3020
	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3021 3022 3023 3024
		list_del(&node->list);
		kfree(node);
	}

3025
	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3026 3027
}

3028
static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
3029
{
3030
	struct batadv_tt_roam_node *node, *safe;
3031

3032 3033
	spin_lock_bh(&bat_priv->tt.roam_list_lock);
	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3034 3035
		if (!batadv_has_timed_out(node->first_time,
					  BATADV_ROAMING_MAX_TIME))
3036 3037 3038 3039 3040
			continue;

		list_del(&node->list);
		kfree(node);
	}
3041
	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3042 3043 3044 3045 3046 3047
}

/* This function checks whether the client already reached the
 * maximum number of possible roaming phases. In this case the ROAMING_ADV
 * will not be sent.
 *
3048 3049
 * returns true if the ROAMING_ADV can be sent, false otherwise
 */
3050
static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)
3051
{
3052
	struct batadv_tt_roam_node *tt_roam_node;
3053 3054
	bool ret = false;

3055
	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3056
	/* The new tt_req will be issued only if I'm not waiting for a
3057 3058
	 * reply from the same orig_node yet
	 */
3059
	list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
3060
		if (!batadv_compare_eth(tt_roam_node->addr, client))
3061 3062
			continue;

3063
		if (batadv_has_timed_out(tt_roam_node->first_time,
3064
					 BATADV_ROAMING_MAX_TIME))
3065 3066
			continue;

3067
		if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
			/* 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;
3080 3081
		atomic_set(&tt_roam_node->counter,
			   BATADV_ROAMING_MAX_COUNT - 1);
3082
		ether_addr_copy(tt_roam_node->addr, client);
3083

3084
		list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3085 3086 3087 3088
		ret = true;
	}

unlock:
3089
	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3090 3091 3092
	return ret;
}

3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
/**
 * 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.
 */
3105
static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
3106
				 unsigned short vid,
3107
				 struct batadv_orig_node *orig_node)
3108
{
3109
	struct batadv_hard_iface *primary_if;
3110 3111 3112 3113 3114
	struct batadv_tvlv_roam_adv tvlv_roam;

	primary_if = batadv_primary_if_get_selected(bat_priv);
	if (!primary_if)
		goto out;
3115 3116

	/* before going on we have to check whether the client has
3117 3118
	 * already roamed to us too many times
	 */
3119
	if (!batadv_tt_check_roam_count(bat_priv, client))
3120 3121
		goto out;

3122
	batadv_dbg(BATADV_DBG_TT, bat_priv,
3123 3124
		   "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
		   orig_node->orig, client, BATADV_PRINT_VID(vid));
3125

3126
	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3127

3128
	memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3129
	tvlv_roam.vid = htons(vid);
3130 3131 3132 3133

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

out:
3136 3137
	if (primary_if)
		batadv_hardif_free_ref(primary_if);
3138 3139
}

3140
static void batadv_tt_purge(struct work_struct *work)
3141
{
3142
	struct delayed_work *delayed_work;
3143
	struct batadv_priv_tt *priv_tt;
3144 3145 3146
	struct batadv_priv *bat_priv;

	delayed_work = container_of(work, struct delayed_work, work);
3147 3148
	priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
	bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3149

3150
	batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3151
	batadv_tt_global_purge(bat_priv);
3152 3153
	batadv_tt_req_purge(bat_priv);
	batadv_tt_roam_purge(bat_priv);
3154

3155 3156
	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
			   msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3157
}
3158

3159
void batadv_tt_free(struct batadv_priv *bat_priv)
3160
{
3161 3162 3163
	batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);

3164
	cancel_delayed_work_sync(&bat_priv->tt.work);
3165

3166 3167 3168 3169 3170
	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);
3171

3172
	kfree(bat_priv->tt.last_changeset);
3173
}
3174

3175 3176 3177 3178 3179 3180 3181
/**
 * 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
3182
 */
3183 3184
static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,
				      bool enable, bool count)
3185
{
3186 3187
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
	struct batadv_tt_common_entry *tt_common_entry;
3188
	u16 changed_num = 0;
3189
	struct hlist_head *head;
3190
	u32 i;
3191 3192

	if (!hash)
3193
		return;
3194 3195 3196 3197 3198

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

		rcu_read_lock();
3199
		hlist_for_each_entry_rcu(tt_common_entry,
3200
					 head, hash_entry) {
3201 3202 3203 3204 3205 3206 3207 3208 3209 3210
			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++;
3211 3212 3213 3214 3215 3216

			if (!count)
				continue;

			batadv_tt_local_size_inc(bat_priv,
						 tt_common_entry->vid);
3217 3218 3219 3220 3221
		}
		rcu_read_unlock();
	}
}

3222
/* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
3223
static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3224
{
3225
	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3226 3227
	struct batadv_tt_common_entry *tt_common;
	struct batadv_tt_local_entry *tt_local;
3228
	struct batadv_softif_vlan *vlan;
3229
	struct hlist_node *node_tmp;
3230 3231
	struct hlist_head *head;
	spinlock_t *list_lock; /* protects write access to the hash lists */
3232
	u32 i;
3233 3234 3235 3236 3237 3238 3239 3240 3241

	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);
3242
		hlist_for_each_entry_safe(tt_common, node_tmp, head,
3243 3244
					  hash_entry) {
			if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3245 3246
				continue;

3247
			batadv_dbg(BATADV_DBG_TT, bat_priv,
3248 3249 3250
				   "Deleting local tt entry (%pM, vid: %d): pending\n",
				   tt_common->addr,
				   BATADV_PRINT_VID(tt_common->vid));
3251

3252
			batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3253
			hlist_del_rcu(&tt_common->hash_entry);
3254 3255 3256
			tt_local = container_of(tt_common,
						struct batadv_tt_local_entry,
						common);
3257 3258 3259

			/* decrease the reference held for this vlan */
			vlan = batadv_softif_vlan_get(bat_priv, tt_common->vid);
3260 3261 3262 3263
			if (vlan) {
				batadv_softif_vlan_free_ref(vlan);
				batadv_softif_vlan_free_ref(vlan);
			}
3264

3265
			batadv_tt_local_entry_free_ref(tt_local);
3266 3267 3268 3269 3270
		}
		spin_unlock_bh(list_lock);
	}
}

3271
/**
3272 3273
 * batadv_tt_local_commit_changes_nolock - commit all pending local tt changes
 *  which have been queued in the time since the last commit
3274
 * @bat_priv: the bat priv with all the soft interface information
3275 3276
 *
 * Caller must hold tt->commit_lock.
3277
 */
3278
static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3279
{
3280 3281
	lockdep_assert_held(&bat_priv->tt.commit_lock);

3282 3283 3284
	/* Update multicast addresses in local translation table */
	batadv_mcast_mla_update(bat_priv);

3285 3286 3287
	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);
3288
		return;
3289
	}
3290

3291
	batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3292

3293
	batadv_tt_local_purge_pending_clients(bat_priv);
3294
	batadv_tt_local_update_crc(bat_priv);
3295 3296

	/* Increment the TTVN only once per OGM interval */
3297
	atomic_inc(&bat_priv->tt.vn);
3298
	batadv_dbg(BATADV_DBG_TT, bat_priv,
3299
		   "Local changes committed, updating to ttvn %u\n",
3300
		   (u8)atomic_read(&bat_priv->tt.vn));
3301 3302

	/* reset the sending counter */
3303
	atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3304
	batadv_tt_tvlv_container_update(bat_priv);
3305
}
3306

3307 3308 3309 3310 3311 3312 3313 3314 3315
/**
 * 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);
3316
	spin_unlock_bh(&bat_priv->tt.commit_lock);
3317
}
3318

3319 3320
bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,
			   unsigned short vid)
3321
{
3322 3323
	struct batadv_tt_local_entry *tt_local_entry = NULL;
	struct batadv_tt_global_entry *tt_global_entry = NULL;
3324
	struct batadv_softif_vlan *vlan;
3325
	bool ret = false;
3326

3327 3328
	vlan = batadv_softif_vlan_get(bat_priv, vid);
	if (!vlan || !atomic_read(&vlan->ap_isolation))
3329
		goto out;
3330

3331
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3332 3333 3334
	if (!tt_local_entry)
		goto out;

3335
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3336 3337 3338
	if (!tt_global_entry)
		goto out;

3339
	if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3340 3341
		goto out;

3342
	ret = true;
3343 3344

out:
3345 3346
	if (vlan)
		batadv_softif_vlan_free_ref(vlan);
3347
	if (tt_global_entry)
3348
		batadv_tt_global_entry_free_ref(tt_global_entry);
3349
	if (tt_local_entry)
3350
		batadv_tt_local_entry_free_ref(tt_local_entry);
3351 3352
	return ret;
}
3353

3354 3355 3356 3357 3358
/**
 * 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
 * @orig: the orig_node of the ogm
3359 3360 3361
 * @tt_vlan: pointer to the first tvlv VLAN entry
 * @tt_num_vlan: number of tvlv VLAN entries
 * @tt_change: pointer to the first entry in the TT buffer
3362 3363
 * @tt_num_changes: number of tt changes inside the tt buffer
 * @ttvn: translation table version number of this changeset
3364
 * @tt_crc: crc32 checksum of orig node's translation table
3365 3366 3367
 */
static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
				  struct batadv_orig_node *orig_node,
3368
				  const void *tt_buff, u16 tt_num_vlan,
3369
				  struct batadv_tvlv_tt_change *tt_change,
3370
				  u16 tt_num_changes, u8 ttvn)
3371
{
3372
	u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
3373
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
3374
	bool full_table = true;
3375
	bool has_tt_init;
3376

3377
	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
3378 3379
	has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,
			       &orig_node->capa_initialized);
3380

3381
	/* orig table not initialised AND first diff is in the OGM OR the ttvn
3382 3383
	 * increased by one -> we can apply the attached changes
	 */
3384
	if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
3385
		/* the OGM could not contain the changes due to their size or
3386 3387
		 * because they have already been sent BATADV_TT_OGM_APPEND_MAX
		 * times.
3388 3389
		 * In this case send a tt request
		 */
3390 3391 3392 3393 3394
		if (!tt_num_changes) {
			full_table = false;
			goto request_table;
		}

3395 3396
		spin_lock_bh(&orig_node->tt_lock);

3397
		batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
3398
					 ttvn, tt_change);
3399 3400 3401

		/* Even if we received the precomputed crc with the OGM, we
		 * prefer to recompute it to spot any possible inconsistency
3402 3403
		 * in the global table
		 */
3404
		batadv_tt_global_update_crc(bat_priv, orig_node);
3405

3406 3407
		spin_unlock_bh(&orig_node->tt_lock);

3408 3409 3410 3411 3412 3413 3414
		/* 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
3415 3416
		 * inconsistency
		 */
3417 3418
		if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
						tt_num_vlan))
3419 3420 3421
			goto request_table;
	} else {
		/* if we missed more than one change or our tables are not
3422 3423
		 * in sync anymore -> request fresh tt data
		 */
3424
		if (!has_tt_init || ttvn != orig_ttvn ||
3425 3426
		    !batadv_tt_global_check_crc(orig_node, tt_vlan,
						tt_num_vlan)) {
3427
request_table:
3428
			batadv_dbg(BATADV_DBG_TT, bat_priv,
3429 3430 3431
				   "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);
3432
			batadv_send_tt_request(bat_priv, orig_node, ttvn,
3433 3434
					       tt_vlan, tt_num_vlan,
					       full_table);
3435 3436 3437 3438
			return;
		}
	}
}
3439

3440 3441 3442 3443 3444 3445 3446 3447 3448
/**
 * 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
 *
 * Returns true if we know that the client has moved from its old originator
 * to another one. This entry is still kept for consistency purposes and will be
 * deleted later by a DEL or because of timeout
3449
 */
3450
bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
3451
					u8 *addr, unsigned short vid)
3452
{
3453
	struct batadv_tt_global_entry *tt_global_entry;
3454 3455
	bool ret = false;

3456
	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
3457 3458 3459
	if (!tt_global_entry)
		goto out;

3460
	ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3461
	batadv_tt_global_entry_free_ref(tt_global_entry);
3462 3463 3464
out:
	return ret;
}
3465

3466 3467 3468
/**
 * batadv_tt_local_client_is_roaming - tells whether the client is roaming
 * @bat_priv: the bat priv with all the soft interface information
3469 3470
 * @addr: the mac address of the local client to query
 * @vid: VLAN identifier
3471 3472 3473 3474 3475 3476
 *
 * Returns true if the local client is known to be roaming (it is not served by
 * 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,
3477
				       u8 *addr, unsigned short vid)
3478 3479 3480 3481
{
	struct batadv_tt_local_entry *tt_local_entry;
	bool ret = false;

3482
	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3483 3484 3485 3486 3487 3488 3489 3490 3491
	if (!tt_local_entry)
		goto out;

	ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
	batadv_tt_local_entry_free_ref(tt_local_entry);
out:
	return ret;
}

3492 3493
bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
					  struct batadv_orig_node *orig_node,
3494
					  const unsigned char *addr,
3495
					  unsigned short vid)
3496 3497 3498
{
	bool ret = false;

3499
	if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
3500 3501 3502 3503 3504
				  BATADV_TT_CLIENT_TEMP,
				  atomic_read(&orig_node->last_ttvn)))
		goto out;

	batadv_dbg(BATADV_DBG_TT, bat_priv,
3505 3506
		   "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
		   addr, BATADV_PRINT_VID(vid), orig_node->orig);
3507 3508 3509 3510
	ret = true;
out:
	return ret;
}
3511

3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552
/**
 * 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);
}

3553 3554 3555 3556 3557 3558 3559 3560 3561 3562
/**
 * 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,
3563 3564
					  u8 flags, void *tvlv_value,
					  u16 tvlv_value_len)
3565
{
3566 3567
	struct batadv_tvlv_tt_vlan_data *tt_vlan;
	struct batadv_tvlv_tt_change *tt_change;
3568
	struct batadv_tvlv_tt_data *tt_data;
3569
	u16 num_entries, num_vlan;
3570 3571 3572 3573 3574 3575 3576

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

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

3577 3578 3579 3580 3581 3582 3583 3584 3585
	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;

3586
	num_entries = batadv_tt_entries(tvlv_value_len);
3587

3588 3589
	batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
			      num_entries, tt_data->ttvn);
3590 3591
}

3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604
/**
 * 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
 *
 * Returns NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS
 * otherwise.
 */
static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3605
					     u8 *src, u8 *dst,
3606
					     void *tvlv_value,
3607
					     u16 tvlv_value_len)
3608 3609
{
	struct batadv_tvlv_tt_data *tt_data;
3610
	u16 tt_vlan_len, tt_num_entries;
3611 3612 3613 3614 3615 3616 3617 3618 3619
	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);

3620 3621 3622 3623 3624 3625 3626 3627
	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);
3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654

	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,
3655
						  src, tt_num_entries);
3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673
			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;
}

3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
/**
 * 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
 *
 * Returns NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS
 * otherwise.
 */
static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3686
					       u8 *src, u8 *dst,
3687
					       void *tvlv_value,
3688
					       u16 tvlv_value_len)
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714
{
	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,
3715
			     ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
3716 3717 3718 3719 3720 3721 3722 3723
			     atomic_read(&orig_node->last_ttvn) + 1);

out:
	if (orig_node)
		batadv_orig_node_free_ref(orig_node);
	return NET_RX_SUCCESS;
}

3724 3725 3726 3727 3728 3729 3730 3731 3732 3733
/**
 * batadv_tt_init - initialise the translation table internals
 * @bat_priv: the bat priv with all the soft interface information
 *
 * Return 0 on success or negative error number in case of failure.
 */
int batadv_tt_init(struct batadv_priv *bat_priv)
{
	int ret;

3734 3735 3736
	/* synchronized flags must be remote */
	BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));

3737 3738 3739 3740 3741 3742 3743 3744 3745
	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,
3746 3747
				     batadv_tt_tvlv_unicast_handler_v1,
				     BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
3748

3749 3750 3751 3752
	batadv_tvlv_handler_register(bat_priv, NULL,
				     batadv_roam_tvlv_unicast_handler_v1,
				     BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);

3753 3754 3755 3756 3757 3758
	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;
}
3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769

/**
 * 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
 *
 * Returns true if the client is marked with the TT_CLIENT_ISOLA flag, false
 * otherwise
 */
bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
3770
				  const u8 *addr, unsigned short vid)
3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784
{
	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;

	batadv_tt_global_entry_free_ref(tt);

	return ret;
}