xref: /openbmc/linux/net/batman-adv/routing.c (revision d7a3d85e)
1 /* Copyright (C) 2007-2014 B.A.T.M.A.N. contributors:
2  *
3  * Marek Lindner, Simon Wunderlich
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of version 2 of the GNU General Public
7  * License as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include "main.h"
19 #include "routing.h"
20 #include "send.h"
21 #include "soft-interface.h"
22 #include "hard-interface.h"
23 #include "icmp_socket.h"
24 #include "translation-table.h"
25 #include "originator.h"
26 #include "bridge_loop_avoidance.h"
27 #include "distributed-arp-table.h"
28 #include "network-coding.h"
29 #include "fragmentation.h"
30 
31 #include <linux/if_vlan.h>
32 
33 static int batadv_route_unicast_packet(struct sk_buff *skb,
34 				       struct batadv_hard_iface *recv_if);
35 
36 /**
37  * _batadv_update_route - set the router for this originator
38  * @bat_priv: the bat priv with all the soft interface information
39  * @orig_node: orig node which is to be configured
40  * @recv_if: the receive interface for which this route is set
41  * @neigh_node: neighbor which should be the next router
42  *
43  * This function does not perform any error checks
44  */
45 static void _batadv_update_route(struct batadv_priv *bat_priv,
46 				 struct batadv_orig_node *orig_node,
47 				 struct batadv_hard_iface *recv_if,
48 				 struct batadv_neigh_node *neigh_node)
49 {
50 	struct batadv_orig_ifinfo *orig_ifinfo;
51 	struct batadv_neigh_node *curr_router;
52 
53 	orig_ifinfo = batadv_orig_ifinfo_get(orig_node, recv_if);
54 	if (!orig_ifinfo)
55 		return;
56 
57 	rcu_read_lock();
58 	curr_router = rcu_dereference(orig_ifinfo->router);
59 	if (curr_router && !atomic_inc_not_zero(&curr_router->refcount))
60 		curr_router = NULL;
61 	rcu_read_unlock();
62 
63 	/* route deleted */
64 	if ((curr_router) && (!neigh_node)) {
65 		batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
66 			   "Deleting route towards: %pM\n", orig_node->orig);
67 		batadv_tt_global_del_orig(bat_priv, orig_node, -1,
68 					  "Deleted route towards originator");
69 
70 	/* route added */
71 	} else if ((!curr_router) && (neigh_node)) {
72 		batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
73 			   "Adding route towards: %pM (via %pM)\n",
74 			   orig_node->orig, neigh_node->addr);
75 	/* route changed */
76 	} else if (neigh_node && curr_router) {
77 		batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
78 			   "Changing route towards: %pM (now via %pM - was via %pM)\n",
79 			   orig_node->orig, neigh_node->addr,
80 			   curr_router->addr);
81 	}
82 
83 	if (curr_router)
84 		batadv_neigh_node_free_ref(curr_router);
85 
86 	/* increase refcount of new best neighbor */
87 	if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))
88 		neigh_node = NULL;
89 
90 	spin_lock_bh(&orig_node->neigh_list_lock);
91 	rcu_assign_pointer(orig_ifinfo->router, neigh_node);
92 	spin_unlock_bh(&orig_node->neigh_list_lock);
93 	batadv_orig_ifinfo_free_ref(orig_ifinfo);
94 
95 	/* decrease refcount of previous best neighbor */
96 	if (curr_router)
97 		batadv_neigh_node_free_ref(curr_router);
98 }
99 
100 /**
101  * batadv_update_route - set the router for this originator
102  * @bat_priv: the bat priv with all the soft interface information
103  * @orig_node: orig node which is to be configured
104  * @recv_if: the receive interface for which this route is set
105  * @neigh_node: neighbor which should be the next router
106  */
107 void batadv_update_route(struct batadv_priv *bat_priv,
108 			 struct batadv_orig_node *orig_node,
109 			 struct batadv_hard_iface *recv_if,
110 			 struct batadv_neigh_node *neigh_node)
111 {
112 	struct batadv_neigh_node *router = NULL;
113 
114 	if (!orig_node)
115 		goto out;
116 
117 	router = batadv_orig_router_get(orig_node, recv_if);
118 
119 	if (router != neigh_node)
120 		_batadv_update_route(bat_priv, orig_node, recv_if, neigh_node);
121 
122 out:
123 	if (router)
124 		batadv_neigh_node_free_ref(router);
125 }
126 
127 /* checks whether the host restarted and is in the protection time.
128  * returns:
129  *  0 if the packet is to be accepted
130  *  1 if the packet is to be ignored.
131  */
132 int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff,
133 			    unsigned long *last_reset)
134 {
135 	if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE ||
136 	    seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
137 		if (!batadv_has_timed_out(*last_reset,
138 					  BATADV_RESET_PROTECTION_MS))
139 			return 1;
140 
141 		*last_reset = jiffies;
142 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
143 			   "old packet received, start protection\n");
144 	}
145 
146 	return 0;
147 }
148 
149 bool batadv_check_management_packet(struct sk_buff *skb,
150 				    struct batadv_hard_iface *hard_iface,
151 				    int header_len)
152 {
153 	struct ethhdr *ethhdr;
154 
155 	/* drop packet if it has not necessary minimum size */
156 	if (unlikely(!pskb_may_pull(skb, header_len)))
157 		return false;
158 
159 	ethhdr = eth_hdr(skb);
160 
161 	/* packet with broadcast indication but unicast recipient */
162 	if (!is_broadcast_ether_addr(ethhdr->h_dest))
163 		return false;
164 
165 	/* packet with broadcast sender address */
166 	if (is_broadcast_ether_addr(ethhdr->h_source))
167 		return false;
168 
169 	/* create a copy of the skb, if needed, to modify it. */
170 	if (skb_cow(skb, 0) < 0)
171 		return false;
172 
173 	/* keep skb linear */
174 	if (skb_linearize(skb) < 0)
175 		return false;
176 
177 	return true;
178 }
179 
180 /**
181  * batadv_recv_my_icmp_packet - receive an icmp packet locally
182  * @bat_priv: the bat priv with all the soft interface information
183  * @skb: icmp packet to process
184  *
185  * Returns NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
186  * otherwise.
187  */
188 static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
189 				      struct sk_buff *skb)
190 {
191 	struct batadv_hard_iface *primary_if = NULL;
192 	struct batadv_orig_node *orig_node = NULL;
193 	struct batadv_icmp_header *icmph;
194 	int res, ret = NET_RX_DROP;
195 
196 	icmph = (struct batadv_icmp_header *)skb->data;
197 
198 	switch (icmph->msg_type) {
199 	case BATADV_ECHO_REPLY:
200 	case BATADV_DESTINATION_UNREACHABLE:
201 	case BATADV_TTL_EXCEEDED:
202 		/* receive the packet */
203 		if (skb_linearize(skb) < 0)
204 			break;
205 
206 		batadv_socket_receive_packet(icmph, skb->len);
207 		break;
208 	case BATADV_ECHO_REQUEST:
209 		/* answer echo request (ping) */
210 		primary_if = batadv_primary_if_get_selected(bat_priv);
211 		if (!primary_if)
212 			goto out;
213 
214 		/* get routing information */
215 		orig_node = batadv_orig_hash_find(bat_priv, icmph->orig);
216 		if (!orig_node)
217 			goto out;
218 
219 		/* create a copy of the skb, if needed, to modify it. */
220 		if (skb_cow(skb, ETH_HLEN) < 0)
221 			goto out;
222 
223 		icmph = (struct batadv_icmp_header *)skb->data;
224 
225 		ether_addr_copy(icmph->dst, icmph->orig);
226 		ether_addr_copy(icmph->orig, primary_if->net_dev->dev_addr);
227 		icmph->msg_type = BATADV_ECHO_REPLY;
228 		icmph->ttl = BATADV_TTL;
229 
230 		res = batadv_send_skb_to_orig(skb, orig_node, NULL);
231 		if (res != NET_XMIT_DROP)
232 			ret = NET_RX_SUCCESS;
233 
234 		break;
235 	default:
236 		/* drop unknown type */
237 		goto out;
238 	}
239 out:
240 	if (primary_if)
241 		batadv_hardif_free_ref(primary_if);
242 	if (orig_node)
243 		batadv_orig_node_free_ref(orig_node);
244 	return ret;
245 }
246 
247 static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
248 					 struct sk_buff *skb)
249 {
250 	struct batadv_hard_iface *primary_if = NULL;
251 	struct batadv_orig_node *orig_node = NULL;
252 	struct batadv_icmp_packet *icmp_packet;
253 	int ret = NET_RX_DROP;
254 
255 	icmp_packet = (struct batadv_icmp_packet *)skb->data;
256 
257 	/* send TTL exceeded if packet is an echo request (traceroute) */
258 	if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
259 		pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
260 			 icmp_packet->orig, icmp_packet->dst);
261 		goto out;
262 	}
263 
264 	primary_if = batadv_primary_if_get_selected(bat_priv);
265 	if (!primary_if)
266 		goto out;
267 
268 	/* get routing information */
269 	orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
270 	if (!orig_node)
271 		goto out;
272 
273 	/* create a copy of the skb, if needed, to modify it. */
274 	if (skb_cow(skb, ETH_HLEN) < 0)
275 		goto out;
276 
277 	icmp_packet = (struct batadv_icmp_packet *)skb->data;
278 
279 	ether_addr_copy(icmp_packet->dst, icmp_packet->orig);
280 	ether_addr_copy(icmp_packet->orig, primary_if->net_dev->dev_addr);
281 	icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
282 	icmp_packet->ttl = BATADV_TTL;
283 
284 	if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
285 		ret = NET_RX_SUCCESS;
286 
287 out:
288 	if (primary_if)
289 		batadv_hardif_free_ref(primary_if);
290 	if (orig_node)
291 		batadv_orig_node_free_ref(orig_node);
292 	return ret;
293 }
294 
295 int batadv_recv_icmp_packet(struct sk_buff *skb,
296 			    struct batadv_hard_iface *recv_if)
297 {
298 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
299 	struct batadv_icmp_header *icmph;
300 	struct batadv_icmp_packet_rr *icmp_packet_rr;
301 	struct ethhdr *ethhdr;
302 	struct batadv_orig_node *orig_node = NULL;
303 	int hdr_size = sizeof(struct batadv_icmp_header);
304 	int ret = NET_RX_DROP;
305 
306 	/* drop packet if it has not necessary minimum size */
307 	if (unlikely(!pskb_may_pull(skb, hdr_size)))
308 		goto out;
309 
310 	ethhdr = eth_hdr(skb);
311 
312 	/* packet with unicast indication but broadcast recipient */
313 	if (is_broadcast_ether_addr(ethhdr->h_dest))
314 		goto out;
315 
316 	/* packet with broadcast sender address */
317 	if (is_broadcast_ether_addr(ethhdr->h_source))
318 		goto out;
319 
320 	/* not for me */
321 	if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
322 		goto out;
323 
324 	icmph = (struct batadv_icmp_header *)skb->data;
325 
326 	/* add record route information if not full */
327 	if ((icmph->msg_type == BATADV_ECHO_REPLY ||
328 	     icmph->msg_type == BATADV_ECHO_REQUEST) &&
329 	    (skb->len >= sizeof(struct batadv_icmp_packet_rr))) {
330 		if (skb_linearize(skb) < 0)
331 			goto out;
332 
333 		/* create a copy of the skb, if needed, to modify it. */
334 		if (skb_cow(skb, ETH_HLEN) < 0)
335 			goto out;
336 
337 		icmph = (struct batadv_icmp_header *)skb->data;
338 		icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmph;
339 		if (icmp_packet_rr->rr_cur >= BATADV_RR_LEN)
340 			goto out;
341 
342 		ether_addr_copy(icmp_packet_rr->rr[icmp_packet_rr->rr_cur],
343 				ethhdr->h_dest);
344 		icmp_packet_rr->rr_cur++;
345 	}
346 
347 	/* packet for me */
348 	if (batadv_is_my_mac(bat_priv, icmph->dst))
349 		return batadv_recv_my_icmp_packet(bat_priv, skb);
350 
351 	/* TTL exceeded */
352 	if (icmph->ttl < 2)
353 		return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
354 
355 	/* get routing information */
356 	orig_node = batadv_orig_hash_find(bat_priv, icmph->dst);
357 	if (!orig_node)
358 		goto out;
359 
360 	/* create a copy of the skb, if needed, to modify it. */
361 	if (skb_cow(skb, ETH_HLEN) < 0)
362 		goto out;
363 
364 	icmph = (struct batadv_icmp_header *)skb->data;
365 
366 	/* decrement ttl */
367 	icmph->ttl--;
368 
369 	/* route it */
370 	if (batadv_send_skb_to_orig(skb, orig_node, recv_if) != NET_XMIT_DROP)
371 		ret = NET_RX_SUCCESS;
372 
373 out:
374 	if (orig_node)
375 		batadv_orig_node_free_ref(orig_node);
376 	return ret;
377 }
378 
379 /**
380  * batadv_check_unicast_packet - Check for malformed unicast packets
381  * @bat_priv: the bat priv with all the soft interface information
382  * @skb: packet to check
383  * @hdr_size: size of header to pull
384  *
385  * Check for short header and bad addresses in given packet. Returns negative
386  * value when check fails and 0 otherwise. The negative value depends on the
387  * reason: -ENODATA for bad header, -EBADR for broadcast destination or source,
388  * and -EREMOTE for non-local (other host) destination.
389  */
390 static int batadv_check_unicast_packet(struct batadv_priv *bat_priv,
391 				       struct sk_buff *skb, int hdr_size)
392 {
393 	struct ethhdr *ethhdr;
394 
395 	/* drop packet if it has not necessary minimum size */
396 	if (unlikely(!pskb_may_pull(skb, hdr_size)))
397 		return -ENODATA;
398 
399 	ethhdr = eth_hdr(skb);
400 
401 	/* packet with unicast indication but broadcast recipient */
402 	if (is_broadcast_ether_addr(ethhdr->h_dest))
403 		return -EBADR;
404 
405 	/* packet with broadcast sender address */
406 	if (is_broadcast_ether_addr(ethhdr->h_source))
407 		return -EBADR;
408 
409 	/* not for me */
410 	if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
411 		return -EREMOTE;
412 
413 	return 0;
414 }
415 
416 /**
417  * batadv_find_router - find a suitable router for this originator
418  * @bat_priv: the bat priv with all the soft interface information
419  * @orig_node: the destination node
420  * @recv_if: pointer to interface this packet was received on
421  *
422  * Returns the router which should be used for this orig_node on
423  * this interface, or NULL if not available.
424  */
425 struct batadv_neigh_node *
426 batadv_find_router(struct batadv_priv *bat_priv,
427 		   struct batadv_orig_node *orig_node,
428 		   struct batadv_hard_iface *recv_if)
429 {
430 	struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
431 	struct batadv_neigh_node *first_candidate_router = NULL;
432 	struct batadv_neigh_node *next_candidate_router = NULL;
433 	struct batadv_neigh_node *router, *cand_router = NULL;
434 	struct batadv_neigh_node *last_cand_router = NULL;
435 	struct batadv_orig_ifinfo *cand, *first_candidate = NULL;
436 	struct batadv_orig_ifinfo *next_candidate = NULL;
437 	struct batadv_orig_ifinfo *last_candidate;
438 	bool last_candidate_found = false;
439 
440 	if (!orig_node)
441 		return NULL;
442 
443 	router = batadv_orig_router_get(orig_node, recv_if);
444 
445 	if (!router)
446 		return router;
447 
448 	/* only consider bonding for recv_if == BATADV_IF_DEFAULT (first hop)
449 	 * and if activated.
450 	 */
451 	if (!(recv_if == BATADV_IF_DEFAULT && atomic_read(&bat_priv->bonding)))
452 		return router;
453 
454 	/* bonding: loop through the list of possible routers found
455 	 * for the various outgoing interfaces and find a candidate after
456 	 * the last chosen bonding candidate (next_candidate). If no such
457 	 * router is found, use the first candidate found (the previously
458 	 * chosen bonding candidate might have been the last one in the list).
459 	 * If this can't be found either, return the previously chosen
460 	 * router - obviously there are no other candidates.
461 	 */
462 	rcu_read_lock();
463 	last_candidate = orig_node->last_bonding_candidate;
464 	if (last_candidate)
465 		last_cand_router = rcu_dereference(last_candidate->router);
466 
467 	hlist_for_each_entry_rcu(cand, &orig_node->ifinfo_list, list) {
468 		/* acquire some structures and references ... */
469 		if (!atomic_inc_not_zero(&cand->refcount))
470 			continue;
471 
472 		cand_router = rcu_dereference(cand->router);
473 		if (!cand_router)
474 			goto next;
475 
476 		if (!atomic_inc_not_zero(&cand_router->refcount)) {
477 			cand_router = NULL;
478 			goto next;
479 		}
480 
481 		/* alternative candidate should be good enough to be
482 		 * considered
483 		 */
484 		if (!bao->bat_neigh_is_equiv_or_better(cand_router,
485 						       cand->if_outgoing,
486 						       router, recv_if))
487 			goto next;
488 
489 		/* don't use the same router twice */
490 		if (last_cand_router == cand_router)
491 			goto next;
492 
493 		/* mark the first possible candidate */
494 		if (!first_candidate) {
495 			atomic_inc(&cand_router->refcount);
496 			atomic_inc(&cand->refcount);
497 			first_candidate = cand;
498 			first_candidate_router = cand_router;
499 		}
500 
501 		/* check if the loop has already passed the previously selected
502 		 * candidate ... this function should select the next candidate
503 		 * AFTER the previously used bonding candidate.
504 		 */
505 		if (!last_candidate || last_candidate_found) {
506 			next_candidate = cand;
507 			next_candidate_router = cand_router;
508 			break;
509 		}
510 
511 		if (last_candidate == cand)
512 			last_candidate_found = true;
513 next:
514 		/* free references */
515 		if (cand_router) {
516 			batadv_neigh_node_free_ref(cand_router);
517 			cand_router = NULL;
518 		}
519 		batadv_orig_ifinfo_free_ref(cand);
520 	}
521 	rcu_read_unlock();
522 
523 	/* last_bonding_candidate is reset below, remove the old reference. */
524 	if (orig_node->last_bonding_candidate)
525 		batadv_orig_ifinfo_free_ref(orig_node->last_bonding_candidate);
526 
527 	/* After finding candidates, handle the three cases:
528 	 * 1) there is a next candidate, use that
529 	 * 2) there is no next candidate, use the first of the list
530 	 * 3) there is no candidate at all, return the default router
531 	 */
532 	if (next_candidate) {
533 		batadv_neigh_node_free_ref(router);
534 
535 		/* remove references to first candidate, we don't need it. */
536 		if (first_candidate) {
537 			batadv_neigh_node_free_ref(first_candidate_router);
538 			batadv_orig_ifinfo_free_ref(first_candidate);
539 		}
540 		router = next_candidate_router;
541 		orig_node->last_bonding_candidate = next_candidate;
542 	} else if (first_candidate) {
543 		batadv_neigh_node_free_ref(router);
544 
545 		/* refcounting has already been done in the loop above. */
546 		router = first_candidate_router;
547 		orig_node->last_bonding_candidate = first_candidate;
548 	} else {
549 		orig_node->last_bonding_candidate = NULL;
550 	}
551 
552 	return router;
553 }
554 
555 static int batadv_route_unicast_packet(struct sk_buff *skb,
556 				       struct batadv_hard_iface *recv_if)
557 {
558 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
559 	struct batadv_orig_node *orig_node = NULL;
560 	struct batadv_unicast_packet *unicast_packet;
561 	struct ethhdr *ethhdr = eth_hdr(skb);
562 	int res, hdr_len, ret = NET_RX_DROP;
563 
564 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
565 
566 	/* TTL exceeded */
567 	if (unicast_packet->ttl < 2) {
568 		pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
569 			 ethhdr->h_source, unicast_packet->dest);
570 		goto out;
571 	}
572 
573 	/* get routing information */
574 	orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
575 
576 	if (!orig_node)
577 		goto out;
578 
579 	/* create a copy of the skb, if needed, to modify it. */
580 	if (skb_cow(skb, ETH_HLEN) < 0)
581 		goto out;
582 
583 	/* decrement ttl */
584 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
585 	unicast_packet->ttl--;
586 
587 	switch (unicast_packet->packet_type) {
588 	case BATADV_UNICAST_4ADDR:
589 		hdr_len = sizeof(struct batadv_unicast_4addr_packet);
590 		break;
591 	case BATADV_UNICAST:
592 		hdr_len = sizeof(struct batadv_unicast_packet);
593 		break;
594 	default:
595 		/* other packet types not supported - yet */
596 		hdr_len = -1;
597 		break;
598 	}
599 
600 	if (hdr_len > 0)
601 		batadv_skb_set_priority(skb, hdr_len);
602 
603 	res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
604 
605 	/* translate transmit result into receive result */
606 	if (res == NET_XMIT_SUCCESS) {
607 		/* skb was transmitted and consumed */
608 		batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
609 		batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
610 				   skb->len + ETH_HLEN);
611 
612 		ret = NET_RX_SUCCESS;
613 	} else if (res == NET_XMIT_POLICED) {
614 		/* skb was buffered and consumed */
615 		ret = NET_RX_SUCCESS;
616 	}
617 
618 out:
619 	if (orig_node)
620 		batadv_orig_node_free_ref(orig_node);
621 	return ret;
622 }
623 
624 /**
625  * batadv_reroute_unicast_packet - update the unicast header for re-routing
626  * @bat_priv: the bat priv with all the soft interface information
627  * @unicast_packet: the unicast header to be updated
628  * @dst_addr: the payload destination
629  * @vid: VLAN identifier
630  *
631  * Search the translation table for dst_addr and update the unicast header with
632  * the new corresponding information (originator address where the destination
633  * client currently is and its known TTVN)
634  *
635  * Returns true if the packet header has been updated, false otherwise
636  */
637 static bool
638 batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
639 			      struct batadv_unicast_packet *unicast_packet,
640 			      uint8_t *dst_addr, unsigned short vid)
641 {
642 	struct batadv_orig_node *orig_node = NULL;
643 	struct batadv_hard_iface *primary_if = NULL;
644 	bool ret = false;
645 	uint8_t *orig_addr, orig_ttvn;
646 
647 	if (batadv_is_my_client(bat_priv, dst_addr, vid)) {
648 		primary_if = batadv_primary_if_get_selected(bat_priv);
649 		if (!primary_if)
650 			goto out;
651 		orig_addr = primary_if->net_dev->dev_addr;
652 		orig_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
653 	} else {
654 		orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr,
655 						     vid);
656 		if (!orig_node)
657 			goto out;
658 
659 		if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
660 			goto out;
661 
662 		orig_addr = orig_node->orig;
663 		orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
664 	}
665 
666 	/* update the packet header */
667 	ether_addr_copy(unicast_packet->dest, orig_addr);
668 	unicast_packet->ttvn = orig_ttvn;
669 
670 	ret = true;
671 out:
672 	if (primary_if)
673 		batadv_hardif_free_ref(primary_if);
674 	if (orig_node)
675 		batadv_orig_node_free_ref(orig_node);
676 
677 	return ret;
678 }
679 
680 static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
681 				     struct sk_buff *skb, int hdr_len) {
682 	struct batadv_unicast_packet *unicast_packet;
683 	struct batadv_hard_iface *primary_if;
684 	struct batadv_orig_node *orig_node;
685 	uint8_t curr_ttvn, old_ttvn;
686 	struct ethhdr *ethhdr;
687 	unsigned short vid;
688 	int is_old_ttvn;
689 
690 	/* check if there is enough data before accessing it */
691 	if (!pskb_may_pull(skb, hdr_len + ETH_HLEN))
692 		return 0;
693 
694 	/* create a copy of the skb (in case of for re-routing) to modify it. */
695 	if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
696 		return 0;
697 
698 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
699 	vid = batadv_get_vid(skb, hdr_len);
700 	ethhdr = (struct ethhdr *)(skb->data + hdr_len);
701 
702 	/* check if the destination client was served by this node and it is now
703 	 * roaming. In this case, it means that the node has got a ROAM_ADV
704 	 * message and that it knows the new destination in the mesh to re-route
705 	 * the packet to
706 	 */
707 	if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) {
708 		if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
709 						  ethhdr->h_dest, vid))
710 			batadv_dbg_ratelimited(BATADV_DBG_TT,
711 					       bat_priv,
712 					       "Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
713 					       unicast_packet->dest,
714 					       ethhdr->h_dest);
715 		/* at this point the mesh destination should have been
716 		 * substituted with the originator address found in the global
717 		 * table. If not, let the packet go untouched anyway because
718 		 * there is nothing the node can do
719 		 */
720 		return 1;
721 	}
722 
723 	/* retrieve the TTVN known by this node for the packet destination. This
724 	 * value is used later to check if the node which sent (or re-routed
725 	 * last time) the packet had an updated information or not
726 	 */
727 	curr_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
728 	if (!batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
729 		orig_node = batadv_orig_hash_find(bat_priv,
730 						  unicast_packet->dest);
731 		/* if it is not possible to find the orig_node representing the
732 		 * destination, the packet can immediately be dropped as it will
733 		 * not be possible to deliver it
734 		 */
735 		if (!orig_node)
736 			return 0;
737 
738 		curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
739 		batadv_orig_node_free_ref(orig_node);
740 	}
741 
742 	/* check if the TTVN contained in the packet is fresher than what the
743 	 * node knows
744 	 */
745 	is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
746 	if (!is_old_ttvn)
747 		return 1;
748 
749 	old_ttvn = unicast_packet->ttvn;
750 	/* the packet was forged based on outdated network information. Its
751 	 * destination can possibly be updated and forwarded towards the new
752 	 * target host
753 	 */
754 	if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
755 					  ethhdr->h_dest, vid)) {
756 		batadv_dbg_ratelimited(BATADV_DBG_TT, bat_priv,
757 				       "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
758 				       unicast_packet->dest, ethhdr->h_dest,
759 				       old_ttvn, curr_ttvn);
760 		return 1;
761 	}
762 
763 	/* the packet has not been re-routed: either the destination is
764 	 * currently served by this node or there is no destination at all and
765 	 * it is possible to drop the packet
766 	 */
767 	if (!batadv_is_my_client(bat_priv, ethhdr->h_dest, vid))
768 		return 0;
769 
770 	/* update the header in order to let the packet be delivered to this
771 	 * node's soft interface
772 	 */
773 	primary_if = batadv_primary_if_get_selected(bat_priv);
774 	if (!primary_if)
775 		return 0;
776 
777 	ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
778 
779 	batadv_hardif_free_ref(primary_if);
780 
781 	unicast_packet->ttvn = curr_ttvn;
782 
783 	return 1;
784 }
785 
786 /**
787  * batadv_recv_unhandled_unicast_packet - receive and process packets which
788  *	are in the unicast number space but not yet known to the implementation
789  * @skb: unicast tvlv packet to process
790  * @recv_if: pointer to interface this packet was received on
791  *
792  * Returns NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
793  * otherwise.
794  */
795 int batadv_recv_unhandled_unicast_packet(struct sk_buff *skb,
796 					 struct batadv_hard_iface *recv_if)
797 {
798 	struct batadv_unicast_packet *unicast_packet;
799 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
800 	int check, hdr_size = sizeof(*unicast_packet);
801 
802 	check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
803 	if (check < 0)
804 		return NET_RX_DROP;
805 
806 	/* we don't know about this type, drop it. */
807 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
808 	if (batadv_is_my_mac(bat_priv, unicast_packet->dest))
809 		return NET_RX_DROP;
810 
811 	return batadv_route_unicast_packet(skb, recv_if);
812 }
813 
814 int batadv_recv_unicast_packet(struct sk_buff *skb,
815 			       struct batadv_hard_iface *recv_if)
816 {
817 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
818 	struct batadv_unicast_packet *unicast_packet;
819 	struct batadv_unicast_4addr_packet *unicast_4addr_packet;
820 	uint8_t *orig_addr;
821 	struct batadv_orig_node *orig_node = NULL;
822 	int check, hdr_size = sizeof(*unicast_packet);
823 	bool is4addr;
824 
825 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
826 	unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
827 
828 	is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR;
829 	/* the caller function should have already pulled 2 bytes */
830 	if (is4addr)
831 		hdr_size = sizeof(*unicast_4addr_packet);
832 
833 	/* function returns -EREMOTE for promiscuous packets */
834 	check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
835 
836 	/* Even though the packet is not for us, we might save it to use for
837 	 * decoding a later received coded packet
838 	 */
839 	if (check == -EREMOTE)
840 		batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);
841 
842 	if (check < 0)
843 		return NET_RX_DROP;
844 	if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
845 		return NET_RX_DROP;
846 
847 	/* packet for me */
848 	if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
849 		if (is4addr) {
850 			batadv_dat_inc_counter(bat_priv,
851 					       unicast_4addr_packet->subtype);
852 			orig_addr = unicast_4addr_packet->src;
853 			orig_node = batadv_orig_hash_find(bat_priv, orig_addr);
854 		}
855 
856 		if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
857 							  hdr_size))
858 			goto rx_success;
859 		if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
860 							hdr_size))
861 			goto rx_success;
862 
863 		batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
864 				    orig_node);
865 
866 rx_success:
867 		if (orig_node)
868 			batadv_orig_node_free_ref(orig_node);
869 
870 		return NET_RX_SUCCESS;
871 	}
872 
873 	return batadv_route_unicast_packet(skb, recv_if);
874 }
875 
876 /**
877  * batadv_recv_unicast_tvlv - receive and process unicast tvlv packets
878  * @skb: unicast tvlv packet to process
879  * @recv_if: pointer to interface this packet was received on
880  * @dst_addr: the payload destination
881  *
882  * Returns NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
883  * otherwise.
884  */
885 int batadv_recv_unicast_tvlv(struct sk_buff *skb,
886 			     struct batadv_hard_iface *recv_if)
887 {
888 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
889 	struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
890 	unsigned char *tvlv_buff;
891 	uint16_t tvlv_buff_len;
892 	int hdr_size = sizeof(*unicast_tvlv_packet);
893 	int ret = NET_RX_DROP;
894 
895 	if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
896 		return NET_RX_DROP;
897 
898 	/* the header is likely to be modified while forwarding */
899 	if (skb_cow(skb, hdr_size) < 0)
900 		return NET_RX_DROP;
901 
902 	/* packet needs to be linearized to access the tvlv content */
903 	if (skb_linearize(skb) < 0)
904 		return NET_RX_DROP;
905 
906 	unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)skb->data;
907 
908 	tvlv_buff = (unsigned char *)(skb->data + hdr_size);
909 	tvlv_buff_len = ntohs(unicast_tvlv_packet->tvlv_len);
910 
911 	if (tvlv_buff_len > skb->len - hdr_size)
912 		return NET_RX_DROP;
913 
914 	ret = batadv_tvlv_containers_process(bat_priv, false, NULL,
915 					     unicast_tvlv_packet->src,
916 					     unicast_tvlv_packet->dst,
917 					     tvlv_buff, tvlv_buff_len);
918 
919 	if (ret != NET_RX_SUCCESS)
920 		ret = batadv_route_unicast_packet(skb, recv_if);
921 	else
922 		consume_skb(skb);
923 
924 	return ret;
925 }
926 
927 /**
928  * batadv_recv_frag_packet - process received fragment
929  * @skb: the received fragment
930  * @recv_if: interface that the skb is received on
931  *
932  * This function does one of the three following things: 1) Forward fragment, if
933  * the assembled packet will exceed our MTU; 2) Buffer fragment, if we till
934  * lack further fragments; 3) Merge fragments, if we have all needed parts.
935  *
936  * Return NET_RX_DROP if the skb is not consumed, NET_RX_SUCCESS otherwise.
937  */
938 int batadv_recv_frag_packet(struct sk_buff *skb,
939 			    struct batadv_hard_iface *recv_if)
940 {
941 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
942 	struct batadv_orig_node *orig_node_src = NULL;
943 	struct batadv_frag_packet *frag_packet;
944 	int ret = NET_RX_DROP;
945 
946 	if (batadv_check_unicast_packet(bat_priv, skb,
947 					sizeof(*frag_packet)) < 0)
948 		goto out;
949 
950 	frag_packet = (struct batadv_frag_packet *)skb->data;
951 	orig_node_src = batadv_orig_hash_find(bat_priv, frag_packet->orig);
952 	if (!orig_node_src)
953 		goto out;
954 
955 	/* Route the fragment if it is not for us and too big to be merged. */
956 	if (!batadv_is_my_mac(bat_priv, frag_packet->dest) &&
957 	    batadv_frag_skb_fwd(skb, recv_if, orig_node_src)) {
958 		ret = NET_RX_SUCCESS;
959 		goto out;
960 	}
961 
962 	batadv_inc_counter(bat_priv, BATADV_CNT_FRAG_RX);
963 	batadv_add_counter(bat_priv, BATADV_CNT_FRAG_RX_BYTES, skb->len);
964 
965 	/* Add fragment to buffer and merge if possible. */
966 	if (!batadv_frag_skb_buffer(&skb, orig_node_src))
967 		goto out;
968 
969 	/* Deliver merged packet to the appropriate handler, if it was
970 	 * merged
971 	 */
972 	if (skb)
973 		batadv_batman_skb_recv(skb, recv_if->net_dev,
974 				       &recv_if->batman_adv_ptype, NULL);
975 
976 	ret = NET_RX_SUCCESS;
977 
978 out:
979 	if (orig_node_src)
980 		batadv_orig_node_free_ref(orig_node_src);
981 
982 	return ret;
983 }
984 
985 int batadv_recv_bcast_packet(struct sk_buff *skb,
986 			     struct batadv_hard_iface *recv_if)
987 {
988 	struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
989 	struct batadv_orig_node *orig_node = NULL;
990 	struct batadv_bcast_packet *bcast_packet;
991 	struct ethhdr *ethhdr;
992 	int hdr_size = sizeof(*bcast_packet);
993 	int ret = NET_RX_DROP;
994 	int32_t seq_diff;
995 	uint32_t seqno;
996 
997 	/* drop packet if it has not necessary minimum size */
998 	if (unlikely(!pskb_may_pull(skb, hdr_size)))
999 		goto out;
1000 
1001 	ethhdr = eth_hdr(skb);
1002 
1003 	/* packet with broadcast indication but unicast recipient */
1004 	if (!is_broadcast_ether_addr(ethhdr->h_dest))
1005 		goto out;
1006 
1007 	/* packet with broadcast sender address */
1008 	if (is_broadcast_ether_addr(ethhdr->h_source))
1009 		goto out;
1010 
1011 	/* ignore broadcasts sent by myself */
1012 	if (batadv_is_my_mac(bat_priv, ethhdr->h_source))
1013 		goto out;
1014 
1015 	bcast_packet = (struct batadv_bcast_packet *)skb->data;
1016 
1017 	/* ignore broadcasts originated by myself */
1018 	if (batadv_is_my_mac(bat_priv, bcast_packet->orig))
1019 		goto out;
1020 
1021 	if (bcast_packet->ttl < 2)
1022 		goto out;
1023 
1024 	orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1025 
1026 	if (!orig_node)
1027 		goto out;
1028 
1029 	spin_lock_bh(&orig_node->bcast_seqno_lock);
1030 
1031 	seqno = ntohl(bcast_packet->seqno);
1032 	/* check whether the packet is a duplicate */
1033 	if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1034 			    seqno))
1035 		goto spin_unlock;
1036 
1037 	seq_diff = seqno - orig_node->last_bcast_seqno;
1038 
1039 	/* check whether the packet is old and the host just restarted. */
1040 	if (batadv_window_protected(bat_priv, seq_diff,
1041 				    &orig_node->bcast_seqno_reset))
1042 		goto spin_unlock;
1043 
1044 	/* mark broadcast in flood history, update window position
1045 	 * if required.
1046 	 */
1047 	if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1048 		orig_node->last_bcast_seqno = seqno;
1049 
1050 	spin_unlock_bh(&orig_node->bcast_seqno_lock);
1051 
1052 	/* check whether this has been sent by another originator before */
1053 	if (batadv_bla_check_bcast_duplist(bat_priv, skb))
1054 		goto out;
1055 
1056 	batadv_skb_set_priority(skb, sizeof(struct batadv_bcast_packet));
1057 
1058 	/* rebroadcast packet */
1059 	batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1060 
1061 	/* don't hand the broadcast up if it is from an originator
1062 	 * from the same backbone.
1063 	 */
1064 	if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1065 		goto out;
1066 
1067 	if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
1068 		goto rx_success;
1069 	if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
1070 		goto rx_success;
1071 
1072 	/* broadcast for me */
1073 	batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1074 			    orig_node);
1075 
1076 rx_success:
1077 	ret = NET_RX_SUCCESS;
1078 	goto out;
1079 
1080 spin_unlock:
1081 	spin_unlock_bh(&orig_node->bcast_seqno_lock);
1082 out:
1083 	if (orig_node)
1084 		batadv_orig_node_free_ref(orig_node);
1085 	return ret;
1086 }
1087