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