blob: e3857ed4057f55d2f90ff72ed7cb8a14532d6fe2 [file] [log] [blame]
Sven Eckelmann0046b042016-01-01 00:01:03 +01001/* Copyright (C) 2007-2016 B.A.T.M.A.N. contributors:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00002 *
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
Antonio Quartulliebf38fb2013-11-03 20:40:48 +010015 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000016 */
17
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000018#include "routing.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020019#include "main.h"
20
21#include <linux/atomic.h>
22#include <linux/byteorder/generic.h>
23#include <linux/compiler.h>
24#include <linux/errno.h>
25#include <linux/etherdevice.h>
26#include <linux/if_ether.h>
27#include <linux/jiffies.h>
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +010028#include <linux/kref.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020029#include <linux/netdevice.h>
30#include <linux/printk.h>
31#include <linux/rculist.h>
32#include <linux/rcupdate.h>
33#include <linux/skbuff.h>
34#include <linux/spinlock.h>
35#include <linux/stddef.h>
36
37#include "bitarray.h"
Simon Wunderlich23721382012-01-22 20:00:19 +010038#include "bridge_loop_avoidance.h"
Antonio Quartullic384ea32011-06-26 03:37:18 +020039#include "distributed-arp-table.h"
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +020040#include "fragmentation.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020041#include "hard-interface.h"
42#include "icmp_socket.h"
43#include "network-coding.h"
44#include "originator.h"
45#include "packet.h"
46#include "send.h"
47#include "soft-interface.h"
48#include "translation-table.h"
Antonio Quartullic018ad32013-06-04 12:11:39 +020049
Sven Eckelmann63b01032012-05-16 20:23:13 +020050static int batadv_route_unicast_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +020051 struct batadv_hard_iface *recv_if);
Simon Wunderlicha7f6ee92012-01-22 20:00:18 +010052
Simon Wunderlich7351a4822013-11-13 19:14:47 +010053/**
54 * _batadv_update_route - set the router for this originator
55 * @bat_priv: the bat priv with all the soft interface information
56 * @orig_node: orig node which is to be configured
57 * @recv_if: the receive interface for which this route is set
58 * @neigh_node: neighbor which should be the next router
59 *
60 * This function does not perform any error checks
61 */
Sven Eckelmann56303d32012-06-05 22:31:31 +020062static void _batadv_update_route(struct batadv_priv *bat_priv,
63 struct batadv_orig_node *orig_node,
Simon Wunderlich7351a4822013-11-13 19:14:47 +010064 struct batadv_hard_iface *recv_if,
Sven Eckelmann56303d32012-06-05 22:31:31 +020065 struct batadv_neigh_node *neigh_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000066{
Simon Wunderlich7351a4822013-11-13 19:14:47 +010067 struct batadv_orig_ifinfo *orig_ifinfo;
Sven Eckelmann56303d32012-06-05 22:31:31 +020068 struct batadv_neigh_node *curr_router;
Linus Lüssinge1a5382f2011-03-14 22:43:37 +000069
Simon Wunderlich7351a4822013-11-13 19:14:47 +010070 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, recv_if);
71 if (!orig_ifinfo)
72 return;
73
74 rcu_read_lock();
75 curr_router = rcu_dereference(orig_ifinfo->router);
Sven Eckelmann77ae32e2016-01-16 10:29:53 +010076 if (curr_router && !kref_get_unless_zero(&curr_router->refcount))
Simon Wunderlich7351a4822013-11-13 19:14:47 +010077 curr_router = NULL;
78 rcu_read_unlock();
Marek Lindnera8e7f4b2010-12-12 21:57:10 +000079
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000080 /* route deleted */
Linus Lüssinge1a5382f2011-03-14 22:43:37 +000081 if ((curr_router) && (!neigh_node)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +020082 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
83 "Deleting route towards: %pM\n", orig_node->orig);
Antonio Quartulli95fb1302013-08-07 18:28:55 +020084 batadv_tt_global_del_orig(bat_priv, orig_node, -1,
Sven Eckelmann08c36d32012-05-12 02:09:39 +020085 "Deleted route towards originator");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000086
Linus Lüssinge1a5382f2011-03-14 22:43:37 +000087 /* route added */
88 } else if ((!curr_router) && (neigh_node)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +020089 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +020090 "Adding route towards: %pM (via %pM)\n",
91 orig_node->orig, neigh_node->addr);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +000092 /* route changed */
Sven Eckelmannbb899b82011-05-10 11:22:37 +020093 } else if (neigh_node && curr_router) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +020094 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +020095 "Changing route towards: %pM (now via %pM - was via %pM)\n",
96 orig_node->orig, neigh_node->addr,
97 curr_router->addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000098 }
99
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000100 if (curr_router)
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100101 batadv_neigh_node_put(curr_router);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000102
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000103 spin_lock_bh(&orig_node->neigh_list_lock);
Sven Eckelmannd1a65f12016-03-20 12:27:53 +0100104 /* curr_router used earlier may not be the current orig_ifinfo->router
105 * anymore because it was dereferenced outside of the neigh_list_lock
106 * protected region. After the new best neighbor has replace the current
107 * best neighbor the reference counter needs to decrease. Consequently,
108 * the code needs to ensure the curr_router variable contains a pointer
109 * to the replaced best neighbor.
110 */
111 curr_router = rcu_dereference_protected(orig_ifinfo->router, true);
112
Sven Eckelmannf0b94eb2016-03-05 19:05:24 +0100113 /* increase refcount of new best neighbor */
114 if (neigh_node)
115 kref_get(&neigh_node->refcount);
116
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100117 rcu_assign_pointer(orig_ifinfo->router, neigh_node);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000118 spin_unlock_bh(&orig_node->neigh_list_lock);
Sven Eckelmann35f94772016-01-17 11:01:13 +0100119 batadv_orig_ifinfo_put(orig_ifinfo);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000120
121 /* decrease refcount of previous best neighbor */
122 if (curr_router)
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100123 batadv_neigh_node_put(curr_router);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000124}
125
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100126/**
127 * batadv_update_route - set the router for this originator
128 * @bat_priv: the bat priv with all the soft interface information
129 * @orig_node: orig node which is to be configured
130 * @recv_if: the receive interface for which this route is set
131 * @neigh_node: neighbor which should be the next router
132 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200133void batadv_update_route(struct batadv_priv *bat_priv,
134 struct batadv_orig_node *orig_node,
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100135 struct batadv_hard_iface *recv_if,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200136 struct batadv_neigh_node *neigh_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000137{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200138 struct batadv_neigh_node *router = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000139
140 if (!orig_node)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000141 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000142
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100143 router = batadv_orig_router_get(orig_node, recv_if);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000144
145 if (router != neigh_node)
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100146 _batadv_update_route(bat_priv, orig_node, recv_if, neigh_node);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000147
148out:
149 if (router)
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100150 batadv_neigh_node_put(router);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000151}
152
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200153/**
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100154 * batadv_window_protected - checks whether the host restarted and is in the
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200155 * protection time.
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100156 * @bat_priv: the bat priv with all the soft interface information
157 * @seq_num_diff: difference between the current/received sequence number and
158 * the last sequence number
Simon Wunderlich81f02682015-11-23 19:57:22 +0100159 * @seq_old_max_diff: maximum age of sequence number not considered as restart
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100160 * @last_reset: jiffies timestamp of the last reset, will be updated when reset
161 * is detected
Simon Wunderlich81f02682015-11-23 19:57:22 +0100162 * @protection_started: is set to true if the protection window was started,
163 * doesn't change otherwise.
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200164 *
165 * Return:
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100166 * false if the packet is to be accepted.
167 * true if the packet is to be ignored.
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000168 */
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100169bool batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
170 s32 seq_old_max_diff, unsigned long *last_reset,
171 bool *protection_started)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000172{
Simon Wunderlich81f02682015-11-23 19:57:22 +0100173 if (seq_num_diff <= -seq_old_max_diff ||
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200174 seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
175 if (!batadv_has_timed_out(*last_reset,
176 BATADV_RESET_PROTECTION_MS))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100177 return true;
Marek Lindner8c7bf242012-03-17 15:28:33 +0800178
179 *last_reset = jiffies;
Simon Wunderlich81f02682015-11-23 19:57:22 +0100180 if (protection_started)
181 *protection_started = true;
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200182 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200183 "old packet received, start protection\n");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000184 }
Marek Lindner8c7bf242012-03-17 15:28:33 +0800185
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100186 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000187}
188
Sven Eckelmann30d3c512012-05-12 02:09:36 +0200189bool batadv_check_management_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200190 struct batadv_hard_iface *hard_iface,
Sven Eckelmann30d3c512012-05-12 02:09:36 +0200191 int header_len)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000192{
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000193 struct ethhdr *ethhdr;
194
195 /* drop packet if it has not necessary minimum size */
Marek Lindnerc3e29312012-03-04 16:56:25 +0800196 if (unlikely(!pskb_may_pull(skb, header_len)))
197 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000198
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200199 ethhdr = eth_hdr(skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000200
201 /* packet with broadcast indication but unicast recipient */
202 if (!is_broadcast_ether_addr(ethhdr->h_dest))
Marek Lindnerc3e29312012-03-04 16:56:25 +0800203 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000204
205 /* packet with broadcast sender address */
206 if (is_broadcast_ether_addr(ethhdr->h_source))
Marek Lindnerc3e29312012-03-04 16:56:25 +0800207 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000208
209 /* create a copy of the skb, if needed, to modify it. */
210 if (skb_cow(skb, 0) < 0)
Marek Lindnerc3e29312012-03-04 16:56:25 +0800211 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000212
213 /* keep skb linear */
214 if (skb_linearize(skb) < 0)
Marek Lindnerc3e29312012-03-04 16:56:25 +0800215 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000216
Marek Lindnerc3e29312012-03-04 16:56:25 +0800217 return true;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000218}
219
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200220/**
221 * batadv_recv_my_icmp_packet - receive an icmp packet locally
222 * @bat_priv: the bat priv with all the soft interface information
223 * @skb: icmp packet to process
224 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200225 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200226 * otherwise.
227 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200228static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200229 struct sk_buff *skb)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000230{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200231 struct batadv_hard_iface *primary_if = NULL;
232 struct batadv_orig_node *orig_node = NULL;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200233 struct batadv_icmp_header *icmph;
234 int res, ret = NET_RX_DROP;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000235
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200236 icmph = (struct batadv_icmp_header *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000237
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200238 switch (icmph->msg_type) {
239 case BATADV_ECHO_REPLY:
240 case BATADV_DESTINATION_UNREACHABLE:
241 case BATADV_TTL_EXCEEDED:
242 /* receive the packet */
243 if (skb_linearize(skb) < 0)
244 break;
245
246 batadv_socket_receive_packet(icmph, skb->len);
247 break;
248 case BATADV_ECHO_REQUEST:
249 /* answer echo request (ping) */
250 primary_if = batadv_primary_if_get_selected(bat_priv);
251 if (!primary_if)
252 goto out;
253
254 /* get routing information */
255 orig_node = batadv_orig_hash_find(bat_priv, icmph->orig);
256 if (!orig_node)
257 goto out;
258
259 /* create a copy of the skb, if needed, to modify it. */
260 if (skb_cow(skb, ETH_HLEN) < 0)
261 goto out;
262
263 icmph = (struct batadv_icmp_header *)skb->data;
264
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100265 ether_addr_copy(icmph->dst, icmph->orig);
266 ether_addr_copy(icmph->orig, primary_if->net_dev->dev_addr);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200267 icmph->msg_type = BATADV_ECHO_REPLY;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100268 icmph->ttl = BATADV_TTL;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200269
270 res = batadv_send_skb_to_orig(skb, orig_node, NULL);
271 if (res != NET_XMIT_DROP)
272 ret = NET_RX_SUCCESS;
273
274 break;
275 default:
276 /* drop unknown type */
Marek Lindner44524fc2011-02-10 14:33:53 +0000277 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000278 }
Marek Lindner44524fc2011-02-10 14:33:53 +0000279out:
Marek Lindner32ae9b22011-04-20 15:40:58 +0200280 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100281 batadv_hardif_put(primary_if);
Marek Lindner44524fc2011-02-10 14:33:53 +0000282 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100283 batadv_orig_node_put(orig_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000284 return ret;
285}
286
Sven Eckelmann56303d32012-06-05 22:31:31 +0200287static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
Sven Eckelmann63b01032012-05-16 20:23:13 +0200288 struct sk_buff *skb)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000289{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200290 struct batadv_hard_iface *primary_if = NULL;
291 struct batadv_orig_node *orig_node = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +0200292 struct batadv_icmp_packet *icmp_packet;
Marek Lindner44524fc2011-02-10 14:33:53 +0000293 int ret = NET_RX_DROP;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000294
Sven Eckelmann96412692012-06-05 22:31:30 +0200295 icmp_packet = (struct batadv_icmp_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000296
297 /* send TTL exceeded if packet is an echo request (traceroute) */
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100298 if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100299 pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100300 icmp_packet->orig, icmp_packet->dst);
Marek Lindner44524fc2011-02-10 14:33:53 +0000301 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000302 }
303
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200304 primary_if = batadv_primary_if_get_selected(bat_priv);
Marek Lindner32ae9b22011-04-20 15:40:58 +0200305 if (!primary_if)
Marek Lindner44524fc2011-02-10 14:33:53 +0000306 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000307
308 /* get routing information */
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100309 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
Marek Lindner44524fc2011-02-10 14:33:53 +0000310 if (!orig_node)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000311 goto out;
Marek Lindner44524fc2011-02-10 14:33:53 +0000312
Marek Lindner44524fc2011-02-10 14:33:53 +0000313 /* create a copy of the skb, if needed, to modify it. */
Antonio Quartulli0d125072012-02-18 11:27:34 +0100314 if (skb_cow(skb, ETH_HLEN) < 0)
Marek Lindner44524fc2011-02-10 14:33:53 +0000315 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000316
Sven Eckelmann96412692012-06-05 22:31:30 +0200317 icmp_packet = (struct batadv_icmp_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000318
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100319 ether_addr_copy(icmp_packet->dst, icmp_packet->orig);
320 ether_addr_copy(icmp_packet->orig, primary_if->net_dev->dev_addr);
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100321 icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
322 icmp_packet->ttl = BATADV_TTL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000323
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200324 if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
Martin Hundebøllbb351ba2012-10-16 16:13:48 +0200325 ret = NET_RX_SUCCESS;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000326
Marek Lindner44524fc2011-02-10 14:33:53 +0000327out:
Marek Lindner32ae9b22011-04-20 15:40:58 +0200328 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100329 batadv_hardif_put(primary_if);
Marek Lindner44524fc2011-02-10 14:33:53 +0000330 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100331 batadv_orig_node_put(orig_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000332 return ret;
333}
334
Sven Eckelmann56303d32012-06-05 22:31:31 +0200335int batadv_recv_icmp_packet(struct sk_buff *skb,
336 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000337{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200338 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200339 struct batadv_icmp_header *icmph;
340 struct batadv_icmp_packet_rr *icmp_packet_rr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000341 struct ethhdr *ethhdr;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200342 struct batadv_orig_node *orig_node = NULL;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200343 int hdr_size = sizeof(struct batadv_icmp_header);
Marek Lindner44524fc2011-02-10 14:33:53 +0000344 int ret = NET_RX_DROP;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000345
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000346 /* drop packet if it has not necessary minimum size */
347 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Marek Lindner44524fc2011-02-10 14:33:53 +0000348 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000349
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200350 ethhdr = eth_hdr(skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000351
352 /* packet with unicast indication but broadcast recipient */
353 if (is_broadcast_ether_addr(ethhdr->h_dest))
Marek Lindner44524fc2011-02-10 14:33:53 +0000354 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000355
356 /* packet with broadcast sender address */
357 if (is_broadcast_ether_addr(ethhdr->h_source))
Marek Lindner44524fc2011-02-10 14:33:53 +0000358 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000359
360 /* not for me */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200361 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
Marek Lindner44524fc2011-02-10 14:33:53 +0000362 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000363
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200364 icmph = (struct batadv_icmp_header *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000365
366 /* add record route information if not full */
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200367 if ((icmph->msg_type == BATADV_ECHO_REPLY ||
368 icmph->msg_type == BATADV_ECHO_REQUEST) &&
369 (skb->len >= sizeof(struct batadv_icmp_packet_rr))) {
370 if (skb_linearize(skb) < 0)
371 goto out;
372
373 /* create a copy of the skb, if needed, to modify it. */
374 if (skb_cow(skb, ETH_HLEN) < 0)
375 goto out;
376
377 icmph = (struct batadv_icmp_header *)skb->data;
378 icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmph;
379 if (icmp_packet_rr->rr_cur >= BATADV_RR_LEN)
380 goto out;
381
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100382 ether_addr_copy(icmp_packet_rr->rr[icmp_packet_rr->rr_cur],
383 ethhdr->h_dest);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200384 icmp_packet_rr->rr_cur++;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000385 }
386
387 /* packet for me */
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200388 if (batadv_is_my_mac(bat_priv, icmph->dst))
389 return batadv_recv_my_icmp_packet(bat_priv, skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000390
391 /* TTL exceeded */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100392 if (icmph->ttl < 2)
Sven Eckelmann63b01032012-05-16 20:23:13 +0200393 return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000394
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000395 /* get routing information */
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200396 orig_node = batadv_orig_hash_find(bat_priv, icmph->dst);
Marek Lindner44524fc2011-02-10 14:33:53 +0000397 if (!orig_node)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000398 goto out;
Marek Lindner44524fc2011-02-10 14:33:53 +0000399
Marek Lindner44524fc2011-02-10 14:33:53 +0000400 /* create a copy of the skb, if needed, to modify it. */
Antonio Quartulli0d125072012-02-18 11:27:34 +0100401 if (skb_cow(skb, ETH_HLEN) < 0)
Marek Lindner44524fc2011-02-10 14:33:53 +0000402 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000403
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200404 icmph = (struct batadv_icmp_header *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000405
Marek Lindner44524fc2011-02-10 14:33:53 +0000406 /* decrement ttl */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100407 icmph->ttl--;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000408
Marek Lindner44524fc2011-02-10 14:33:53 +0000409 /* route it */
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200410 if (batadv_send_skb_to_orig(skb, orig_node, recv_if) != NET_XMIT_DROP)
Martin Hundebøllbb351ba2012-10-16 16:13:48 +0200411 ret = NET_RX_SUCCESS;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000412
Marek Lindner44524fc2011-02-10 14:33:53 +0000413out:
Marek Lindner44524fc2011-02-10 14:33:53 +0000414 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100415 batadv_orig_node_put(orig_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000416 return ret;
417}
418
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100419/**
420 * batadv_check_unicast_packet - Check for malformed unicast packets
David S. Miller6e0895c2013-04-22 20:32:51 -0400421 * @bat_priv: the bat priv with all the soft interface information
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100422 * @skb: packet to check
423 * @hdr_size: size of header to pull
424 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200425 * Check for short header and bad addresses in given packet.
426 *
427 * Return: negative value when check fails and 0 otherwise. The negative value
428 * depends on the reason: -ENODATA for bad header, -EBADR for broadcast
429 * destination or source, and -EREMOTE for non-local (other host) destination.
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100430 */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200431static int batadv_check_unicast_packet(struct batadv_priv *bat_priv,
432 struct sk_buff *skb, int hdr_size)
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200433{
434 struct ethhdr *ethhdr;
435
436 /* drop packet if it has not necessary minimum size */
437 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100438 return -ENODATA;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200439
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200440 ethhdr = eth_hdr(skb);
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200441
442 /* packet with unicast indication but broadcast recipient */
443 if (is_broadcast_ether_addr(ethhdr->h_dest))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100444 return -EBADR;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200445
446 /* packet with broadcast sender address */
447 if (is_broadcast_ether_addr(ethhdr->h_source))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100448 return -EBADR;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200449
450 /* not for me */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200451 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100452 return -EREMOTE;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200453
454 return 0;
455}
456
Simon Wunderlichf6c8b712013-11-13 19:14:45 +0100457/**
458 * batadv_find_router - find a suitable router for this originator
459 * @bat_priv: the bat priv with all the soft interface information
460 * @orig_node: the destination node
461 * @recv_if: pointer to interface this packet was received on
462 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200463 * Return: the router which should be used for this orig_node on
Simon Wunderlichf6c8b712013-11-13 19:14:45 +0100464 * this interface, or NULL if not available.
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200465 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200466struct batadv_neigh_node *
467batadv_find_router(struct batadv_priv *bat_priv,
468 struct batadv_orig_node *orig_node,
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100469 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000470{
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100471 struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
472 struct batadv_neigh_node *first_candidate_router = NULL;
473 struct batadv_neigh_node *next_candidate_router = NULL;
474 struct batadv_neigh_node *router, *cand_router = NULL;
475 struct batadv_neigh_node *last_cand_router = NULL;
476 struct batadv_orig_ifinfo *cand, *first_candidate = NULL;
477 struct batadv_orig_ifinfo *next_candidate = NULL;
478 struct batadv_orig_ifinfo *last_candidate;
479 bool last_candidate_found = false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000480
481 if (!orig_node)
482 return NULL;
483
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100484 router = batadv_orig_router_get(orig_node, recv_if);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000485
Simon Wunderlich329887a2014-08-13 14:26:56 +0200486 if (!router)
487 return router;
488
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100489 /* only consider bonding for recv_if == BATADV_IF_DEFAULT (first hop)
490 * and if activated.
491 */
Simon Wunderlich329887a2014-08-13 14:26:56 +0200492 if (!(recv_if == BATADV_IF_DEFAULT && atomic_read(&bat_priv->bonding)))
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100493 return router;
494
495 /* bonding: loop through the list of possible routers found
496 * for the various outgoing interfaces and find a candidate after
497 * the last chosen bonding candidate (next_candidate). If no such
498 * router is found, use the first candidate found (the previously
499 * chosen bonding candidate might have been the last one in the list).
Antonio Quartulli3f687852014-11-02 11:29:56 +0100500 * If this can't be found either, return the previously chosen
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100501 * router - obviously there are no other candidates.
502 */
503 rcu_read_lock();
504 last_candidate = orig_node->last_bonding_candidate;
505 if (last_candidate)
506 last_cand_router = rcu_dereference(last_candidate->router);
507
508 hlist_for_each_entry_rcu(cand, &orig_node->ifinfo_list, list) {
509 /* acquire some structures and references ... */
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100510 if (!kref_get_unless_zero(&cand->refcount))
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100511 continue;
512
513 cand_router = rcu_dereference(cand->router);
514 if (!cand_router)
515 goto next;
516
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100517 if (!kref_get_unless_zero(&cand_router->refcount)) {
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100518 cand_router = NULL;
519 goto next;
520 }
521
522 /* alternative candidate should be good enough to be
523 * considered
524 */
Simon Wunderlich18165f62015-08-08 02:01:50 +0200525 if (!bao->bat_neigh_is_similar_or_better(cand_router,
526 cand->if_outgoing,
527 router, recv_if))
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100528 goto next;
529
530 /* don't use the same router twice */
531 if (last_cand_router == cand_router)
532 goto next;
533
534 /* mark the first possible candidate */
535 if (!first_candidate) {
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100536 kref_get(&cand_router->refcount);
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100537 kref_get(&cand->refcount);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100538 first_candidate = cand;
539 first_candidate_router = cand_router;
540 }
541
542 /* check if the loop has already passed the previously selected
543 * candidate ... this function should select the next candidate
544 * AFTER the previously used bonding candidate.
545 */
546 if (!last_candidate || last_candidate_found) {
547 next_candidate = cand;
548 next_candidate_router = cand_router;
549 break;
550 }
551
552 if (last_candidate == cand)
553 last_candidate_found = true;
554next:
555 /* free references */
556 if (cand_router) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100557 batadv_neigh_node_put(cand_router);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100558 cand_router = NULL;
559 }
Sven Eckelmann35f94772016-01-17 11:01:13 +0100560 batadv_orig_ifinfo_put(cand);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100561 }
562 rcu_read_unlock();
563
564 /* last_bonding_candidate is reset below, remove the old reference. */
565 if (orig_node->last_bonding_candidate)
Sven Eckelmann35f94772016-01-17 11:01:13 +0100566 batadv_orig_ifinfo_put(orig_node->last_bonding_candidate);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100567
568 /* After finding candidates, handle the three cases:
569 * 1) there is a next candidate, use that
570 * 2) there is no next candidate, use the first of the list
571 * 3) there is no candidate at all, return the default router
572 */
573 if (next_candidate) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100574 batadv_neigh_node_put(router);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100575
576 /* remove references to first candidate, we don't need it. */
577 if (first_candidate) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100578 batadv_neigh_node_put(first_candidate_router);
Sven Eckelmann35f94772016-01-17 11:01:13 +0100579 batadv_orig_ifinfo_put(first_candidate);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100580 }
581 router = next_candidate_router;
582 orig_node->last_bonding_candidate = next_candidate;
583 } else if (first_candidate) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100584 batadv_neigh_node_put(router);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100585
586 /* refcounting has already been done in the loop above. */
587 router = first_candidate_router;
588 orig_node->last_bonding_candidate = first_candidate;
589 } else {
590 orig_node->last_bonding_candidate = NULL;
591 }
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000592
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000593 return router;
594}
595
Sven Eckelmann63b01032012-05-16 20:23:13 +0200596static int batadv_route_unicast_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200597 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000598{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200599 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
600 struct batadv_orig_node *orig_node = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +0200601 struct batadv_unicast_packet *unicast_packet;
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200602 struct ethhdr *ethhdr = eth_hdr(skb);
Simon Wunderlichc54f38c92013-07-29 17:56:44 +0200603 int res, hdr_len, ret = NET_RX_DROP;
Florian Westphal63d443e2016-05-10 23:17:59 +0200604 unsigned int len;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000605
Sven Eckelmann96412692012-06-05 22:31:30 +0200606 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000607
608 /* TTL exceeded */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100609 if (unicast_packet->ttl < 2) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100610 pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
611 ethhdr->h_source, unicast_packet->dest);
Marek Lindner44524fc2011-02-10 14:33:53 +0000612 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000613 }
614
615 /* get routing information */
Sven Eckelmannda641192012-05-12 13:48:56 +0200616 orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
Marek Lindner7aadf882011-02-18 12:28:09 +0000617
Marek Lindner44524fc2011-02-10 14:33:53 +0000618 if (!orig_node)
Antonio Quartullib5a6f692011-04-16 11:30:57 +0200619 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000620
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000621 /* create a copy of the skb, if needed, to modify it. */
Antonio Quartulli0d125072012-02-18 11:27:34 +0100622 if (skb_cow(skb, ETH_HLEN) < 0)
Marek Lindner44524fc2011-02-10 14:33:53 +0000623 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000624
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000625 /* decrement ttl */
Martin Hundebøllf097e252013-05-23 16:53:01 +0200626 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100627 unicast_packet->ttl--;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000628
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100629 switch (unicast_packet->packet_type) {
Simon Wunderlichc54f38c92013-07-29 17:56:44 +0200630 case BATADV_UNICAST_4ADDR:
631 hdr_len = sizeof(struct batadv_unicast_4addr_packet);
632 break;
633 case BATADV_UNICAST:
634 hdr_len = sizeof(struct batadv_unicast_packet);
635 break;
636 default:
637 /* other packet types not supported - yet */
638 hdr_len = -1;
639 break;
640 }
641
642 if (hdr_len > 0)
643 batadv_skb_set_priority(skb, hdr_len);
644
Florian Westphal63d443e2016-05-10 23:17:59 +0200645 len = skb->len;
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200646 res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
Martin Hundebøll95332472013-01-25 11:12:40 +0100647
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200648 /* translate transmit result into receive result */
649 if (res == NET_XMIT_SUCCESS) {
650 /* skb was transmitted and consumed */
Martin Hundebøll95332472013-01-25 11:12:40 +0100651 batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
652 batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
Florian Westphal63d443e2016-05-10 23:17:59 +0200653 len + ETH_HLEN);
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200654
655 ret = NET_RX_SUCCESS;
656 } else if (res == NET_XMIT_POLICED) {
657 /* skb was buffered and consumed */
658 ret = NET_RX_SUCCESS;
Martin Hundebøll95332472013-01-25 11:12:40 +0100659 }
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000660
Marek Lindner44524fc2011-02-10 14:33:53 +0000661out:
Marek Lindner44524fc2011-02-10 14:33:53 +0000662 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100663 batadv_orig_node_put(orig_node);
Marek Lindner44524fc2011-02-10 14:33:53 +0000664 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000665}
666
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200667/**
668 * batadv_reroute_unicast_packet - update the unicast header for re-routing
669 * @bat_priv: the bat priv with all the soft interface information
670 * @unicast_packet: the unicast header to be updated
671 * @dst_addr: the payload destination
Antonio Quartullic018ad32013-06-04 12:11:39 +0200672 * @vid: VLAN identifier
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200673 *
674 * Search the translation table for dst_addr and update the unicast header with
675 * the new corresponding information (originator address where the destination
676 * client currently is and its known TTVN)
677 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200678 * Return: true if the packet header has been updated, false otherwise
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200679 */
680static bool
681batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
682 struct batadv_unicast_packet *unicast_packet,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200683 u8 *dst_addr, unsigned short vid)
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200684{
685 struct batadv_orig_node *orig_node = NULL;
686 struct batadv_hard_iface *primary_if = NULL;
687 bool ret = false;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200688 u8 *orig_addr, orig_ttvn;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200689
Antonio Quartullic018ad32013-06-04 12:11:39 +0200690 if (batadv_is_my_client(bat_priv, dst_addr, vid)) {
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200691 primary_if = batadv_primary_if_get_selected(bat_priv);
692 if (!primary_if)
693 goto out;
694 orig_addr = primary_if->net_dev->dev_addr;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200695 orig_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200696 } else {
Antonio Quartullic018ad32013-06-04 12:11:39 +0200697 orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr,
698 vid);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200699 if (!orig_node)
700 goto out;
701
702 if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
703 goto out;
704
705 orig_addr = orig_node->orig;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200706 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200707 }
708
709 /* update the packet header */
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100710 ether_addr_copy(unicast_packet->dest, orig_addr);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200711 unicast_packet->ttvn = orig_ttvn;
712
713 ret = true;
714out:
715 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100716 batadv_hardif_put(primary_if);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200717 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100718 batadv_orig_node_put(orig_node);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200719
720 return ret;
721}
722
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100723static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
724 struct sk_buff *skb, int hdr_len)
725{
Sven Eckelmann96412692012-06-05 22:31:30 +0200726 struct batadv_unicast_packet *unicast_packet;
Antonio Quartullic018ad32013-06-04 12:11:39 +0200727 struct batadv_hard_iface *primary_if;
728 struct batadv_orig_node *orig_node;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200729 u8 curr_ttvn, old_ttvn;
Antonio Quartullic018ad32013-06-04 12:11:39 +0200730 struct ethhdr *ethhdr;
731 unsigned short vid;
Sven Eckelmann3e348192012-05-16 20:23:22 +0200732 int is_old_ttvn;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200733
Antonio Quartullib8fcfa42012-08-26 23:25:59 +0200734 /* check if there is enough data before accessing it */
Antonio Quartullif1791422014-01-30 00:12:24 +0100735 if (!pskb_may_pull(skb, hdr_len + ETH_HLEN))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100736 return false;
Antonio Quartullib8fcfa42012-08-26 23:25:59 +0200737
738 /* create a copy of the skb (in case of for re-routing) to modify it. */
739 if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100740 return false;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200741
Sven Eckelmann96412692012-06-05 22:31:30 +0200742 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Antonio Quartullic018ad32013-06-04 12:11:39 +0200743 vid = batadv_get_vid(skb, hdr_len);
Antonio Quartullidd981ab2013-04-03 10:14:20 +0200744 ethhdr = (struct ethhdr *)(skb->data + hdr_len);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200745
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200746 /* check if the destination client was served by this node and it is now
747 * roaming. In this case, it means that the node has got a ROAM_ADV
748 * message and that it knows the new destination in the mesh to re-route
749 * the packet to
750 */
Antonio Quartullic018ad32013-06-04 12:11:39 +0200751 if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) {
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200752 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
Antonio Quartullic018ad32013-06-04 12:11:39 +0200753 ethhdr->h_dest, vid))
André Gaul23c4ec12014-06-10 17:50:31 +0200754 batadv_dbg_ratelimited(BATADV_DBG_TT,
755 bat_priv,
756 "Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
757 unicast_packet->dest,
758 ethhdr->h_dest);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200759 /* at this point the mesh destination should have been
760 * substituted with the originator address found in the global
761 * table. If not, let the packet go untouched anyway because
762 * there is nothing the node can do
763 */
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100764 return true;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200765 }
766
767 /* retrieve the TTVN known by this node for the packet destination. This
768 * value is used later to check if the node which sent (or re-routed
769 * last time) the packet had an updated information or not
770 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200771 curr_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200772 if (!batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
Sven Eckelmannda641192012-05-12 13:48:56 +0200773 orig_node = batadv_orig_hash_find(bat_priv,
774 unicast_packet->dest);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200775 /* if it is not possible to find the orig_node representing the
776 * destination, the packet can immediately be dropped as it will
777 * not be possible to deliver it
778 */
Antonio Quartullia73105b2011-04-27 14:27:44 +0200779 if (!orig_node)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100780 return false;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200781
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200782 curr_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
Sven Eckelmann5d967312016-01-17 11:01:09 +0100783 batadv_orig_node_put(orig_node);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200784 }
785
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200786 /* check if the TTVN contained in the packet is fresher than what the
787 * node knows
788 */
Sven Eckelmann3e348192012-05-16 20:23:22 +0200789 is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200790 if (!is_old_ttvn)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100791 return true;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200792
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200793 old_ttvn = unicast_packet->ttvn;
794 /* the packet was forged based on outdated network information. Its
795 * destination can possibly be updated and forwarded towards the new
796 * target host
797 */
798 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
Antonio Quartullic018ad32013-06-04 12:11:39 +0200799 ethhdr->h_dest, vid)) {
André Gaul23c4ec12014-06-10 17:50:31 +0200800 batadv_dbg_ratelimited(BATADV_DBG_TT, bat_priv,
801 "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
802 unicast_packet->dest, ethhdr->h_dest,
803 old_ttvn, curr_ttvn);
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100804 return true;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200805 }
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200806
807 /* the packet has not been re-routed: either the destination is
808 * currently served by this node or there is no destination at all and
809 * it is possible to drop the packet
810 */
Antonio Quartullic018ad32013-06-04 12:11:39 +0200811 if (!batadv_is_my_client(bat_priv, ethhdr->h_dest, vid))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100812 return false;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200813
814 /* update the header in order to let the packet be delivered to this
815 * node's soft interface
816 */
817 primary_if = batadv_primary_if_get_selected(bat_priv);
818 if (!primary_if)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100819 return false;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200820
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100821 ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200822
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100823 batadv_hardif_put(primary_if);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200824
825 unicast_packet->ttvn = curr_ttvn;
826
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100827 return true;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200828}
829
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200830/**
831 * batadv_recv_unhandled_unicast_packet - receive and process packets which
832 * are in the unicast number space but not yet known to the implementation
833 * @skb: unicast tvlv packet to process
834 * @recv_if: pointer to interface this packet was received on
835 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200836 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200837 * otherwise.
838 */
839int batadv_recv_unhandled_unicast_packet(struct sk_buff *skb,
840 struct batadv_hard_iface *recv_if)
841{
842 struct batadv_unicast_packet *unicast_packet;
843 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
844 int check, hdr_size = sizeof(*unicast_packet);
845
846 check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
847 if (check < 0)
848 return NET_RX_DROP;
849
850 /* we don't know about this type, drop it. */
851 unicast_packet = (struct batadv_unicast_packet *)skb->data;
852 if (batadv_is_my_mac(bat_priv, unicast_packet->dest))
853 return NET_RX_DROP;
854
855 return batadv_route_unicast_packet(skb, recv_if);
856}
857
Sven Eckelmann56303d32012-06-05 22:31:31 +0200858int batadv_recv_unicast_packet(struct sk_buff *skb,
859 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000860{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200861 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
Sven Eckelmann96412692012-06-05 22:31:30 +0200862 struct batadv_unicast_packet *unicast_packet;
Martin Hundebøll4046b242012-04-20 17:02:45 +0200863 struct batadv_unicast_4addr_packet *unicast_4addr_packet;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200864 u8 *orig_addr;
Antonio Quartulli9affec62012-10-14 17:19:19 +0200865 struct batadv_orig_node *orig_node = NULL;
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100866 int check, hdr_size = sizeof(*unicast_packet);
Simon Wunderlich437bb0e2015-09-02 20:09:54 +0200867 enum batadv_subtype subtype;
Antonio Quartullic384ea32011-06-26 03:37:18 +0200868 bool is4addr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000869
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200870 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Martin Hundebøll4046b242012-04-20 17:02:45 +0200871 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200872
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100873 is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR;
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200874 /* the caller function should have already pulled 2 bytes */
Antonio Quartullic384ea32011-06-26 03:37:18 +0200875 if (is4addr)
Martin Hundebøll4046b242012-04-20 17:02:45 +0200876 hdr_size = sizeof(*unicast_4addr_packet);
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200877
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100878 /* function returns -EREMOTE for promiscuous packets */
David S. Miller6e0895c2013-04-22 20:32:51 -0400879 check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100880
881 /* Even though the packet is not for us, we might save it to use for
882 * decoding a later received coded packet
883 */
884 if (check == -EREMOTE)
885 batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);
886
887 if (check < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000888 return NET_RX_DROP;
Antonio Quartullidd981ab2013-04-03 10:14:20 +0200889 if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
Antonio Quartullia73105b2011-04-27 14:27:44 +0200890 return NET_RX_DROP;
891
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000892 /* packet for me */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200893 if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
Antonio Quartulli9affec62012-10-14 17:19:19 +0200894 if (is4addr) {
Simon Wunderlich437bb0e2015-09-02 20:09:54 +0200895 subtype = unicast_4addr_packet->subtype;
896 batadv_dat_inc_counter(bat_priv, subtype);
897
898 /* Only payload data should be considered for speedy
899 * join. For example, DAT also uses unicast 4addr
900 * types, but those packets should not be considered
901 * for speedy join, since the clients do not actually
902 * reside at the sending originator.
903 */
904 if (subtype == BATADV_P_DATA) {
905 orig_addr = unicast_4addr_packet->src;
906 orig_node = batadv_orig_hash_find(bat_priv,
907 orig_addr);
908 }
Antonio Quartulli9affec62012-10-14 17:19:19 +0200909 }
Martin Hundebøll4046b242012-04-20 17:02:45 +0200910
Antonio Quartullic384ea32011-06-26 03:37:18 +0200911 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
912 hdr_size))
913 goto rx_success;
914 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
915 hdr_size))
916 goto rx_success;
917
Sven Eckelmann6535db52016-02-28 11:38:51 +0100918 batadv_interface_rx(recv_if->soft_iface, skb, hdr_size,
Antonio Quartulli9affec62012-10-14 17:19:19 +0200919 orig_node);
Antonio Quartulli37135172012-07-05 23:38:30 +0200920
Antonio Quartullic384ea32011-06-26 03:37:18 +0200921rx_success:
Antonio Quartulli9affec62012-10-14 17:19:19 +0200922 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100923 batadv_orig_node_put(orig_node);
Antonio Quartulli9affec62012-10-14 17:19:19 +0200924
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000925 return NET_RX_SUCCESS;
926 }
927
Sven Eckelmann63b01032012-05-16 20:23:13 +0200928 return batadv_route_unicast_packet(skb, recv_if);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000929}
930
Marek Lindneref261572013-04-23 21:39:57 +0800931/**
932 * batadv_recv_unicast_tvlv - receive and process unicast tvlv packets
933 * @skb: unicast tvlv packet to process
934 * @recv_if: pointer to interface this packet was received on
Marek Lindneref261572013-04-23 21:39:57 +0800935 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200936 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
Marek Lindneref261572013-04-23 21:39:57 +0800937 * otherwise.
938 */
939int batadv_recv_unicast_tvlv(struct sk_buff *skb,
940 struct batadv_hard_iface *recv_if)
941{
942 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
943 struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
944 unsigned char *tvlv_buff;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200945 u16 tvlv_buff_len;
Marek Lindneref261572013-04-23 21:39:57 +0800946 int hdr_size = sizeof(*unicast_tvlv_packet);
947 int ret = NET_RX_DROP;
948
949 if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
950 return NET_RX_DROP;
951
952 /* the header is likely to be modified while forwarding */
953 if (skb_cow(skb, hdr_size) < 0)
954 return NET_RX_DROP;
955
956 /* packet needs to be linearized to access the tvlv content */
957 if (skb_linearize(skb) < 0)
958 return NET_RX_DROP;
959
960 unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)skb->data;
961
962 tvlv_buff = (unsigned char *)(skb->data + hdr_size);
963 tvlv_buff_len = ntohs(unicast_tvlv_packet->tvlv_len);
964
965 if (tvlv_buff_len > skb->len - hdr_size)
966 return NET_RX_DROP;
967
968 ret = batadv_tvlv_containers_process(bat_priv, false, NULL,
969 unicast_tvlv_packet->src,
970 unicast_tvlv_packet->dst,
971 tvlv_buff, tvlv_buff_len);
972
973 if (ret != NET_RX_SUCCESS)
974 ret = batadv_route_unicast_packet(skb, recv_if);
Antonio Quartulli05c3c8a2014-02-11 17:05:07 +0100975 else
976 consume_skb(skb);
Marek Lindneref261572013-04-23 21:39:57 +0800977
978 return ret;
979}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000980
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200981/**
982 * batadv_recv_frag_packet - process received fragment
983 * @skb: the received fragment
984 * @recv_if: interface that the skb is received on
985 *
986 * This function does one of the three following things: 1) Forward fragment, if
987 * the assembled packet will exceed our MTU; 2) Buffer fragment, if we till
988 * lack further fragments; 3) Merge fragments, if we have all needed parts.
989 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200990 * Return: NET_RX_DROP if the skb is not consumed, NET_RX_SUCCESS otherwise.
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200991 */
992int batadv_recv_frag_packet(struct sk_buff *skb,
993 struct batadv_hard_iface *recv_if)
994{
995 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
996 struct batadv_orig_node *orig_node_src = NULL;
997 struct batadv_frag_packet *frag_packet;
998 int ret = NET_RX_DROP;
999
1000 if (batadv_check_unicast_packet(bat_priv, skb,
1001 sizeof(*frag_packet)) < 0)
1002 goto out;
1003
1004 frag_packet = (struct batadv_frag_packet *)skb->data;
1005 orig_node_src = batadv_orig_hash_find(bat_priv, frag_packet->orig);
1006 if (!orig_node_src)
1007 goto out;
1008
1009 /* Route the fragment if it is not for us and too big to be merged. */
1010 if (!batadv_is_my_mac(bat_priv, frag_packet->dest) &&
1011 batadv_frag_skb_fwd(skb, recv_if, orig_node_src)) {
1012 ret = NET_RX_SUCCESS;
1013 goto out;
1014 }
1015
1016 batadv_inc_counter(bat_priv, BATADV_CNT_FRAG_RX);
1017 batadv_add_counter(bat_priv, BATADV_CNT_FRAG_RX_BYTES, skb->len);
1018
1019 /* Add fragment to buffer and merge if possible. */
1020 if (!batadv_frag_skb_buffer(&skb, orig_node_src))
1021 goto out;
1022
1023 /* Deliver merged packet to the appropriate handler, if it was
1024 * merged
1025 */
1026 if (skb)
1027 batadv_batman_skb_recv(skb, recv_if->net_dev,
1028 &recv_if->batman_adv_ptype, NULL);
1029
1030 ret = NET_RX_SUCCESS;
1031
1032out:
1033 if (orig_node_src)
Sven Eckelmann5d967312016-01-17 11:01:09 +01001034 batadv_orig_node_put(orig_node_src);
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001035
1036 return ret;
1037}
1038
Sven Eckelmann56303d32012-06-05 22:31:31 +02001039int batadv_recv_bcast_packet(struct sk_buff *skb,
1040 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001041{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001042 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1043 struct batadv_orig_node *orig_node = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +02001044 struct batadv_bcast_packet *bcast_packet;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001045 struct ethhdr *ethhdr;
Sven Eckelmann704509b2011-05-14 23:14:54 +02001046 int hdr_size = sizeof(*bcast_packet);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001047 int ret = NET_RX_DROP;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001048 s32 seq_diff;
1049 u32 seqno;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001050
1051 /* drop packet if it has not necessary minimum size */
1052 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001053 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001054
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001055 ethhdr = eth_hdr(skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001056
1057 /* packet with broadcast indication but unicast recipient */
1058 if (!is_broadcast_ether_addr(ethhdr->h_dest))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001059 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001060
1061 /* packet with broadcast sender address */
1062 if (is_broadcast_ether_addr(ethhdr->h_source))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001063 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001064
1065 /* ignore broadcasts sent by myself */
Antonio Quartullife8a93b2013-04-03 19:10:26 +02001066 if (batadv_is_my_mac(bat_priv, ethhdr->h_source))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001067 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001068
Sven Eckelmann96412692012-06-05 22:31:30 +02001069 bcast_packet = (struct batadv_bcast_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001070
1071 /* ignore broadcasts originated by myself */
Antonio Quartullife8a93b2013-04-03 19:10:26 +02001072 if (batadv_is_my_mac(bat_priv, bcast_packet->orig))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001073 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001074
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001075 if (bcast_packet->ttl < 2)
Marek Lindnerf3e00082011-01-25 21:52:11 +00001076 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001077
Sven Eckelmannda641192012-05-12 13:48:56 +02001078 orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001079
1080 if (!orig_node)
Antonio Quartullib5a6f692011-04-16 11:30:57 +02001081 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001082
Marek Lindnerf3e00082011-01-25 21:52:11 +00001083 spin_lock_bh(&orig_node->bcast_seqno_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001084
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001085 seqno = ntohl(bcast_packet->seqno);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001086 /* check whether the packet is a duplicate */
Sven Eckelmann9b4a1152012-05-12 13:48:53 +02001087 if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001088 seqno))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001089 goto spin_unlock;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001090
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001091 seq_diff = seqno - orig_node->last_bcast_seqno;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001092
1093 /* check whether the packet is old and the host just restarted. */
Sven Eckelmann30d3c512012-05-12 02:09:36 +02001094 if (batadv_window_protected(bat_priv, seq_diff,
Simon Wunderlich81f02682015-11-23 19:57:22 +01001095 BATADV_BCAST_MAX_AGE,
1096 &orig_node->bcast_seqno_reset, NULL))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001097 goto spin_unlock;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001098
1099 /* mark broadcast in flood history, update window position
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001100 * if required.
1101 */
Sven Eckelmann0f5f93222012-05-12 02:09:25 +02001102 if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001103 orig_node->last_bcast_seqno = seqno;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001104
Marek Lindnerf3e00082011-01-25 21:52:11 +00001105 spin_unlock_bh(&orig_node->bcast_seqno_lock);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001106
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001107 /* check whether this has been sent by another originator before */
Simon Wunderlich004e86f2012-10-18 13:47:42 +02001108 if (batadv_bla_check_bcast_duplist(bat_priv, skb))
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001109 goto out;
1110
Simon Wunderlichc54f38c92013-07-29 17:56:44 +02001111 batadv_skb_set_priority(skb, sizeof(struct batadv_bcast_packet));
1112
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001113 /* rebroadcast packet */
Sven Eckelmann9455e342012-05-12 02:09:37 +02001114 batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001115
Simon Wunderlich23721382012-01-22 20:00:19 +01001116 /* don't hand the broadcast up if it is from an originator
1117 * from the same backbone.
1118 */
Sven Eckelmann08adf152012-05-12 13:38:47 +02001119 if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
Simon Wunderlich23721382012-01-22 20:00:19 +01001120 goto out;
1121
Antonio Quartullic384ea32011-06-26 03:37:18 +02001122 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
1123 goto rx_success;
1124 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
1125 goto rx_success;
1126
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001127 /* broadcast for me */
Sven Eckelmann6535db52016-02-28 11:38:51 +01001128 batadv_interface_rx(recv_if->soft_iface, skb, hdr_size, orig_node);
Antonio Quartullic384ea32011-06-26 03:37:18 +02001129
1130rx_success:
Marek Lindnerf3e00082011-01-25 21:52:11 +00001131 ret = NET_RX_SUCCESS;
1132 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001133
Marek Lindnerf3e00082011-01-25 21:52:11 +00001134spin_unlock:
1135 spin_unlock_bh(&orig_node->bcast_seqno_lock);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001136out:
1137 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +01001138 batadv_orig_node_put(orig_node);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001139 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001140}