routing.c 34.6 KB
Newer Older
1
/* Copyright (C) 2007-2016  B.A.T.M.A.N. contributors:
2 3 4 5 6 7 8 9 10 11 12 13 14
 *
 * Marek Lindner, Simon Wunderlich
 *
 * 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 "routing.h"
19 20 21 22 23 24 25 26 27
#include "main.h"

#include <linux/atomic.h>
#include <linux/byteorder/generic.h>
#include <linux/compiler.h>
#include <linux/errno.h>
#include <linux/etherdevice.h>
#include <linux/if_ether.h>
#include <linux/jiffies.h>
28
#include <linux/kref.h>
29 30 31 32 33 34 35 36 37
#include <linux/netdevice.h>
#include <linux/printk.h>
#include <linux/rculist.h>
#include <linux/rcupdate.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/stddef.h>

#include "bitarray.h"
38
#include "bridge_loop_avoidance.h"
39
#include "distributed-arp-table.h"
40
#include "fragmentation.h"
41 42
#include "hard-interface.h"
#include "icmp_socket.h"
43
#include "log.h"
44 45 46 47 48
#include "network-coding.h"
#include "originator.h"
#include "packet.h"
#include "send.h"
#include "soft-interface.h"
49
#include "tp_meter.h"
50
#include "translation-table.h"
51
#include "tvlv.h"
52

53
static int batadv_route_unicast_packet(struct sk_buff *skb,
54
				       struct batadv_hard_iface *recv_if);
55

56 57 58 59 60 61 62 63 64
/**
 * _batadv_update_route - set the router for this originator
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: orig node which is to be configured
 * @recv_if: the receive interface for which this route is set
 * @neigh_node: neighbor which should be the next router
 *
 * This function does not perform any error checks
 */
65 66
static void _batadv_update_route(struct batadv_priv *bat_priv,
				 struct batadv_orig_node *orig_node,
67
				 struct batadv_hard_iface *recv_if,
68
				 struct batadv_neigh_node *neigh_node)
69
{
70
	struct batadv_orig_ifinfo *orig_ifinfo;
71
	struct batadv_neigh_node *curr_router;
72

73 74 75 76 77 78
	orig_ifinfo = batadv_orig_ifinfo_get(orig_node, recv_if);
	if (!orig_ifinfo)
		return;

	rcu_read_lock();
	curr_router = rcu_dereference(orig_ifinfo->router);
79
	if (curr_router && !kref_get_unless_zero(&curr_router->refcount))
80 81
		curr_router = NULL;
	rcu_read_unlock();
82

83
	/* route deleted */
84
	if ((curr_router) && (!neigh_node)) {
85 86
		batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
			   "Deleting route towards: %pM\n", orig_node->orig);
87
		batadv_tt_global_del_orig(bat_priv, orig_node, -1,
88
					  "Deleted route towards originator");
89

90 91
	/* route added */
	} else if ((!curr_router) && (neigh_node)) {
92
		batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
93 94
			   "Adding route towards: %pM (via %pM)\n",
			   orig_node->orig, neigh_node->addr);
95
	/* route changed */
96
	} else if (neigh_node && curr_router) {
97
		batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
98 99 100
			   "Changing route towards: %pM (now via %pM - was via %pM)\n",
			   orig_node->orig, neigh_node->addr,
			   curr_router->addr);
101 102
	}

103
	if (curr_router)
104
		batadv_neigh_node_put(curr_router);
105 106

	spin_lock_bh(&orig_node->neigh_list_lock);
107 108 109 110 111 112 113 114 115
	/* curr_router used earlier may not be the current orig_ifinfo->router
	 * anymore because it was dereferenced outside of the neigh_list_lock
	 * protected region. After the new best neighbor has replace the current
	 * best neighbor the reference counter needs to decrease. Consequently,
	 * the code needs to ensure the curr_router variable contains a pointer
	 * to the replaced best neighbor.
	 */
	curr_router = rcu_dereference_protected(orig_ifinfo->router, true);

116 117 118 119
	/* increase refcount of new best neighbor */
	if (neigh_node)
		kref_get(&neigh_node->refcount);

120
	rcu_assign_pointer(orig_ifinfo->router, neigh_node);
121
	spin_unlock_bh(&orig_node->neigh_list_lock);
122
	batadv_orig_ifinfo_put(orig_ifinfo);
123 124 125

	/* decrease refcount of previous best neighbor */
	if (curr_router)
126
		batadv_neigh_node_put(curr_router);
127 128
}

129 130 131 132 133 134 135
/**
 * batadv_update_route - set the router for this originator
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: orig node which is to be configured
 * @recv_if: the receive interface for which this route is set
 * @neigh_node: neighbor which should be the next router
 */
136 137
void batadv_update_route(struct batadv_priv *bat_priv,
			 struct batadv_orig_node *orig_node,
138
			 struct batadv_hard_iface *recv_if,
139
			 struct batadv_neigh_node *neigh_node)
140
{
141
	struct batadv_neigh_node *router = NULL;
142 143

	if (!orig_node)
144 145
		goto out;

146
	router = batadv_orig_router_get(orig_node, recv_if);
147

148
	if (router != neigh_node)
149
		_batadv_update_route(bat_priv, orig_node, recv_if, neigh_node);
150 151 152

out:
	if (router)
153
		batadv_neigh_node_put(router);
154 155
}

156
/**
157
 * batadv_window_protected - checks whether the host restarted and is in the
158
 *  protection time.
159 160 161
 * @bat_priv: the bat priv with all the soft interface information
 * @seq_num_diff: difference between the current/received sequence number and
 *  the last sequence number
162
 * @seq_old_max_diff: maximum age of sequence number not considered as restart
163 164
 * @last_reset: jiffies timestamp of the last reset, will be updated when reset
 *  is detected
165 166
 * @protection_started: is set to true if the protection window was started,
 *   doesn't change otherwise.
167 168
 *
 * Return:
169 170
 *  false if the packet is to be accepted.
 *  true if the packet is to be ignored.
171
 */
172 173 174
bool batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
			     s32 seq_old_max_diff, unsigned long *last_reset,
			     bool *protection_started)
175
{
176
	if (seq_num_diff <= -seq_old_max_diff ||
177 178 179
	    seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
		if (!batadv_has_timed_out(*last_reset,
					  BATADV_RESET_PROTECTION_MS))
180
			return true;
181 182

		*last_reset = jiffies;
183 184
		if (protection_started)
			*protection_started = true;
185
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
186
			   "old packet received, start protection\n");
187
	}
188

189
	return false;
190 191
}

192
bool batadv_check_management_packet(struct sk_buff *skb,
193
				    struct batadv_hard_iface *hard_iface,
194
				    int header_len)
195 196 197 198
{
	struct ethhdr *ethhdr;

	/* drop packet if it has not necessary minimum size */
199 200
	if (unlikely(!pskb_may_pull(skb, header_len)))
		return false;
201

202
	ethhdr = eth_hdr(skb);
203 204 205

	/* packet with broadcast indication but unicast recipient */
	if (!is_broadcast_ether_addr(ethhdr->h_dest))
206
		return false;
207 208 209

	/* packet with broadcast sender address */
	if (is_broadcast_ether_addr(ethhdr->h_source))
210
		return false;
211 212 213

	/* create a copy of the skb, if needed, to modify it. */
	if (skb_cow(skb, 0) < 0)
214
		return false;
215 216 217

	/* keep skb linear */
	if (skb_linearize(skb) < 0)
218
		return false;
219

220
	return true;
221 222
}

223 224 225 226 227
/**
 * batadv_recv_my_icmp_packet - receive an icmp packet locally
 * @bat_priv: the bat priv with all the soft interface information
 * @skb: icmp packet to process
 *
228
 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
229 230
 * otherwise.
 */
231
static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
232
				      struct sk_buff *skb)
233
{
234 235
	struct batadv_hard_iface *primary_if = NULL;
	struct batadv_orig_node *orig_node = NULL;
236 237
	struct batadv_icmp_header *icmph;
	int res, ret = NET_RX_DROP;
238

239
	icmph = (struct batadv_icmp_header *)skb->data;
240

241 242 243 244 245 246 247
	switch (icmph->msg_type) {
	case BATADV_ECHO_REPLY:
	case BATADV_DESTINATION_UNREACHABLE:
	case BATADV_TTL_EXCEEDED:
		/* receive the packet */
		if (skb_linearize(skb) < 0)
			break;
248

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
		batadv_socket_receive_packet(icmph, skb->len);
		break;
	case BATADV_ECHO_REQUEST:
		/* answer echo request (ping) */
		primary_if = batadv_primary_if_get_selected(bat_priv);
		if (!primary_if)
			goto out;

		/* get routing information */
		orig_node = batadv_orig_hash_find(bat_priv, icmph->orig);
		if (!orig_node)
			goto out;

		/* create a copy of the skb, if needed, to modify it. */
		if (skb_cow(skb, ETH_HLEN) < 0)
			goto out;

		icmph = (struct batadv_icmp_header *)skb->data;

268 269
		ether_addr_copy(icmph->dst, icmph->orig);
		ether_addr_copy(icmph->orig, primary_if->net_dev->dev_addr);
270
		icmph->msg_type = BATADV_ECHO_REPLY;
271
		icmph->ttl = BATADV_TTL;
272 273

		res = batadv_send_skb_to_orig(skb, orig_node, NULL);
274 275 276 277
		if (res == -1)
			goto out;

		ret = NET_RX_SUCCESS;
278 279

		break;
280 281 282 283 284 285 286
	case BATADV_TP:
		if (!pskb_may_pull(skb, sizeof(struct batadv_icmp_tp_packet)))
			goto out;

		batadv_tp_meter_recv(bat_priv, skb);
		ret = NET_RX_SUCCESS;
		goto out;
287 288
	default:
		/* drop unknown type */
289
		goto out;
290
	}
291
out:
292
	if (primary_if)
293
		batadv_hardif_put(primary_if);
294
	if (orig_node)
295
		batadv_orig_node_put(orig_node);
296 297 298
	return ret;
}

299
static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
300
					 struct sk_buff *skb)
301
{
302 303
	struct batadv_hard_iface *primary_if = NULL;
	struct batadv_orig_node *orig_node = NULL;
304
	struct batadv_icmp_packet *icmp_packet;
305
	int res, ret = NET_RX_DROP;
306

307
	icmp_packet = (struct batadv_icmp_packet *)skb->data;
308 309

	/* send TTL exceeded if packet is an echo request (traceroute) */
310
	if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
311
		pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
312
			 icmp_packet->orig, icmp_packet->dst);
313
		goto out;
314 315
	}

316
	primary_if = batadv_primary_if_get_selected(bat_priv);
317
	if (!primary_if)
318
		goto out;
319 320

	/* get routing information */
321
	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
322
	if (!orig_node)
323
		goto out;
324

325
	/* create a copy of the skb, if needed, to modify it. */
326
	if (skb_cow(skb, ETH_HLEN) < 0)
327
		goto out;
328

329
	icmp_packet = (struct batadv_icmp_packet *)skb->data;
330

331 332
	ether_addr_copy(icmp_packet->dst, icmp_packet->orig);
	ether_addr_copy(icmp_packet->orig, primary_if->net_dev->dev_addr);
333 334
	icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
	icmp_packet->ttl = BATADV_TTL;
335

336 337
	res = batadv_send_skb_to_orig(skb, orig_node, NULL);
	if (res != -1)
338
		ret = NET_RX_SUCCESS;
339

340
out:
341
	if (primary_if)
342
		batadv_hardif_put(primary_if);
343
	if (orig_node)
344
		batadv_orig_node_put(orig_node);
345 346 347
	return ret;
}

348 349
int batadv_recv_icmp_packet(struct sk_buff *skb,
			    struct batadv_hard_iface *recv_if)
350
{
351
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
352 353
	struct batadv_icmp_header *icmph;
	struct batadv_icmp_packet_rr *icmp_packet_rr;
354
	struct ethhdr *ethhdr;
355
	struct batadv_orig_node *orig_node = NULL;
356
	int hdr_size = sizeof(struct batadv_icmp_header);
357
	int res, ret = NET_RX_DROP;
358 359 360

	/* drop packet if it has not necessary minimum size */
	if (unlikely(!pskb_may_pull(skb, hdr_size)))
361
		goto out;
362

363
	ethhdr = eth_hdr(skb);
364 365 366

	/* packet with unicast indication but broadcast recipient */
	if (is_broadcast_ether_addr(ethhdr->h_dest))
367
		goto out;
368 369 370

	/* packet with broadcast sender address */
	if (is_broadcast_ether_addr(ethhdr->h_source))
371
		goto out;
372 373

	/* not for me */
374
	if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
375
		goto out;
376

377
	icmph = (struct batadv_icmp_header *)skb->data;
378 379

	/* add record route information if not full */
380 381 382 383 384 385 386 387 388 389
	if ((icmph->msg_type == BATADV_ECHO_REPLY ||
	     icmph->msg_type == BATADV_ECHO_REQUEST) &&
	    (skb->len >= sizeof(struct batadv_icmp_packet_rr))) {
		if (skb_linearize(skb) < 0)
			goto out;

		/* create a copy of the skb, if needed, to modify it. */
		if (skb_cow(skb, ETH_HLEN) < 0)
			goto out;

390
		ethhdr = eth_hdr(skb);
391 392 393 394 395
		icmph = (struct batadv_icmp_header *)skb->data;
		icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmph;
		if (icmp_packet_rr->rr_cur >= BATADV_RR_LEN)
			goto out;

396 397
		ether_addr_copy(icmp_packet_rr->rr[icmp_packet_rr->rr_cur],
				ethhdr->h_dest);
398
		icmp_packet_rr->rr_cur++;
399 400 401
	}

	/* packet for me */
402 403
	if (batadv_is_my_mac(bat_priv, icmph->dst))
		return batadv_recv_my_icmp_packet(bat_priv, skb);
404 405

	/* TTL exceeded */
406
	if (icmph->ttl < 2)
407
		return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
408 409

	/* get routing information */
410
	orig_node = batadv_orig_hash_find(bat_priv, icmph->dst);
411
	if (!orig_node)
412
		goto out;
413

414
	/* create a copy of the skb, if needed, to modify it. */
415
	if (skb_cow(skb, ETH_HLEN) < 0)
416
		goto out;
417

418
	icmph = (struct batadv_icmp_header *)skb->data;
419

420
	/* decrement ttl */
421
	icmph->ttl--;
422 423

	/* route it */
424 425
	res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
	if (res != -1)
426
		ret = NET_RX_SUCCESS;
427

428 429
out:
	if (orig_node)
430
		batadv_orig_node_put(orig_node);
431 432 433
	return ret;
}

434 435
/**
 * batadv_check_unicast_packet - Check for malformed unicast packets
436
 * @bat_priv: the bat priv with all the soft interface information
437 438 439
 * @skb: packet to check
 * @hdr_size: size of header to pull
 *
440 441 442 443 444
 * Check for short header and bad addresses in given packet.
 *
 * Return: negative value when check fails and 0 otherwise. The negative value
 * depends on the reason: -ENODATA for bad header, -EBADR for broadcast
 * destination or source, and -EREMOTE for non-local (other host) destination.
445
 */
446 447
static int batadv_check_unicast_packet(struct batadv_priv *bat_priv,
				       struct sk_buff *skb, int hdr_size)
448 449 450 451 452
{
	struct ethhdr *ethhdr;

	/* drop packet if it has not necessary minimum size */
	if (unlikely(!pskb_may_pull(skb, hdr_size)))
453
		return -ENODATA;
454

455
	ethhdr = eth_hdr(skb);
456 457 458

	/* packet with unicast indication but broadcast recipient */
	if (is_broadcast_ether_addr(ethhdr->h_dest))
459
		return -EBADR;
460 461 462

	/* packet with broadcast sender address */
	if (is_broadcast_ether_addr(ethhdr->h_source))
463
		return -EBADR;
464 465

	/* not for me */
466
	if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
467
		return -EREMOTE;
468 469 470 471

	return 0;
}

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
/**
 * batadv_last_bonding_get - Get last_bonding_candidate of orig_node
 * @orig_node: originator node whose last bonding candidate should be retrieved
 *
 * Return: last bonding candidate of router or NULL if not found
 *
 * The object is returned with refcounter increased by 1.
 */
static struct batadv_orig_ifinfo *
batadv_last_bonding_get(struct batadv_orig_node *orig_node)
{
	struct batadv_orig_ifinfo *last_bonding_candidate;

	spin_lock_bh(&orig_node->neigh_list_lock);
	last_bonding_candidate = orig_node->last_bonding_candidate;

	if (last_bonding_candidate)
		kref_get(&last_bonding_candidate->refcount);
	spin_unlock_bh(&orig_node->neigh_list_lock);

	return last_bonding_candidate;
}

495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517
/**
 * batadv_last_bonding_replace - Replace last_bonding_candidate of orig_node
 * @orig_node: originator node whose bonding candidates should be replaced
 * @new_candidate: new bonding candidate or NULL
 */
static void
batadv_last_bonding_replace(struct batadv_orig_node *orig_node,
			    struct batadv_orig_ifinfo *new_candidate)
{
	struct batadv_orig_ifinfo *old_candidate;

	spin_lock_bh(&orig_node->neigh_list_lock);
	old_candidate = orig_node->last_bonding_candidate;

	if (new_candidate)
		kref_get(&new_candidate->refcount);
	orig_node->last_bonding_candidate = new_candidate;
	spin_unlock_bh(&orig_node->neigh_list_lock);

	if (old_candidate)
		batadv_orig_ifinfo_put(old_candidate);
}

518 519 520 521 522 523
/**
 * batadv_find_router - find a suitable router for this originator
 * @bat_priv: the bat priv with all the soft interface information
 * @orig_node: the destination node
 * @recv_if: pointer to interface this packet was received on
 *
524
 * Return: the router which should be used for this orig_node on
525
 * this interface, or NULL if not available.
526
 */
527 528 529
struct batadv_neigh_node *
batadv_find_router(struct batadv_priv *bat_priv,
		   struct batadv_orig_node *orig_node,
530
		   struct batadv_hard_iface *recv_if)
531
{
532
	struct batadv_algo_ops *bao = bat_priv->algo_ops;
533 534 535 536 537 538 539 540
	struct batadv_neigh_node *first_candidate_router = NULL;
	struct batadv_neigh_node *next_candidate_router = NULL;
	struct batadv_neigh_node *router, *cand_router = NULL;
	struct batadv_neigh_node *last_cand_router = NULL;
	struct batadv_orig_ifinfo *cand, *first_candidate = NULL;
	struct batadv_orig_ifinfo *next_candidate = NULL;
	struct batadv_orig_ifinfo *last_candidate;
	bool last_candidate_found = false;
541 542 543 544

	if (!orig_node)
		return NULL;

545
	router = batadv_orig_router_get(orig_node, recv_if);
546

547 548 549
	if (!router)
		return router;

550 551 552
	/* only consider bonding for recv_if == BATADV_IF_DEFAULT (first hop)
	 * and if activated.
	 */
553
	if (!(recv_if == BATADV_IF_DEFAULT && atomic_read(&bat_priv->bonding)))
554 555 556 557 558 559 560
		return router;

	/* bonding: loop through the list of possible routers found
	 * for the various outgoing interfaces and find a candidate after
	 * the last chosen bonding candidate (next_candidate). If no such
	 * router is found, use the first candidate found (the previously
	 * chosen bonding candidate might have been the last one in the list).
561
	 * If this can't be found either, return the previously chosen
562 563 564
	 * router - obviously there are no other candidates.
	 */
	rcu_read_lock();
565
	last_candidate = batadv_last_bonding_get(orig_node);
566 567 568 569 570
	if (last_candidate)
		last_cand_router = rcu_dereference(last_candidate->router);

	hlist_for_each_entry_rcu(cand, &orig_node->ifinfo_list, list) {
		/* acquire some structures and references ... */
571
		if (!kref_get_unless_zero(&cand->refcount))
572 573 574 575 576 577
			continue;

		cand_router = rcu_dereference(cand->router);
		if (!cand_router)
			goto next;

578
		if (!kref_get_unless_zero(&cand_router->refcount)) {
579 580 581 582 583 584 585
			cand_router = NULL;
			goto next;
		}

		/* alternative candidate should be good enough to be
		 * considered
		 */
586 587 588
		if (!bao->neigh.is_similar_or_better(cand_router,
						     cand->if_outgoing, router,
						     recv_if))
589 590 591 592 593 594 595 596
			goto next;

		/* don't use the same router twice */
		if (last_cand_router == cand_router)
			goto next;

		/* mark the first possible candidate */
		if (!first_candidate) {
597
			kref_get(&cand_router->refcount);
598
			kref_get(&cand->refcount);
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
			first_candidate = cand;
			first_candidate_router = cand_router;
		}

		/* check if the loop has already passed the previously selected
		 * candidate ... this function should select the next candidate
		 * AFTER the previously used bonding candidate.
		 */
		if (!last_candidate || last_candidate_found) {
			next_candidate = cand;
			next_candidate_router = cand_router;
			break;
		}

		if (last_candidate == cand)
			last_candidate_found = true;
next:
		/* free references */
		if (cand_router) {
618
			batadv_neigh_node_put(cand_router);
619 620
			cand_router = NULL;
		}
621
		batadv_orig_ifinfo_put(cand);
622 623 624 625 626 627 628 629 630
	}
	rcu_read_unlock();

	/* After finding candidates, handle the three cases:
	 * 1) there is a next candidate, use that
	 * 2) there is no next candidate, use the first of the list
	 * 3) there is no candidate at all, return the default router
	 */
	if (next_candidate) {
631
		batadv_neigh_node_put(router);
632

633
		kref_get(&next_candidate_router->refcount);
634
		router = next_candidate_router;
635
		batadv_last_bonding_replace(orig_node, next_candidate);
636
	} else if (first_candidate) {
637
		batadv_neigh_node_put(router);
638

639
		kref_get(&first_candidate_router->refcount);
640
		router = first_candidate_router;
641
		batadv_last_bonding_replace(orig_node, first_candidate);
642
	} else {
643 644 645 646 647 648 649 650 651 652 653 654
		batadv_last_bonding_replace(orig_node, NULL);
	}

	/* cleanup of candidates */
	if (first_candidate) {
		batadv_neigh_node_put(first_candidate_router);
		batadv_orig_ifinfo_put(first_candidate);
	}

	if (next_candidate) {
		batadv_neigh_node_put(next_candidate_router);
		batadv_orig_ifinfo_put(next_candidate);
655
	}
656

657 658 659
	if (last_candidate)
		batadv_orig_ifinfo_put(last_candidate);

660 661 662
	return router;
}

663
static int batadv_route_unicast_packet(struct sk_buff *skb,
664
				       struct batadv_hard_iface *recv_if)
665
{
666 667
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
	struct batadv_orig_node *orig_node = NULL;
668
	struct batadv_unicast_packet *unicast_packet;
669
	struct ethhdr *ethhdr = eth_hdr(skb);
670
	int res, hdr_len, ret = NET_RX_DROP;
671
	unsigned int len;
672

673
	unicast_packet = (struct batadv_unicast_packet *)skb->data;
674 675

	/* TTL exceeded */
676
	if (unicast_packet->ttl < 2) {
677 678
		pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
			 ethhdr->h_source, unicast_packet->dest);
679
		goto out;
680 681 682
	}

	/* get routing information */
683
	orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
684

685
	if (!orig_node)
686
		goto out;
687 688

	/* create a copy of the skb, if needed, to modify it. */
689
	if (skb_cow(skb, ETH_HLEN) < 0)
690
		goto out;
691 692

	/* decrement ttl */
693
	unicast_packet = (struct batadv_unicast_packet *)skb->data;
694
	unicast_packet->ttl--;
695

696
	switch (unicast_packet->packet_type) {
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
	case BATADV_UNICAST_4ADDR:
		hdr_len = sizeof(struct batadv_unicast_4addr_packet);
		break;
	case BATADV_UNICAST:
		hdr_len = sizeof(struct batadv_unicast_packet);
		break;
	default:
		/* other packet types not supported - yet */
		hdr_len = -1;
		break;
	}

	if (hdr_len > 0)
		batadv_skb_set_priority(skb, hdr_len);

712
	len = skb->len;
713
	res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
714 715
	if (res == -1)
		goto out;
716

717 718 719
	/* translate transmit result into receive result */
	if (res == NET_XMIT_SUCCESS) {
		/* skb was transmitted and consumed */
720 721
		batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
		batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
722
				   len + ETH_HLEN);
723
	}
724

725 726
	ret = NET_RX_SUCCESS;

727 728
out:
	if (orig_node)
729
		batadv_orig_node_put(orig_node);
730
	return ret;
731 732
}

733 734 735 736 737
/**
 * batadv_reroute_unicast_packet - update the unicast header for re-routing
 * @bat_priv: the bat priv with all the soft interface information
 * @unicast_packet: the unicast header to be updated
 * @dst_addr: the payload destination
738
 * @vid: VLAN identifier
739 740 741 742 743
 *
 * Search the translation table for dst_addr and update the unicast header with
 * the new corresponding information (originator address where the destination
 * client currently is and its known TTVN)
 *
744
 * Return: true if the packet header has been updated, false otherwise
745 746 747 748
 */
static bool
batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
			      struct batadv_unicast_packet *unicast_packet,
749
			      u8 *dst_addr, unsigned short vid)
750 751 752 753
{
	struct batadv_orig_node *orig_node = NULL;
	struct batadv_hard_iface *primary_if = NULL;
	bool ret = false;
754
	u8 *orig_addr, orig_ttvn;
755

756
	if (batadv_is_my_client(bat_priv, dst_addr, vid)) {
757 758 759 760
		primary_if = batadv_primary_if_get_selected(bat_priv);
		if (!primary_if)
			goto out;
		orig_addr = primary_if->net_dev->dev_addr;
761
		orig_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
762
	} else {
763 764
		orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr,
						     vid);
765 766 767 768 769 770 771
		if (!orig_node)
			goto out;

		if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
			goto out;

		orig_addr = orig_node->orig;
772
		orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
773 774 775
	}

	/* update the packet header */
776
	ether_addr_copy(unicast_packet->dest, orig_addr);
777 778 779 780 781
	unicast_packet->ttvn = orig_ttvn;

	ret = true;
out:
	if (primary_if)
782
		batadv_hardif_put(primary_if);
783
	if (orig_node)
784
		batadv_orig_node_put(orig_node);
785 786 787 788

	return ret;
}

789 790 791
static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
				      struct sk_buff *skb, int hdr_len)
{
792 793
	struct batadv_unicast_packet *unicast_packet;
	struct batadv_hard_iface *primary_if;
794
	struct batadv_orig_node *orig_node;
795
	u8 curr_ttvn, old_ttvn;
796
	struct ethhdr *ethhdr;
797
	unsigned short vid;
798
	int is_old_ttvn;
799

800
	/* check if there is enough data before accessing it */
801
	if (!pskb_may_pull(skb, hdr_len + ETH_HLEN))
802
		return false;
803 804 805

	/* create a copy of the skb (in case of for re-routing) to modify it. */
	if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
806
		return false;
807

808
	unicast_packet = (struct batadv_unicast_packet *)skb->data;
809
	vid = batadv_get_vid(skb, hdr_len);
810
	ethhdr = (struct ethhdr *)(skb->data + hdr_len);
811

812 813 814 815 816
	/* check if the destination client was served by this node and it is now
	 * roaming. In this case, it means that the node has got a ROAM_ADV
	 * message and that it knows the new destination in the mesh to re-route
	 * the packet to
	 */
817
	if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) {
818
		if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
819
						  ethhdr->h_dest, vid))
820 821 822 823 824
			batadv_dbg_ratelimited(BATADV_DBG_TT,
					       bat_priv,
					       "Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
					       unicast_packet->dest,
					       ethhdr->h_dest);
825 826 827 828 829
		/* at this point the mesh destination should have been
		 * substituted with the originator address found in the global
		 * table. If not, let the packet go untouched anyway because
		 * there is nothing the node can do
		 */
830
		return true;
831 832 833 834 835 836
	}

	/* retrieve the TTVN known by this node for the packet destination. This
	 * value is used later to check if the node which sent (or re-routed
	 * last time) the packet had an updated information or not
	 */
837
	curr_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
838
	if (!batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
839 840
		orig_node = batadv_orig_hash_find(bat_priv,
						  unicast_packet->dest);
841 842 843 844
		/* if it is not possible to find the orig_node representing the
		 * destination, the packet can immediately be dropped as it will
		 * not be possible to deliver it
		 */
845
		if (!orig_node)
846
			return false;
847

848
		curr_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
849
		batadv_orig_node_put(orig_node);
850 851
	}

852 853 854
	/* check if the TTVN contained in the packet is fresher than what the
	 * node knows
	 */
855
	is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
856
	if (!is_old_ttvn)
857
		return true;
858

859 860 861 862 863 864
	old_ttvn = unicast_packet->ttvn;
	/* the packet was forged based on outdated network information. Its
	 * destination can possibly be updated and forwarded towards the new
	 * target host
	 */
	if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
865
					  ethhdr->h_dest, vid)) {
866 867 868 869
		batadv_dbg_ratelimited(BATADV_DBG_TT, bat_priv,
				       "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
				       unicast_packet->dest, ethhdr->h_dest,
				       old_ttvn, curr_ttvn);
870
		return true;
871
	}
872

873 874 875 876
	/* the packet has not been re-routed: either the destination is
	 * currently served by this node or there is no destination at all and
	 * it is possible to drop the packet
	 */
877
	if (!batadv_is_my_client(bat_priv, ethhdr->h_dest, vid))
878
		return false;
879

880 881 882 883 884
	/* update the header in order to let the packet be delivered to this
	 * node's soft interface
	 */
	primary_if = batadv_primary_if_get_selected(bat_priv);
	if (!primary_if)
885
		return false;
886

887
	ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
888

889
	batadv_hardif_put(primary_if);
890 891

	unicast_packet->ttvn = curr_ttvn;
892

893
	return true;
894 895
}

896 897 898 899 900 901
/**
 * batadv_recv_unhandled_unicast_packet - receive and process packets which
 *	are in the unicast number space but not yet known to the implementation
 * @skb: unicast tvlv packet to process
 * @recv_if: pointer to interface this packet was received on
 *
902
 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
 * otherwise.
 */
int batadv_recv_unhandled_unicast_packet(struct sk_buff *skb,
					 struct batadv_hard_iface *recv_if)
{
	struct batadv_unicast_packet *unicast_packet;
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
	int check, hdr_size = sizeof(*unicast_packet);

	check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
	if (check < 0)
		return NET_RX_DROP;

	/* we don't know about this type, drop it. */
	unicast_packet = (struct batadv_unicast_packet *)skb->data;
	if (batadv_is_my_mac(bat_priv, unicast_packet->dest))
		return NET_RX_DROP;

	return batadv_route_unicast_packet(skb, recv_if);
}

924 925
int batadv_recv_unicast_packet(struct sk_buff *skb,
			       struct batadv_hard_iface *recv_if)
926
{
927
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
928
	struct batadv_unicast_packet *unicast_packet;
929
	struct batadv_unicast_4addr_packet *unicast_4addr_packet;
930
	u8 *orig_addr;
931
	struct batadv_orig_node *orig_node = NULL;
932
	int check, hdr_size = sizeof(*unicast_packet);
933
	enum batadv_subtype subtype;
934
	bool is4addr;
935

936
	unicast_packet = (struct batadv_unicast_packet *)skb->data;
937
	unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
938

939
	is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR;
940
	/* the caller function should have already pulled 2 bytes */
941
	if (is4addr)
942
		hdr_size = sizeof(*unicast_4addr_packet);
943

944
	/* function returns -EREMOTE for promiscuous packets */
945
	check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
946 947 948 949 950 951 952 953

	/* Even though the packet is not for us, we might save it to use for
	 * decoding a later received coded packet
	 */
	if (check == -EREMOTE)
		batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);

	if (check < 0)
954
		return NET_RX_DROP;
955
	if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
956 957
		return NET_RX_DROP;

958
	/* packet for me */
959
	if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
960
		if (is4addr) {
961 962 963 964 965 966 967 968 969 970 971 972 973 974
			subtype = unicast_4addr_packet->subtype;
			batadv_dat_inc_counter(bat_priv, subtype);

			/* Only payload data should be considered for speedy
			 * join. For example, DAT also uses unicast 4addr
			 * types, but those packets should not be considered
			 * for speedy join, since the clients do not actually
			 * reside at the sending originator.
			 */
			if (subtype == BATADV_P_DATA) {
				orig_addr = unicast_4addr_packet->src;
				orig_node = batadv_orig_hash_find(bat_priv,
								  orig_addr);
			}
975
		}
976

977 978 979 980 981 982 983
		if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
							  hdr_size))
			goto rx_success;
		if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
							hdr_size))
			goto rx_success;

984
		batadv_interface_rx(recv_if->soft_iface, skb, hdr_size,
985
				    orig_node);
986

987
rx_success:
988
		if (orig_node)
989
			batadv_orig_node_put(orig_node);
990

991 992 993
		return NET_RX_SUCCESS;
	}

994
	return batadv_route_unicast_packet(skb, recv_if);
995 996
}

997 998 999 1000 1001
/**
 * batadv_recv_unicast_tvlv - receive and process unicast tvlv packets
 * @skb: unicast tvlv packet to process
 * @recv_if: pointer to interface this packet was received on
 *
1002
 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
1003 1004 1005 1006 1007 1008 1009 1010
 * otherwise.
 */
int batadv_recv_unicast_tvlv(struct sk_buff *skb,
			     struct batadv_hard_iface *recv_if)
{
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
	struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
	unsigned char *tvlv_buff;
1011
	u16 tvlv_buff_len;
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
	int hdr_size = sizeof(*unicast_tvlv_packet);
	int ret = NET_RX_DROP;

	if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
		return NET_RX_DROP;

	/* the header is likely to be modified while forwarding */
	if (skb_cow(skb, hdr_size) < 0)
		return NET_RX_DROP;

	/* packet needs to be linearized to access the tvlv content */
	if (skb_linearize(skb) < 0)
		return NET_RX_DROP;

	unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)skb->data;

	tvlv_buff = (unsigned char *)(skb->data + hdr_size);
	tvlv_buff_len = ntohs(unicast_tvlv_packet->tvlv_len);

	if (tvlv_buff_len > skb->len - hdr_size)
		return NET_RX_DROP;

	ret = batadv_tvlv_containers_process(bat_priv, false, NULL,
					     unicast_tvlv_packet->src,
					     unicast_tvlv_packet->dst,
					     tvlv_buff, tvlv_buff_len);

	if (ret != NET_RX_SUCCESS)
		ret = batadv_route_unicast_packet(skb, recv_if);
1041 1042
	else
		consume_skb(skb);
1043 1044 1045

	return ret;
}
1046

1047 1048 1049 1050 1051 1052 1053 1054 1055
/**
 * batadv_recv_frag_packet - process received fragment
 * @skb: the received fragment
 * @recv_if: interface that the skb is received on
 *
 * This function does one of the three following things: 1) Forward fragment, if
 * the assembled packet will exceed our MTU; 2) Buffer fragment, if we till
 * lack further fragments; 3) Merge fragments, if we have all needed parts.
 *
1056
 * Return: NET_RX_DROP if the skb is not consumed, NET_RX_SUCCESS otherwise.
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
 */
int batadv_recv_frag_packet(struct sk_buff *skb,
			    struct batadv_hard_iface *recv_if)
{
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
	struct batadv_orig_node *orig_node_src = NULL;
	struct batadv_frag_packet *frag_packet;
	int ret = NET_RX_DROP;

	if (batadv_check_unicast_packet(bat_priv, skb,
					sizeof(*frag_packet)) < 0)
		goto out;

	frag_packet = (struct batadv_frag_packet *)skb->data;
	orig_node_src = batadv_orig_hash_find(bat_priv, frag_packet->orig);
	if (!orig_node_src)
		goto out;

1075 1076
	skb->priority = frag_packet->priority + 256;

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
	/* Route the fragment if it is not for us and too big to be merged. */
	if (!batadv_is_my_mac(bat_priv, frag_packet->dest) &&
	    batadv_frag_skb_fwd(skb, recv_if, orig_node_src)) {
		ret = NET_RX_SUCCESS;
		goto out;
	}

	batadv_inc_counter(bat_priv, BATADV_CNT_FRAG_RX);
	batadv_add_counter(bat_priv, BATADV_CNT_FRAG_RX_BYTES, skb->len);

	/* Add fragment to buffer and merge if possible. */
	if (!batadv_frag_skb_buffer(&skb, orig_node_src))
		goto out;

	/* Deliver merged packet to the appropriate handler, if it was
	 * merged
	 */
	if (skb)
		batadv_batman_skb_recv(skb, recv_if->net_dev,
				       &recv_if->batman_adv_ptype, NULL);

	ret = NET_RX_SUCCESS;

out:
	if (orig_node_src)
1102
		batadv_orig_node_put(orig_node_src);
1103 1104 1105 1106

	return ret;
}

1107 1108
int batadv_recv_bcast_packet(struct sk_buff *skb,
			     struct batadv_hard_iface *recv_if)
1109
{
1110 1111
	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
	struct batadv_orig_node *orig_node = NULL;
1112
	struct batadv_bcast_packet *bcast_packet;
1113
	struct ethhdr *ethhdr;
1114
	int hdr_size = sizeof(*bcast_packet);
1115
	int ret = NET_RX_DROP;
1116 1117
	s32 seq_diff;
	u32 seqno;
1118 1119 1120

	/* drop packet if it has not necessary minimum size */
	if (unlikely(!pskb_may_pull(skb, hdr_size)))
1121
		goto out;
1122

1123
	ethhdr = eth_hdr(skb);
1124 1125 1126

	/* packet with broadcast indication but unicast recipient */
	if (!is_broadcast_ether_addr(ethhdr->h_dest))
1127
		goto out;
1128 1129 1130

	/* packet with broadcast sender address */
	if (is_broadcast_ether_addr(ethhdr->h_source))
1131
		goto out;
1132 1133

	/* ignore broadcasts sent by myself */
1134
	if (batadv_is_my_mac(bat_priv, ethhdr->h_source))
1135
		goto out;
1136

1137
	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1138 1139

	/* ignore broadcasts originated by myself */
1140
	if (batadv_is_my_mac(bat_priv, bcast_packet->orig))
1141
		goto out;
1142

1143
	if (bcast_packet->ttl < 2)
1144
		goto out;
1145

1146
	orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1147 1148

	if (!orig_node)
1149
		goto out;
1150

1151
	spin_lock_bh(&orig_node->bcast_seqno_lock);
1152

1153
	seqno = ntohl(bcast_packet->seqno);
1154
	/* check whether the packet is a duplicate */
1155
	if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1156
			    seqno))
1157
		goto spin_unlock;
1158

1159
	seq_diff = seqno - orig_node->last_bcast_seqno;
1160 1161

	/* check whether the packet is old and the host just restarted. */
1162
	if (batadv_window_protected(bat_priv, seq_diff,
1163 1164
				    BATADV_BCAST_MAX_AGE,
				    &orig_node->bcast_seqno_reset, NULL))
1165
		goto spin_unlock;
1166 1167

	/* mark broadcast in flood history, update window position
1168 1169
	 * if required.
	 */
1170
	if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1171
		orig_node->last_bcast_seqno = seqno;
1172

1173 1174
	spin_unlock_bh(&orig_node->bcast_seqno_lock);

1175
	/* check whether this has been sent by another originator before */
1176
	if (batadv_bla_check_bcast_duplist(bat_priv, skb))
1177 1178
		goto out;

1179 1180
	batadv_skb_set_priority(skb, sizeof(struct batadv_bcast_packet));

1181
	/* rebroadcast packet */
1182
	batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1183

1184 1185 1186
	/* don't hand the broadcast up if it is from an originator
	 * from the same backbone.
	 */
1187
	if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1188 1189
		goto out;

1190 1191 1192 1193 1194
	if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
		goto rx_success;
	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
		goto rx_success;

1195
	/* broadcast for me */
1196
	batadv_interface_rx(recv_if->soft_iface, skb, hdr_size, orig_node);
1197 1198

rx_success:
1199 1200
	ret = NET_RX_SUCCESS;
	goto out;
1201

1202 1203 1204 1205
spin_unlock:
	spin_unlock_bh(&orig_node->bcast_seqno_lock);
out:
	if (orig_node)
1206
		batadv_orig_node_put(orig_node);
1207
	return ret;
1208
}
新手
引导
客服 返回
顶部