blob: 7e8dc648b95a671d5643ac6cd06ca5e572f930a7 [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"
Sven Eckelmannba412082016-05-15 23:48:31 +020043#include "log.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020044#include "network-coding.h"
45#include "originator.h"
46#include "packet.h"
47#include "send.h"
48#include "soft-interface.h"
Antonio Quartulli33a3bb42016-05-05 13:09:43 +020049#include "tp_meter.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020050#include "translation-table.h"
Markus Pargmann1f8dce42016-05-15 11:07:43 +020051#include "tvlv.h"
Antonio Quartullic018ad32013-06-04 12:11:39 +020052
Sven Eckelmann63b01032012-05-16 20:23:13 +020053static int batadv_route_unicast_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +020054 struct batadv_hard_iface *recv_if);
Simon Wunderlicha7f6ee92012-01-22 20:00:18 +010055
Simon Wunderlich7351a4822013-11-13 19:14:47 +010056/**
57 * _batadv_update_route - set the router for this originator
58 * @bat_priv: the bat priv with all the soft interface information
59 * @orig_node: orig node which is to be configured
60 * @recv_if: the receive interface for which this route is set
61 * @neigh_node: neighbor which should be the next router
62 *
63 * This function does not perform any error checks
64 */
Sven Eckelmann56303d32012-06-05 22:31:31 +020065static void _batadv_update_route(struct batadv_priv *bat_priv,
66 struct batadv_orig_node *orig_node,
Simon Wunderlich7351a4822013-11-13 19:14:47 +010067 struct batadv_hard_iface *recv_if,
Sven Eckelmann56303d32012-06-05 22:31:31 +020068 struct batadv_neigh_node *neigh_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000069{
Simon Wunderlich7351a4822013-11-13 19:14:47 +010070 struct batadv_orig_ifinfo *orig_ifinfo;
Sven Eckelmann56303d32012-06-05 22:31:31 +020071 struct batadv_neigh_node *curr_router;
Linus Lüssinge1a5382f2011-03-14 22:43:37 +000072
Simon Wunderlich7351a4822013-11-13 19:14:47 +010073 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, recv_if);
74 if (!orig_ifinfo)
75 return;
76
Sven Eckelmannb5dcbad2016-06-29 23:45:57 +020077 spin_lock_bh(&orig_node->neigh_list_lock);
78 /* curr_router used earlier may not be the current orig_ifinfo->router
79 * anymore because it was dereferenced outside of the neigh_list_lock
80 * protected region. After the new best neighbor has replace the current
81 * best neighbor the reference counter needs to decrease. Consequently,
82 * the code needs to ensure the curr_router variable contains a pointer
83 * to the replaced best neighbor.
84 */
85 curr_router = rcu_dereference_protected(orig_ifinfo->router, true);
86
87 /* increase refcount of new best neighbor */
88 if (neigh_node)
89 kref_get(&neigh_node->refcount);
90
91 rcu_assign_pointer(orig_ifinfo->router, neigh_node);
92 spin_unlock_bh(&orig_node->neigh_list_lock);
93 batadv_orig_ifinfo_put(orig_ifinfo);
Marek Lindnera8e7f4b2010-12-12 21:57:10 +000094
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000095 /* route deleted */
Linus Lüssinge1a5382f2011-03-14 22:43:37 +000096 if ((curr_router) && (!neigh_node)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +020097 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
98 "Deleting route towards: %pM\n", orig_node->orig);
Antonio Quartulli95fb1302013-08-07 18:28:55 +020099 batadv_tt_global_del_orig(bat_priv, orig_node, -1,
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200100 "Deleted route towards originator");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000101
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000102 /* route added */
103 } else if ((!curr_router) && (neigh_node)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200104 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200105 "Adding route towards: %pM (via %pM)\n",
106 orig_node->orig, neigh_node->addr);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000107 /* route changed */
Sven Eckelmannbb899b82011-05-10 11:22:37 +0200108 } else if (neigh_node && curr_router) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200109 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200110 "Changing route towards: %pM (now via %pM - was via %pM)\n",
111 orig_node->orig, neigh_node->addr,
112 curr_router->addr);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000113 }
114
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000115 /* decrease refcount of previous best neighbor */
116 if (curr_router)
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100117 batadv_neigh_node_put(curr_router);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000118}
119
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100120/**
121 * batadv_update_route - set the router for this originator
122 * @bat_priv: the bat priv with all the soft interface information
123 * @orig_node: orig node which is to be configured
124 * @recv_if: the receive interface for which this route is set
125 * @neigh_node: neighbor which should be the next router
126 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200127void batadv_update_route(struct batadv_priv *bat_priv,
128 struct batadv_orig_node *orig_node,
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100129 struct batadv_hard_iface *recv_if,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200130 struct batadv_neigh_node *neigh_node)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000131{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200132 struct batadv_neigh_node *router = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000133
134 if (!orig_node)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000135 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000136
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100137 router = batadv_orig_router_get(orig_node, recv_if);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000138
139 if (router != neigh_node)
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100140 _batadv_update_route(bat_priv, orig_node, recv_if, neigh_node);
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000141
142out:
143 if (router)
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100144 batadv_neigh_node_put(router);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000145}
146
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200147/**
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100148 * batadv_window_protected - checks whether the host restarted and is in the
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200149 * protection time.
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100150 * @bat_priv: the bat priv with all the soft interface information
151 * @seq_num_diff: difference between the current/received sequence number and
152 * the last sequence number
Simon Wunderlich81f02682015-11-23 19:57:22 +0100153 * @seq_old_max_diff: maximum age of sequence number not considered as restart
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100154 * @last_reset: jiffies timestamp of the last reset, will be updated when reset
155 * is detected
Simon Wunderlich81f02682015-11-23 19:57:22 +0100156 * @protection_started: is set to true if the protection window was started,
157 * doesn't change otherwise.
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200158 *
159 * Return:
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100160 * false if the packet is to be accepted.
161 * true if the packet is to be ignored.
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000162 */
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100163bool batadv_window_protected(struct batadv_priv *bat_priv, s32 seq_num_diff,
164 s32 seq_old_max_diff, unsigned long *last_reset,
165 bool *protection_started)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000166{
Simon Wunderlich81f02682015-11-23 19:57:22 +0100167 if (seq_num_diff <= -seq_old_max_diff ||
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200168 seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
169 if (!batadv_has_timed_out(*last_reset,
170 BATADV_RESET_PROTECTION_MS))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100171 return true;
Marek Lindner8c7bf242012-03-17 15:28:33 +0800172
173 *last_reset = jiffies;
Simon Wunderlich81f02682015-11-23 19:57:22 +0100174 if (protection_started)
175 *protection_started = true;
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200176 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200177 "old packet received, start protection\n");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000178 }
Marek Lindner8c7bf242012-03-17 15:28:33 +0800179
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100180 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000181}
182
Sven Eckelmann30d3c512012-05-12 02:09:36 +0200183bool batadv_check_management_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200184 struct batadv_hard_iface *hard_iface,
Sven Eckelmann30d3c512012-05-12 02:09:36 +0200185 int header_len)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000186{
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000187 struct ethhdr *ethhdr;
188
189 /* drop packet if it has not necessary minimum size */
Marek Lindnerc3e29312012-03-04 16:56:25 +0800190 if (unlikely(!pskb_may_pull(skb, header_len)))
191 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000192
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200193 ethhdr = eth_hdr(skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000194
195 /* packet with broadcast indication but unicast recipient */
196 if (!is_broadcast_ether_addr(ethhdr->h_dest))
Marek Lindnerc3e29312012-03-04 16:56:25 +0800197 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000198
199 /* packet with broadcast sender address */
200 if (is_broadcast_ether_addr(ethhdr->h_source))
Marek Lindnerc3e29312012-03-04 16:56:25 +0800201 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000202
203 /* create a copy of the skb, if needed, to modify it. */
204 if (skb_cow(skb, 0) < 0)
Marek Lindnerc3e29312012-03-04 16:56:25 +0800205 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000206
207 /* keep skb linear */
208 if (skb_linearize(skb) < 0)
Marek Lindnerc3e29312012-03-04 16:56:25 +0800209 return false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000210
Marek Lindnerc3e29312012-03-04 16:56:25 +0800211 return true;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000212}
213
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200214/**
215 * batadv_recv_my_icmp_packet - receive an icmp packet locally
216 * @bat_priv: the bat priv with all the soft interface information
217 * @skb: icmp packet to process
218 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200219 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200220 * otherwise.
221 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200222static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200223 struct sk_buff *skb)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000224{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200225 struct batadv_hard_iface *primary_if = NULL;
226 struct batadv_orig_node *orig_node = NULL;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200227 struct batadv_icmp_header *icmph;
228 int res, ret = NET_RX_DROP;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000229
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200230 icmph = (struct batadv_icmp_header *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000231
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200232 switch (icmph->msg_type) {
233 case BATADV_ECHO_REPLY:
234 case BATADV_DESTINATION_UNREACHABLE:
235 case BATADV_TTL_EXCEEDED:
236 /* receive the packet */
237 if (skb_linearize(skb) < 0)
238 break;
239
240 batadv_socket_receive_packet(icmph, skb->len);
241 break;
242 case BATADV_ECHO_REQUEST:
243 /* answer echo request (ping) */
244 primary_if = batadv_primary_if_get_selected(bat_priv);
245 if (!primary_if)
246 goto out;
247
248 /* get routing information */
249 orig_node = batadv_orig_hash_find(bat_priv, icmph->orig);
250 if (!orig_node)
251 goto out;
252
253 /* create a copy of the skb, if needed, to modify it. */
254 if (skb_cow(skb, ETH_HLEN) < 0)
255 goto out;
256
257 icmph = (struct batadv_icmp_header *)skb->data;
258
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100259 ether_addr_copy(icmph->dst, icmph->orig);
260 ether_addr_copy(icmph->orig, primary_if->net_dev->dev_addr);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200261 icmph->msg_type = BATADV_ECHO_REPLY;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100262 icmph->ttl = BATADV_TTL;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200263
264 res = batadv_send_skb_to_orig(skb, orig_node, NULL);
Antonio Quartullif50ca952016-05-18 11:38:48 +0200265 if (res == -1)
266 goto out;
267
268 ret = NET_RX_SUCCESS;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200269
270 break;
Antonio Quartulli33a3bb42016-05-05 13:09:43 +0200271 case BATADV_TP:
272 if (!pskb_may_pull(skb, sizeof(struct batadv_icmp_tp_packet)))
273 goto out;
274
275 batadv_tp_meter_recv(bat_priv, skb);
276 ret = NET_RX_SUCCESS;
277 goto out;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200278 default:
279 /* drop unknown type */
Marek Lindner44524fc2011-02-10 14:33:53 +0000280 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000281 }
Marek Lindner44524fc2011-02-10 14:33:53 +0000282out:
Marek Lindner32ae9b22011-04-20 15:40:58 +0200283 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100284 batadv_hardif_put(primary_if);
Marek Lindner44524fc2011-02-10 14:33:53 +0000285 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100286 batadv_orig_node_put(orig_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000287 return ret;
288}
289
Sven Eckelmann56303d32012-06-05 22:31:31 +0200290static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
Sven Eckelmann63b01032012-05-16 20:23:13 +0200291 struct sk_buff *skb)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000292{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200293 struct batadv_hard_iface *primary_if = NULL;
294 struct batadv_orig_node *orig_node = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +0200295 struct batadv_icmp_packet *icmp_packet;
Antonio Quartullif50ca952016-05-18 11:38:48 +0200296 int res, ret = NET_RX_DROP;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000297
Sven Eckelmann96412692012-06-05 22:31:30 +0200298 icmp_packet = (struct batadv_icmp_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000299
300 /* send TTL exceeded if packet is an echo request (traceroute) */
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100301 if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100302 pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100303 icmp_packet->orig, icmp_packet->dst);
Marek Lindner44524fc2011-02-10 14:33:53 +0000304 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000305 }
306
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200307 primary_if = batadv_primary_if_get_selected(bat_priv);
Marek Lindner32ae9b22011-04-20 15:40:58 +0200308 if (!primary_if)
Marek Lindner44524fc2011-02-10 14:33:53 +0000309 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000310
311 /* get routing information */
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100312 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
Marek Lindner44524fc2011-02-10 14:33:53 +0000313 if (!orig_node)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000314 goto out;
Marek Lindner44524fc2011-02-10 14:33:53 +0000315
Marek Lindner44524fc2011-02-10 14:33:53 +0000316 /* create a copy of the skb, if needed, to modify it. */
Antonio Quartulli0d125072012-02-18 11:27:34 +0100317 if (skb_cow(skb, ETH_HLEN) < 0)
Marek Lindner44524fc2011-02-10 14:33:53 +0000318 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000319
Sven Eckelmann96412692012-06-05 22:31:30 +0200320 icmp_packet = (struct batadv_icmp_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000321
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100322 ether_addr_copy(icmp_packet->dst, icmp_packet->orig);
323 ether_addr_copy(icmp_packet->orig, primary_if->net_dev->dev_addr);
Antonio Quartulli27a417e2013-12-05 15:33:00 +0100324 icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
325 icmp_packet->ttl = BATADV_TTL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000326
Antonio Quartullif50ca952016-05-18 11:38:48 +0200327 res = batadv_send_skb_to_orig(skb, orig_node, NULL);
328 if (res != -1)
Martin Hundebøllbb351ba2012-10-16 16:13:48 +0200329 ret = NET_RX_SUCCESS;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000330
Marek Lindner44524fc2011-02-10 14:33:53 +0000331out:
Marek Lindner32ae9b22011-04-20 15:40:58 +0200332 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100333 batadv_hardif_put(primary_if);
Marek Lindner44524fc2011-02-10 14:33:53 +0000334 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100335 batadv_orig_node_put(orig_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000336 return ret;
337}
338
Sven Eckelmann56303d32012-06-05 22:31:31 +0200339int batadv_recv_icmp_packet(struct sk_buff *skb,
340 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000341{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200342 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200343 struct batadv_icmp_header *icmph;
344 struct batadv_icmp_packet_rr *icmp_packet_rr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000345 struct ethhdr *ethhdr;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200346 struct batadv_orig_node *orig_node = NULL;
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200347 int hdr_size = sizeof(struct batadv_icmp_header);
Antonio Quartullif50ca952016-05-18 11:38:48 +0200348 int res, ret = NET_RX_DROP;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000349
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000350 /* drop packet if it has not necessary minimum size */
351 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Marek Lindner44524fc2011-02-10 14:33:53 +0000352 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000353
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200354 ethhdr = eth_hdr(skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000355
356 /* packet with unicast indication but broadcast recipient */
357 if (is_broadcast_ether_addr(ethhdr->h_dest))
Marek Lindner44524fc2011-02-10 14:33:53 +0000358 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000359
360 /* packet with broadcast sender address */
361 if (is_broadcast_ether_addr(ethhdr->h_source))
Marek Lindner44524fc2011-02-10 14:33:53 +0000362 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000363
364 /* not for me */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200365 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
Marek Lindner44524fc2011-02-10 14:33:53 +0000366 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000367
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200368 icmph = (struct batadv_icmp_header *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000369
370 /* add record route information if not full */
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200371 if ((icmph->msg_type == BATADV_ECHO_REPLY ||
372 icmph->msg_type == BATADV_ECHO_REQUEST) &&
373 (skb->len >= sizeof(struct batadv_icmp_packet_rr))) {
374 if (skb_linearize(skb) < 0)
375 goto out;
376
377 /* create a copy of the skb, if needed, to modify it. */
378 if (skb_cow(skb, ETH_HLEN) < 0)
379 goto out;
380
Sven Eckelmann3b55e442016-06-26 11:16:12 +0200381 ethhdr = eth_hdr(skb);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200382 icmph = (struct batadv_icmp_header *)skb->data;
383 icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmph;
384 if (icmp_packet_rr->rr_cur >= BATADV_RR_LEN)
385 goto out;
386
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100387 ether_addr_copy(icmp_packet_rr->rr[icmp_packet_rr->rr_cur],
388 ethhdr->h_dest);
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200389 icmp_packet_rr->rr_cur++;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000390 }
391
392 /* packet for me */
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200393 if (batadv_is_my_mac(bat_priv, icmph->dst))
394 return batadv_recv_my_icmp_packet(bat_priv, skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000395
396 /* TTL exceeded */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100397 if (icmph->ttl < 2)
Sven Eckelmann63b01032012-05-16 20:23:13 +0200398 return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000399
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000400 /* get routing information */
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200401 orig_node = batadv_orig_hash_find(bat_priv, icmph->dst);
Marek Lindner44524fc2011-02-10 14:33:53 +0000402 if (!orig_node)
Linus Lüssinge1a5382f2011-03-14 22:43:37 +0000403 goto out;
Marek Lindner44524fc2011-02-10 14:33:53 +0000404
Marek Lindner44524fc2011-02-10 14:33:53 +0000405 /* create a copy of the skb, if needed, to modify it. */
Antonio Quartulli0d125072012-02-18 11:27:34 +0100406 if (skb_cow(skb, ETH_HLEN) < 0)
Marek Lindner44524fc2011-02-10 14:33:53 +0000407 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000408
Simon Wunderlichda6b8c22013-10-22 22:50:09 +0200409 icmph = (struct batadv_icmp_header *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000410
Marek Lindner44524fc2011-02-10 14:33:53 +0000411 /* decrement ttl */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100412 icmph->ttl--;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000413
Marek Lindner44524fc2011-02-10 14:33:53 +0000414 /* route it */
Antonio Quartullif50ca952016-05-18 11:38:48 +0200415 res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
416 if (res != -1)
Martin Hundebøllbb351ba2012-10-16 16:13:48 +0200417 ret = NET_RX_SUCCESS;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000418
Marek Lindner44524fc2011-02-10 14:33:53 +0000419out:
Marek Lindner44524fc2011-02-10 14:33:53 +0000420 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100421 batadv_orig_node_put(orig_node);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000422 return ret;
423}
424
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100425/**
426 * batadv_check_unicast_packet - Check for malformed unicast packets
David S. Miller6e0895c2013-04-22 20:32:51 -0400427 * @bat_priv: the bat priv with all the soft interface information
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100428 * @skb: packet to check
429 * @hdr_size: size of header to pull
430 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200431 * Check for short header and bad addresses in given packet.
432 *
433 * Return: negative value when check fails and 0 otherwise. The negative value
434 * depends on the reason: -ENODATA for bad header, -EBADR for broadcast
435 * destination or source, and -EREMOTE for non-local (other host) destination.
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100436 */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200437static int batadv_check_unicast_packet(struct batadv_priv *bat_priv,
438 struct sk_buff *skb, int hdr_size)
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200439{
440 struct ethhdr *ethhdr;
441
442 /* drop packet if it has not necessary minimum size */
443 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100444 return -ENODATA;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200445
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200446 ethhdr = eth_hdr(skb);
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200447
448 /* packet with unicast indication but broadcast recipient */
449 if (is_broadcast_ether_addr(ethhdr->h_dest))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100450 return -EBADR;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200451
452 /* packet with broadcast sender address */
453 if (is_broadcast_ether_addr(ethhdr->h_source))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100454 return -EBADR;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200455
456 /* not for me */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200457 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
Martin Hundebøllf86ce0a2013-01-14 00:20:32 +0100458 return -EREMOTE;
Martin Hundebøllff51fd72012-07-05 11:34:27 +0200459
460 return 0;
461}
462
Simon Wunderlichf6c8b712013-11-13 19:14:45 +0100463/**
Sven Eckelmann93652342016-08-06 15:50:52 +0200464 * batadv_last_bonding_get - Get last_bonding_candidate of orig_node
465 * @orig_node: originator node whose last bonding candidate should be retrieved
466 *
467 * Return: last bonding candidate of router or NULL if not found
468 *
469 * The object is returned with refcounter increased by 1.
470 */
471static struct batadv_orig_ifinfo *
472batadv_last_bonding_get(struct batadv_orig_node *orig_node)
473{
474 struct batadv_orig_ifinfo *last_bonding_candidate;
475
476 spin_lock_bh(&orig_node->neigh_list_lock);
477 last_bonding_candidate = orig_node->last_bonding_candidate;
478
479 if (last_bonding_candidate)
480 kref_get(&last_bonding_candidate->refcount);
481 spin_unlock_bh(&orig_node->neigh_list_lock);
482
483 return last_bonding_candidate;
484}
485
486/**
Sven Eckelmann15c2ed72016-06-30 20:11:34 +0200487 * batadv_last_bonding_replace - Replace last_bonding_candidate of orig_node
488 * @orig_node: originator node whose bonding candidates should be replaced
489 * @new_candidate: new bonding candidate or NULL
490 */
491static void
492batadv_last_bonding_replace(struct batadv_orig_node *orig_node,
493 struct batadv_orig_ifinfo *new_candidate)
494{
495 struct batadv_orig_ifinfo *old_candidate;
496
497 spin_lock_bh(&orig_node->neigh_list_lock);
498 old_candidate = orig_node->last_bonding_candidate;
499
500 if (new_candidate)
501 kref_get(&new_candidate->refcount);
502 orig_node->last_bonding_candidate = new_candidate;
503 spin_unlock_bh(&orig_node->neigh_list_lock);
504
505 if (old_candidate)
506 batadv_orig_ifinfo_put(old_candidate);
507}
508
509/**
Simon Wunderlichf6c8b712013-11-13 19:14:45 +0100510 * batadv_find_router - find a suitable router for this originator
511 * @bat_priv: the bat priv with all the soft interface information
512 * @orig_node: the destination node
513 * @recv_if: pointer to interface this packet was received on
514 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200515 * Return: the router which should be used for this orig_node on
Simon Wunderlichf6c8b712013-11-13 19:14:45 +0100516 * this interface, or NULL if not available.
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200517 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200518struct batadv_neigh_node *
519batadv_find_router(struct batadv_priv *bat_priv,
520 struct batadv_orig_node *orig_node,
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100521 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000522{
Antonio Quartulli29824a52016-05-25 23:27:31 +0800523 struct batadv_algo_ops *bao = bat_priv->algo_ops;
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100524 struct batadv_neigh_node *first_candidate_router = NULL;
525 struct batadv_neigh_node *next_candidate_router = NULL;
526 struct batadv_neigh_node *router, *cand_router = NULL;
527 struct batadv_neigh_node *last_cand_router = NULL;
528 struct batadv_orig_ifinfo *cand, *first_candidate = NULL;
529 struct batadv_orig_ifinfo *next_candidate = NULL;
530 struct batadv_orig_ifinfo *last_candidate;
531 bool last_candidate_found = false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000532
533 if (!orig_node)
534 return NULL;
535
Simon Wunderlich7351a4822013-11-13 19:14:47 +0100536 router = batadv_orig_router_get(orig_node, recv_if);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000537
Simon Wunderlich329887a2014-08-13 14:26:56 +0200538 if (!router)
539 return router;
540
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100541 /* only consider bonding for recv_if == BATADV_IF_DEFAULT (first hop)
542 * and if activated.
543 */
Simon Wunderlich329887a2014-08-13 14:26:56 +0200544 if (!(recv_if == BATADV_IF_DEFAULT && atomic_read(&bat_priv->bonding)))
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100545 return router;
546
547 /* bonding: loop through the list of possible routers found
548 * for the various outgoing interfaces and find a candidate after
549 * the last chosen bonding candidate (next_candidate). If no such
550 * router is found, use the first candidate found (the previously
551 * chosen bonding candidate might have been the last one in the list).
Antonio Quartulli3f687852014-11-02 11:29:56 +0100552 * If this can't be found either, return the previously chosen
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100553 * router - obviously there are no other candidates.
554 */
555 rcu_read_lock();
Sven Eckelmann93652342016-08-06 15:50:52 +0200556 last_candidate = batadv_last_bonding_get(orig_node);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100557 if (last_candidate)
558 last_cand_router = rcu_dereference(last_candidate->router);
559
560 hlist_for_each_entry_rcu(cand, &orig_node->ifinfo_list, list) {
561 /* acquire some structures and references ... */
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100562 if (!kref_get_unless_zero(&cand->refcount))
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100563 continue;
564
565 cand_router = rcu_dereference(cand->router);
566 if (!cand_router)
567 goto next;
568
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100569 if (!kref_get_unless_zero(&cand_router->refcount)) {
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100570 cand_router = NULL;
571 goto next;
572 }
573
574 /* alternative candidate should be good enough to be
575 * considered
576 */
Antonio Quartulli29824a52016-05-25 23:27:31 +0800577 if (!bao->neigh.is_similar_or_better(cand_router,
578 cand->if_outgoing, router,
579 recv_if))
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100580 goto next;
581
582 /* don't use the same router twice */
583 if (last_cand_router == cand_router)
584 goto next;
585
586 /* mark the first possible candidate */
587 if (!first_candidate) {
Sven Eckelmann77ae32e2016-01-16 10:29:53 +0100588 kref_get(&cand_router->refcount);
Sven Eckelmanna6ba0d32016-01-16 10:29:52 +0100589 kref_get(&cand->refcount);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100590 first_candidate = cand;
591 first_candidate_router = cand_router;
592 }
593
594 /* check if the loop has already passed the previously selected
595 * candidate ... this function should select the next candidate
596 * AFTER the previously used bonding candidate.
597 */
598 if (!last_candidate || last_candidate_found) {
599 next_candidate = cand;
600 next_candidate_router = cand_router;
601 break;
602 }
603
604 if (last_candidate == cand)
605 last_candidate_found = true;
606next:
607 /* free references */
608 if (cand_router) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100609 batadv_neigh_node_put(cand_router);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100610 cand_router = NULL;
611 }
Sven Eckelmann35f94772016-01-17 11:01:13 +0100612 batadv_orig_ifinfo_put(cand);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100613 }
614 rcu_read_unlock();
615
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100616 /* After finding candidates, handle the three cases:
617 * 1) there is a next candidate, use that
618 * 2) there is no next candidate, use the first of the list
619 * 3) there is no candidate at all, return the default router
620 */
621 if (next_candidate) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100622 batadv_neigh_node_put(router);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100623
Sven Eckelmann15c2ed72016-06-30 20:11:34 +0200624 kref_get(&next_candidate_router->refcount);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100625 router = next_candidate_router;
Sven Eckelmann15c2ed72016-06-30 20:11:34 +0200626 batadv_last_bonding_replace(orig_node, next_candidate);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100627 } else if (first_candidate) {
Sven Eckelmann25bb2502016-01-17 11:01:11 +0100628 batadv_neigh_node_put(router);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100629
Sven Eckelmann15c2ed72016-06-30 20:11:34 +0200630 kref_get(&first_candidate_router->refcount);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100631 router = first_candidate_router;
Sven Eckelmann15c2ed72016-06-30 20:11:34 +0200632 batadv_last_bonding_replace(orig_node, first_candidate);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100633 } else {
Sven Eckelmann15c2ed72016-06-30 20:11:34 +0200634 batadv_last_bonding_replace(orig_node, NULL);
635 }
636
637 /* cleanup of candidates */
638 if (first_candidate) {
639 batadv_neigh_node_put(first_candidate_router);
640 batadv_orig_ifinfo_put(first_candidate);
641 }
642
643 if (next_candidate) {
644 batadv_neigh_node_put(next_candidate_router);
645 batadv_orig_ifinfo_put(next_candidate);
Simon Wunderlichf3b3d902013-11-13 19:14:50 +0100646 }
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000647
Sven Eckelmann93652342016-08-06 15:50:52 +0200648 if (last_candidate)
649 batadv_orig_ifinfo_put(last_candidate);
650
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000651 return router;
652}
653
Sven Eckelmann63b01032012-05-16 20:23:13 +0200654static int batadv_route_unicast_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200655 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000656{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200657 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
658 struct batadv_orig_node *orig_node = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +0200659 struct batadv_unicast_packet *unicast_packet;
Antonio Quartulli7ed4be92013-04-08 15:08:18 +0200660 struct ethhdr *ethhdr = eth_hdr(skb);
Simon Wunderlichc54f38c2013-07-29 17:56:44 +0200661 int res, hdr_len, ret = NET_RX_DROP;
Florian Westphal63d443e2016-05-10 23:17:59 +0200662 unsigned int len;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000663
Sven Eckelmann96412692012-06-05 22:31:30 +0200664 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000665
666 /* TTL exceeded */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100667 if (unicast_packet->ttl < 2) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100668 pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
669 ethhdr->h_source, unicast_packet->dest);
Marek Lindner44524fc2011-02-10 14:33:53 +0000670 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000671 }
672
673 /* get routing information */
Sven Eckelmannda641192012-05-12 13:48:56 +0200674 orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
Marek Lindner7aadf882011-02-18 12:28:09 +0000675
Marek Lindner44524fc2011-02-10 14:33:53 +0000676 if (!orig_node)
Antonio Quartullib5a6f692011-04-16 11:30:57 +0200677 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000678
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000679 /* create a copy of the skb, if needed, to modify it. */
Antonio Quartulli0d125072012-02-18 11:27:34 +0100680 if (skb_cow(skb, ETH_HLEN) < 0)
Marek Lindner44524fc2011-02-10 14:33:53 +0000681 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000682
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000683 /* decrement ttl */
Martin Hundebøllf097e252013-05-23 16:53:01 +0200684 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100685 unicast_packet->ttl--;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000686
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100687 switch (unicast_packet->packet_type) {
Simon Wunderlichc54f38c2013-07-29 17:56:44 +0200688 case BATADV_UNICAST_4ADDR:
689 hdr_len = sizeof(struct batadv_unicast_4addr_packet);
690 break;
691 case BATADV_UNICAST:
692 hdr_len = sizeof(struct batadv_unicast_packet);
693 break;
694 default:
695 /* other packet types not supported - yet */
696 hdr_len = -1;
697 break;
698 }
699
700 if (hdr_len > 0)
701 batadv_skb_set_priority(skb, hdr_len);
702
Florian Westphal63d443e2016-05-10 23:17:59 +0200703 len = skb->len;
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200704 res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
Antonio Quartullif50ca952016-05-18 11:38:48 +0200705 if (res == -1)
706 goto out;
Martin Hundebøll95332472013-01-25 11:12:40 +0100707
Martin Hundebølle91ecfc2013-04-20 13:54:39 +0200708 /* translate transmit result into receive result */
709 if (res == NET_XMIT_SUCCESS) {
710 /* skb was transmitted and consumed */
Martin Hundebøll95332472013-01-25 11:12:40 +0100711 batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
712 batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
Florian Westphal63d443e2016-05-10 23:17:59 +0200713 len + ETH_HLEN);
Martin Hundebøll95332472013-01-25 11:12:40 +0100714 }
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000715
Antonio Quartullif50ca952016-05-18 11:38:48 +0200716 ret = NET_RX_SUCCESS;
717
Marek Lindner44524fc2011-02-10 14:33:53 +0000718out:
Marek Lindner44524fc2011-02-10 14:33:53 +0000719 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100720 batadv_orig_node_put(orig_node);
Marek Lindner44524fc2011-02-10 14:33:53 +0000721 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000722}
723
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200724/**
725 * batadv_reroute_unicast_packet - update the unicast header for re-routing
726 * @bat_priv: the bat priv with all the soft interface information
727 * @unicast_packet: the unicast header to be updated
728 * @dst_addr: the payload destination
Antonio Quartullic018ad32013-06-04 12:11:39 +0200729 * @vid: VLAN identifier
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200730 *
731 * Search the translation table for dst_addr and update the unicast header with
732 * the new corresponding information (originator address where the destination
733 * client currently is and its known TTVN)
734 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200735 * Return: true if the packet header has been updated, false otherwise
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200736 */
737static bool
738batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
739 struct batadv_unicast_packet *unicast_packet,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200740 u8 *dst_addr, unsigned short vid)
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200741{
742 struct batadv_orig_node *orig_node = NULL;
743 struct batadv_hard_iface *primary_if = NULL;
744 bool ret = false;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200745 u8 *orig_addr, orig_ttvn;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200746
Antonio Quartullic018ad32013-06-04 12:11:39 +0200747 if (batadv_is_my_client(bat_priv, dst_addr, vid)) {
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200748 primary_if = batadv_primary_if_get_selected(bat_priv);
749 if (!primary_if)
750 goto out;
751 orig_addr = primary_if->net_dev->dev_addr;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200752 orig_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200753 } else {
Antonio Quartullic018ad32013-06-04 12:11:39 +0200754 orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr,
755 vid);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200756 if (!orig_node)
757 goto out;
758
759 if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
760 goto out;
761
762 orig_addr = orig_node->orig;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200763 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200764 }
765
766 /* update the packet header */
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100767 ether_addr_copy(unicast_packet->dest, orig_addr);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200768 unicast_packet->ttvn = orig_ttvn;
769
770 ret = true;
771out:
772 if (primary_if)
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100773 batadv_hardif_put(primary_if);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200774 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100775 batadv_orig_node_put(orig_node);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200776
777 return ret;
778}
779
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100780static bool batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
781 struct sk_buff *skb, int hdr_len)
782{
Sven Eckelmann96412692012-06-05 22:31:30 +0200783 struct batadv_unicast_packet *unicast_packet;
Antonio Quartullic018ad32013-06-04 12:11:39 +0200784 struct batadv_hard_iface *primary_if;
785 struct batadv_orig_node *orig_node;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200786 u8 curr_ttvn, old_ttvn;
Antonio Quartullic018ad32013-06-04 12:11:39 +0200787 struct ethhdr *ethhdr;
788 unsigned short vid;
Sven Eckelmann3e348192012-05-16 20:23:22 +0200789 int is_old_ttvn;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200790
Antonio Quartullib8fcfa42012-08-26 23:25:59 +0200791 /* check if there is enough data before accessing it */
Antonio Quartullif1791422014-01-30 00:12:24 +0100792 if (!pskb_may_pull(skb, hdr_len + ETH_HLEN))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100793 return false;
Antonio Quartullib8fcfa42012-08-26 23:25:59 +0200794
795 /* create a copy of the skb (in case of for re-routing) to modify it. */
796 if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100797 return false;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200798
Sven Eckelmann96412692012-06-05 22:31:30 +0200799 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Antonio Quartullic018ad32013-06-04 12:11:39 +0200800 vid = batadv_get_vid(skb, hdr_len);
Antonio Quartullidd981ab2013-04-03 10:14:20 +0200801 ethhdr = (struct ethhdr *)(skb->data + hdr_len);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200802
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200803 /* check if the destination client was served by this node and it is now
804 * roaming. In this case, it means that the node has got a ROAM_ADV
805 * message and that it knows the new destination in the mesh to re-route
806 * the packet to
807 */
Antonio Quartullic018ad32013-06-04 12:11:39 +0200808 if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) {
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200809 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
Antonio Quartullic018ad32013-06-04 12:11:39 +0200810 ethhdr->h_dest, vid))
André Gaul23c4ec12014-06-10 17:50:31 +0200811 batadv_dbg_ratelimited(BATADV_DBG_TT,
812 bat_priv,
813 "Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
814 unicast_packet->dest,
815 ethhdr->h_dest);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200816 /* at this point the mesh destination should have been
817 * substituted with the originator address found in the global
818 * table. If not, let the packet go untouched anyway because
819 * there is nothing the node can do
820 */
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100821 return true;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200822 }
823
824 /* retrieve the TTVN known by this node for the packet destination. This
825 * value is used later to check if the node which sent (or re-routed
826 * last time) the packet had an updated information or not
827 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200828 curr_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200829 if (!batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
Sven Eckelmannda641192012-05-12 13:48:56 +0200830 orig_node = batadv_orig_hash_find(bat_priv,
831 unicast_packet->dest);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200832 /* if it is not possible to find the orig_node representing the
833 * destination, the packet can immediately be dropped as it will
834 * not be possible to deliver it
835 */
Antonio Quartullia73105b2011-04-27 14:27:44 +0200836 if (!orig_node)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100837 return false;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200838
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200839 curr_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
Sven Eckelmann5d967312016-01-17 11:01:09 +0100840 batadv_orig_node_put(orig_node);
Antonio Quartullia73105b2011-04-27 14:27:44 +0200841 }
842
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200843 /* check if the TTVN contained in the packet is fresher than what the
844 * node knows
845 */
Sven Eckelmann3e348192012-05-16 20:23:22 +0200846 is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200847 if (!is_old_ttvn)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100848 return true;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200849
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200850 old_ttvn = unicast_packet->ttvn;
851 /* the packet was forged based on outdated network information. Its
852 * destination can possibly be updated and forwarded towards the new
853 * target host
854 */
855 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
Antonio Quartullic018ad32013-06-04 12:11:39 +0200856 ethhdr->h_dest, vid)) {
André Gaul23c4ec12014-06-10 17:50:31 +0200857 batadv_dbg_ratelimited(BATADV_DBG_TT, bat_priv,
858 "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
859 unicast_packet->dest, ethhdr->h_dest,
860 old_ttvn, curr_ttvn);
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100861 return true;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200862 }
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200863
864 /* the packet has not been re-routed: either the destination is
865 * currently served by this node or there is no destination at all and
866 * it is possible to drop the packet
867 */
Antonio Quartullic018ad32013-06-04 12:11:39 +0200868 if (!batadv_is_my_client(bat_priv, ethhdr->h_dest, vid))
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100869 return false;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200870
871 /* update the header in order to let the packet be delivered to this
872 * node's soft interface
873 */
874 primary_if = batadv_primary_if_get_selected(bat_priv);
875 if (!primary_if)
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100876 return false;
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200877
Antonio Quartulli8fdd0152014-01-22 00:42:11 +0100878 ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200879
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100880 batadv_hardif_put(primary_if);
Antonio Quartulli7c1fd912012-09-23 22:38:34 +0200881
882 unicast_packet->ttvn = curr_ttvn;
883
Sven Eckelmann4b426b12016-02-22 21:02:39 +0100884 return true;
Antonio Quartullia73105b2011-04-27 14:27:44 +0200885}
886
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200887/**
888 * batadv_recv_unhandled_unicast_packet - receive and process packets which
889 * are in the unicast number space but not yet known to the implementation
890 * @skb: unicast tvlv packet to process
891 * @recv_if: pointer to interface this packet was received on
892 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200893 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200894 * otherwise.
895 */
896int batadv_recv_unhandled_unicast_packet(struct sk_buff *skb,
897 struct batadv_hard_iface *recv_if)
898{
899 struct batadv_unicast_packet *unicast_packet;
900 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
901 int check, hdr_size = sizeof(*unicast_packet);
902
903 check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
904 if (check < 0)
905 return NET_RX_DROP;
906
907 /* we don't know about this type, drop it. */
908 unicast_packet = (struct batadv_unicast_packet *)skb->data;
909 if (batadv_is_my_mac(bat_priv, unicast_packet->dest))
910 return NET_RX_DROP;
911
912 return batadv_route_unicast_packet(skb, recv_if);
913}
914
Sven Eckelmann56303d32012-06-05 22:31:31 +0200915int batadv_recv_unicast_packet(struct sk_buff *skb,
916 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000917{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200918 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
Sven Eckelmann96412692012-06-05 22:31:30 +0200919 struct batadv_unicast_packet *unicast_packet;
Martin Hundebøll4046b242012-04-20 17:02:45 +0200920 struct batadv_unicast_4addr_packet *unicast_4addr_packet;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200921 u8 *orig_addr;
Antonio Quartulli9affec62012-10-14 17:19:19 +0200922 struct batadv_orig_node *orig_node = NULL;
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100923 int check, hdr_size = sizeof(*unicast_packet);
Simon Wunderlich437bb0e2015-09-02 20:09:54 +0200924 enum batadv_subtype subtype;
Antonio Quartullic384ea32011-06-26 03:37:18 +0200925 bool is4addr;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000926
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200927 unicast_packet = (struct batadv_unicast_packet *)skb->data;
Martin Hundebøll4046b242012-04-20 17:02:45 +0200928 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200929
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100930 is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR;
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200931 /* the caller function should have already pulled 2 bytes */
Antonio Quartullic384ea32011-06-26 03:37:18 +0200932 if (is4addr)
Martin Hundebøll4046b242012-04-20 17:02:45 +0200933 hdr_size = sizeof(*unicast_4addr_packet);
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200934
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100935 /* function returns -EREMOTE for promiscuous packets */
David S. Miller6e0895c2013-04-22 20:32:51 -0400936 check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
Martin Hundebøll612d2b42013-01-25 11:12:42 +0100937
938 /* Even though the packet is not for us, we might save it to use for
939 * decoding a later received coded packet
940 */
941 if (check == -EREMOTE)
942 batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);
943
944 if (check < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000945 return NET_RX_DROP;
Antonio Quartullidd981ab2013-04-03 10:14:20 +0200946 if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
Antonio Quartullia73105b2011-04-27 14:27:44 +0200947 return NET_RX_DROP;
948
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000949 /* packet for me */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200950 if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
Antonio Quartulli9affec62012-10-14 17:19:19 +0200951 if (is4addr) {
Simon Wunderlich437bb0e2015-09-02 20:09:54 +0200952 subtype = unicast_4addr_packet->subtype;
953 batadv_dat_inc_counter(bat_priv, subtype);
954
955 /* Only payload data should be considered for speedy
956 * join. For example, DAT also uses unicast 4addr
957 * types, but those packets should not be considered
958 * for speedy join, since the clients do not actually
959 * reside at the sending originator.
960 */
961 if (subtype == BATADV_P_DATA) {
962 orig_addr = unicast_4addr_packet->src;
963 orig_node = batadv_orig_hash_find(bat_priv,
964 orig_addr);
965 }
Antonio Quartulli9affec62012-10-14 17:19:19 +0200966 }
Martin Hundebøll4046b242012-04-20 17:02:45 +0200967
Antonio Quartullic384ea32011-06-26 03:37:18 +0200968 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
969 hdr_size))
970 goto rx_success;
971 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
972 hdr_size))
973 goto rx_success;
974
Sven Eckelmann6535db52016-02-28 11:38:51 +0100975 batadv_interface_rx(recv_if->soft_iface, skb, hdr_size,
Antonio Quartulli9affec62012-10-14 17:19:19 +0200976 orig_node);
Antonio Quartulli37135172012-07-05 23:38:30 +0200977
Antonio Quartullic384ea32011-06-26 03:37:18 +0200978rx_success:
Antonio Quartulli9affec62012-10-14 17:19:19 +0200979 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +0100980 batadv_orig_node_put(orig_node);
Antonio Quartulli9affec62012-10-14 17:19:19 +0200981
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000982 return NET_RX_SUCCESS;
983 }
984
Sven Eckelmann63b01032012-05-16 20:23:13 +0200985 return batadv_route_unicast_packet(skb, recv_if);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000986}
987
Marek Lindneref261572013-04-23 21:39:57 +0800988/**
989 * batadv_recv_unicast_tvlv - receive and process unicast tvlv packets
990 * @skb: unicast tvlv packet to process
991 * @recv_if: pointer to interface this packet was received on
Marek Lindneref261572013-04-23 21:39:57 +0800992 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200993 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
Marek Lindneref261572013-04-23 21:39:57 +0800994 * otherwise.
995 */
996int batadv_recv_unicast_tvlv(struct sk_buff *skb,
997 struct batadv_hard_iface *recv_if)
998{
999 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1000 struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
1001 unsigned char *tvlv_buff;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001002 u16 tvlv_buff_len;
Marek Lindneref261572013-04-23 21:39:57 +08001003 int hdr_size = sizeof(*unicast_tvlv_packet);
1004 int ret = NET_RX_DROP;
1005
1006 if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
1007 return NET_RX_DROP;
1008
1009 /* the header is likely to be modified while forwarding */
1010 if (skb_cow(skb, hdr_size) < 0)
1011 return NET_RX_DROP;
1012
1013 /* packet needs to be linearized to access the tvlv content */
1014 if (skb_linearize(skb) < 0)
1015 return NET_RX_DROP;
1016
1017 unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)skb->data;
1018
1019 tvlv_buff = (unsigned char *)(skb->data + hdr_size);
1020 tvlv_buff_len = ntohs(unicast_tvlv_packet->tvlv_len);
1021
1022 if (tvlv_buff_len > skb->len - hdr_size)
1023 return NET_RX_DROP;
1024
1025 ret = batadv_tvlv_containers_process(bat_priv, false, NULL,
1026 unicast_tvlv_packet->src,
1027 unicast_tvlv_packet->dst,
1028 tvlv_buff, tvlv_buff_len);
1029
1030 if (ret != NET_RX_SUCCESS)
1031 ret = batadv_route_unicast_packet(skb, recv_if);
Antonio Quartulli05c3c8a2014-02-11 17:05:07 +01001032 else
1033 consume_skb(skb);
Marek Lindneref261572013-04-23 21:39:57 +08001034
1035 return ret;
1036}
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001037
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001038/**
1039 * batadv_recv_frag_packet - process received fragment
1040 * @skb: the received fragment
1041 * @recv_if: interface that the skb is received on
1042 *
1043 * This function does one of the three following things: 1) Forward fragment, if
1044 * the assembled packet will exceed our MTU; 2) Buffer fragment, if we till
1045 * lack further fragments; 3) Merge fragments, if we have all needed parts.
1046 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001047 * Return: NET_RX_DROP if the skb is not consumed, NET_RX_SUCCESS otherwise.
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001048 */
1049int batadv_recv_frag_packet(struct sk_buff *skb,
1050 struct batadv_hard_iface *recv_if)
1051{
1052 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1053 struct batadv_orig_node *orig_node_src = NULL;
1054 struct batadv_frag_packet *frag_packet;
1055 int ret = NET_RX_DROP;
1056
1057 if (batadv_check_unicast_packet(bat_priv, skb,
1058 sizeof(*frag_packet)) < 0)
1059 goto out;
1060
1061 frag_packet = (struct batadv_frag_packet *)skb->data;
1062 orig_node_src = batadv_orig_hash_find(bat_priv, frag_packet->orig);
1063 if (!orig_node_src)
1064 goto out;
1065
Andrew Lunnc0f25c82016-05-09 20:03:36 +02001066 skb->priority = frag_packet->priority + 256;
1067
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001068 /* Route the fragment if it is not for us and too big to be merged. */
1069 if (!batadv_is_my_mac(bat_priv, frag_packet->dest) &&
1070 batadv_frag_skb_fwd(skb, recv_if, orig_node_src)) {
1071 ret = NET_RX_SUCCESS;
1072 goto out;
1073 }
1074
1075 batadv_inc_counter(bat_priv, BATADV_CNT_FRAG_RX);
1076 batadv_add_counter(bat_priv, BATADV_CNT_FRAG_RX_BYTES, skb->len);
1077
1078 /* Add fragment to buffer and merge if possible. */
1079 if (!batadv_frag_skb_buffer(&skb, orig_node_src))
1080 goto out;
1081
1082 /* Deliver merged packet to the appropriate handler, if it was
1083 * merged
1084 */
1085 if (skb)
1086 batadv_batman_skb_recv(skb, recv_if->net_dev,
1087 &recv_if->batman_adv_ptype, NULL);
1088
1089 ret = NET_RX_SUCCESS;
1090
1091out:
1092 if (orig_node_src)
Sven Eckelmann5d967312016-01-17 11:01:09 +01001093 batadv_orig_node_put(orig_node_src);
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +02001094
1095 return ret;
1096}
1097
Sven Eckelmann56303d32012-06-05 22:31:31 +02001098int batadv_recv_bcast_packet(struct sk_buff *skb,
1099 struct batadv_hard_iface *recv_if)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001100{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001101 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1102 struct batadv_orig_node *orig_node = NULL;
Sven Eckelmann96412692012-06-05 22:31:30 +02001103 struct batadv_bcast_packet *bcast_packet;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001104 struct ethhdr *ethhdr;
Sven Eckelmann704509b2011-05-14 23:14:54 +02001105 int hdr_size = sizeof(*bcast_packet);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001106 int ret = NET_RX_DROP;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001107 s32 seq_diff;
1108 u32 seqno;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001109
1110 /* drop packet if it has not necessary minimum size */
1111 if (unlikely(!pskb_may_pull(skb, hdr_size)))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001112 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001113
Antonio Quartulli7ed4be92013-04-08 15:08:18 +02001114 ethhdr = eth_hdr(skb);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001115
1116 /* packet with broadcast indication but unicast recipient */
1117 if (!is_broadcast_ether_addr(ethhdr->h_dest))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001118 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001119
1120 /* packet with broadcast sender address */
1121 if (is_broadcast_ether_addr(ethhdr->h_source))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001122 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001123
1124 /* ignore broadcasts sent by myself */
Antonio Quartullife8a93b2013-04-03 19:10:26 +02001125 if (batadv_is_my_mac(bat_priv, ethhdr->h_source))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001126 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001127
Sven Eckelmann96412692012-06-05 22:31:30 +02001128 bcast_packet = (struct batadv_bcast_packet *)skb->data;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001129
1130 /* ignore broadcasts originated by myself */
Antonio Quartullife8a93b2013-04-03 19:10:26 +02001131 if (batadv_is_my_mac(bat_priv, bcast_packet->orig))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001132 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001133
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001134 if (bcast_packet->ttl < 2)
Marek Lindnerf3e00082011-01-25 21:52:11 +00001135 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001136
Sven Eckelmannda641192012-05-12 13:48:56 +02001137 orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001138
1139 if (!orig_node)
Antonio Quartullib5a6f692011-04-16 11:30:57 +02001140 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001141
Marek Lindnerf3e00082011-01-25 21:52:11 +00001142 spin_lock_bh(&orig_node->bcast_seqno_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001143
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001144 seqno = ntohl(bcast_packet->seqno);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001145 /* check whether the packet is a duplicate */
Sven Eckelmann9b4a1152012-05-12 13:48:53 +02001146 if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001147 seqno))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001148 goto spin_unlock;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001149
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001150 seq_diff = seqno - orig_node->last_bcast_seqno;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001151
1152 /* check whether the packet is old and the host just restarted. */
Sven Eckelmann30d3c512012-05-12 02:09:36 +02001153 if (batadv_window_protected(bat_priv, seq_diff,
Simon Wunderlich81f02682015-11-23 19:57:22 +01001154 BATADV_BCAST_MAX_AGE,
1155 &orig_node->bcast_seqno_reset, NULL))
Marek Lindnerf3e00082011-01-25 21:52:11 +00001156 goto spin_unlock;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001157
1158 /* mark broadcast in flood history, update window position
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001159 * if required.
1160 */
Sven Eckelmann0f5f9322012-05-12 02:09:25 +02001161 if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
Antonio Quartulli3fba7322013-10-13 02:50:17 +02001162 orig_node->last_bcast_seqno = seqno;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001163
Marek Lindnerf3e00082011-01-25 21:52:11 +00001164 spin_unlock_bh(&orig_node->bcast_seqno_lock);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001165
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001166 /* check whether this has been sent by another originator before */
Simon Wunderlich004e86f2012-10-18 13:47:42 +02001167 if (batadv_bla_check_bcast_duplist(bat_priv, skb))
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001168 goto out;
1169
Simon Wunderlichc54f38c2013-07-29 17:56:44 +02001170 batadv_skb_set_priority(skb, sizeof(struct batadv_bcast_packet));
1171
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001172 /* rebroadcast packet */
Sven Eckelmann9455e342012-05-12 02:09:37 +02001173 batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001174
Simon Wunderlich23721382012-01-22 20:00:19 +01001175 /* don't hand the broadcast up if it is from an originator
1176 * from the same backbone.
1177 */
Sven Eckelmann08adf152012-05-12 13:38:47 +02001178 if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
Simon Wunderlich23721382012-01-22 20:00:19 +01001179 goto out;
1180
Antonio Quartullic384ea32011-06-26 03:37:18 +02001181 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
1182 goto rx_success;
1183 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
1184 goto rx_success;
1185
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001186 /* broadcast for me */
Sven Eckelmann6535db52016-02-28 11:38:51 +01001187 batadv_interface_rx(recv_if->soft_iface, skb, hdr_size, orig_node);
Antonio Quartullic384ea32011-06-26 03:37:18 +02001188
1189rx_success:
Marek Lindnerf3e00082011-01-25 21:52:11 +00001190 ret = NET_RX_SUCCESS;
1191 goto out;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001192
Marek Lindnerf3e00082011-01-25 21:52:11 +00001193spin_unlock:
1194 spin_unlock_bh(&orig_node->bcast_seqno_lock);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001195out:
1196 if (orig_node)
Sven Eckelmann5d967312016-01-17 11:01:09 +01001197 batadv_orig_node_put(orig_node);
Marek Lindnerf3e00082011-01-25 21:52:11 +00001198 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001199}