Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 377fe0f968b30a1a714fab53a908061914f30e26

Authored by Antonio Quartulli
Committed by Antonio Quartulli
1 parent be181015a1

batman-adv: increase orig refcount when storing ref in gw_node 

A pointer to the orig_node representing a bat-gateway is
stored in the gw_node->orig_node member, but the refcount
for such orig_node is never increased.
This leads to memory faults when gw_node->orig_node is accessed
and the originator has already been freed.

Fix this by increasing the refcount on gw_node creation
and decreasing it on gw_node free.

Signed-off-by: Antonio Quartulli <antonio@open-mesh.com>
Signed-off-by: Marek Lindner <mareklindner@neomailbox.ch>

Showing 1 changed file with 9 additions and 2 deletions Inline Diff

net/batman-adv/gateway_client.c
Diff comments   View file @ 377fe0f
1 /* Copyright (C) 2009-2014 B.A.T.M.A.N. contributors: 1 /* Copyright (C) 2009-2014 B.A.T.M.A.N. contributors:
2 * 2 *
3 * Marek Lindner 3 * Marek Lindner
4 * 4 *
5 * This program is free software; you can redistribute it and/or 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 6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation. 7 * License as published by the Free Software Foundation.
8 * 8 *
9 * This program is distributed in the hope that it will be useful, but 9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details. 12 * General Public License for more details.
13 * 13 *
14 * You should have received a copy of the GNU General Public License 14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>. 15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */ 16 */
17 17
18 #include "main.h" 18 #include "main.h"
19 #include "sysfs.h" 19 #include "sysfs.h"
20 #include "gateway_client.h" 20 #include "gateway_client.h"
21 #include "gateway_common.h" 21 #include "gateway_common.h"
22 #include "hard-interface.h" 22 #include "hard-interface.h"
23 #include "originator.h" 23 #include "originator.h"
24 #include "translation-table.h" 24 #include "translation-table.h"
25 #include "routing.h" 25 #include "routing.h"
26 #include <linux/ip.h> 26 #include <linux/ip.h>
27 #include <linux/ipv6.h> 27 #include <linux/ipv6.h>
28 #include <linux/udp.h> 28 #include <linux/udp.h>
29 #include <linux/if_vlan.h> 29 #include <linux/if_vlan.h>
30 30
31 /* These are the offsets of the "hw type" and "hw address length" in the dhcp 31 /* These are the offsets of the "hw type" and "hw address length" in the dhcp
32 * packet starting at the beginning of the dhcp header 32 * packet starting at the beginning of the dhcp header
33 */ 33 */
34 #define BATADV_DHCP_HTYPE_OFFSET 1 34 #define BATADV_DHCP_HTYPE_OFFSET 1
35 #define BATADV_DHCP_HLEN_OFFSET 2 35 #define BATADV_DHCP_HLEN_OFFSET 2
36 /* Value of htype representing Ethernet */ 36 /* Value of htype representing Ethernet */
37 #define BATADV_DHCP_HTYPE_ETHERNET 0x01 37 #define BATADV_DHCP_HTYPE_ETHERNET 0x01
38 /* This is the offset of the "chaddr" field in the dhcp packet starting at the 38 /* This is the offset of the "chaddr" field in the dhcp packet starting at the
39 * beginning of the dhcp header 39 * beginning of the dhcp header
40 */ 40 */
41 #define BATADV_DHCP_CHADDR_OFFSET 28 41 #define BATADV_DHCP_CHADDR_OFFSET 28
42 42
43 static void batadv_gw_node_free_ref(struct batadv_gw_node *gw_node) 43 static void batadv_gw_node_free_ref(struct batadv_gw_node *gw_node)
44 { 44 {
45 if (atomic_dec_and_test(&gw_node->refcount)) 45 if (atomic_dec_and_test(&gw_node->refcount)) {
46 batadv_orig_node_free_ref(gw_node->orig_node);
46 kfree_rcu(gw_node, rcu); 47 kfree_rcu(gw_node, rcu);
48 }
47 } 49 }
48 50
49 static struct batadv_gw_node * 51 static struct batadv_gw_node *
50 batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv) 52 batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv)
51 { 53 {
52 struct batadv_gw_node *gw_node; 54 struct batadv_gw_node *gw_node;
53 55
54 rcu_read_lock(); 56 rcu_read_lock();
55 gw_node = rcu_dereference(bat_priv->gw.curr_gw); 57 gw_node = rcu_dereference(bat_priv->gw.curr_gw);
56 if (!gw_node) 58 if (!gw_node)
57 goto out; 59 goto out;
58 60
59 if (!atomic_inc_not_zero(&gw_node->refcount)) 61 if (!atomic_inc_not_zero(&gw_node->refcount))
60 gw_node = NULL; 62 gw_node = NULL;
61 63
62 out: 64 out:
63 rcu_read_unlock(); 65 rcu_read_unlock();
64 return gw_node; 66 return gw_node;
65 } 67 }
66 68
67 struct batadv_orig_node * 69 struct batadv_orig_node *
68 batadv_gw_get_selected_orig(struct batadv_priv *bat_priv) 70 batadv_gw_get_selected_orig(struct batadv_priv *bat_priv)
69 { 71 {
70 struct batadv_gw_node *gw_node; 72 struct batadv_gw_node *gw_node;
71 struct batadv_orig_node *orig_node = NULL; 73 struct batadv_orig_node *orig_node = NULL;
72 74
73 gw_node = batadv_gw_get_selected_gw_node(bat_priv); 75 gw_node = batadv_gw_get_selected_gw_node(bat_priv);
74 if (!gw_node) 76 if (!gw_node)
75 goto out; 77 goto out;
76 78
77 rcu_read_lock(); 79 rcu_read_lock();
78 orig_node = gw_node->orig_node; 80 orig_node = gw_node->orig_node;
79 if (!orig_node) 81 if (!orig_node)
80 goto unlock; 82 goto unlock;
81 83
82 if (!atomic_inc_not_zero(&orig_node->refcount)) 84 if (!atomic_inc_not_zero(&orig_node->refcount))
83 orig_node = NULL; 85 orig_node = NULL;
84 86
85 unlock: 87 unlock:
86 rcu_read_unlock(); 88 rcu_read_unlock();
87 out: 89 out:
88 if (gw_node) 90 if (gw_node)
89 batadv_gw_node_free_ref(gw_node); 91 batadv_gw_node_free_ref(gw_node);
90 return orig_node; 92 return orig_node;
91 } 93 }
92 94
93 static void batadv_gw_select(struct batadv_priv *bat_priv, 95 static void batadv_gw_select(struct batadv_priv *bat_priv,
94 struct batadv_gw_node *new_gw_node) 96 struct batadv_gw_node *new_gw_node)
95 { 97 {
96 struct batadv_gw_node *curr_gw_node; 98 struct batadv_gw_node *curr_gw_node;
97 99
98 spin_lock_bh(&bat_priv->gw.list_lock); 100 spin_lock_bh(&bat_priv->gw.list_lock);
99 101
100 if (new_gw_node && !atomic_inc_not_zero(&new_gw_node->refcount)) 102 if (new_gw_node && !atomic_inc_not_zero(&new_gw_node->refcount))
101 new_gw_node = NULL; 103 new_gw_node = NULL;
102 104
103 curr_gw_node = rcu_dereference_protected(bat_priv->gw.curr_gw, 1); 105 curr_gw_node = rcu_dereference_protected(bat_priv->gw.curr_gw, 1);
104 rcu_assign_pointer(bat_priv->gw.curr_gw, new_gw_node); 106 rcu_assign_pointer(bat_priv->gw.curr_gw, new_gw_node);
105 107
106 if (curr_gw_node) 108 if (curr_gw_node)
107 batadv_gw_node_free_ref(curr_gw_node); 109 batadv_gw_node_free_ref(curr_gw_node);
108 110
109 spin_unlock_bh(&bat_priv->gw.list_lock); 111 spin_unlock_bh(&bat_priv->gw.list_lock);
110 } 112 }
111 113
112 /** 114 /**
113 * batadv_gw_reselect - force a gateway reselection 115 * batadv_gw_reselect - force a gateway reselection
114 * @bat_priv: the bat priv with all the soft interface information 116 * @bat_priv: the bat priv with all the soft interface information
115 * 117 *
116 * Set a flag to remind the GW component to perform a new gateway reselection. 118 * Set a flag to remind the GW component to perform a new gateway reselection.
117 * However this function does not ensure that the current gateway is going to be 119 * However this function does not ensure that the current gateway is going to be
118 * deselected. The reselection mechanism may elect the same gateway once again. 120 * deselected. The reselection mechanism may elect the same gateway once again.
119 * 121 *
120 * This means that invoking batadv_gw_reselect() does not guarantee a gateway 122 * This means that invoking batadv_gw_reselect() does not guarantee a gateway
121 * change and therefore a uevent is not necessarily expected. 123 * change and therefore a uevent is not necessarily expected.
122 */ 124 */
123 void batadv_gw_reselect(struct batadv_priv *bat_priv) 125 void batadv_gw_reselect(struct batadv_priv *bat_priv)
124 { 126 {
125 atomic_set(&bat_priv->gw.reselect, 1); 127 atomic_set(&bat_priv->gw.reselect, 1);
126 } 128 }
127 129
128 static struct batadv_gw_node * 130 static struct batadv_gw_node *
129 batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv) 131 batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
130 { 132 {
131 struct batadv_neigh_node *router; 133 struct batadv_neigh_node *router;
132 struct batadv_neigh_ifinfo *router_ifinfo; 134 struct batadv_neigh_ifinfo *router_ifinfo;
133 struct batadv_gw_node *gw_node, *curr_gw = NULL; 135 struct batadv_gw_node *gw_node, *curr_gw = NULL;
134 uint32_t max_gw_factor = 0, tmp_gw_factor = 0; 136 uint32_t max_gw_factor = 0, tmp_gw_factor = 0;
135 uint32_t gw_divisor; 137 uint32_t gw_divisor;
136 uint8_t max_tq = 0; 138 uint8_t max_tq = 0;
137 uint8_t tq_avg; 139 uint8_t tq_avg;
138 struct batadv_orig_node *orig_node; 140 struct batadv_orig_node *orig_node;
139 141
140 gw_divisor = BATADV_TQ_LOCAL_WINDOW_SIZE * BATADV_TQ_LOCAL_WINDOW_SIZE; 142 gw_divisor = BATADV_TQ_LOCAL_WINDOW_SIZE * BATADV_TQ_LOCAL_WINDOW_SIZE;
141 gw_divisor *= 64; 143 gw_divisor *= 64;
142 144
143 rcu_read_lock(); 145 rcu_read_lock();
144 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) { 146 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
145 if (gw_node->deleted) 147 if (gw_node->deleted)
146 continue; 148 continue;
147 149
148 orig_node = gw_node->orig_node; 150 orig_node = gw_node->orig_node;
149 router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); 151 router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
150 if (!router) 152 if (!router)
151 continue; 153 continue;
152 154
153 router_ifinfo = batadv_neigh_ifinfo_get(router, 155 router_ifinfo = batadv_neigh_ifinfo_get(router,
154 BATADV_IF_DEFAULT); 156 BATADV_IF_DEFAULT);
155 if (!router_ifinfo) 157 if (!router_ifinfo)
156 goto next; 158 goto next;
157 159
158 if (!atomic_inc_not_zero(&gw_node->refcount)) 160 if (!atomic_inc_not_zero(&gw_node->refcount))
159 goto next; 161 goto next;
160 162
161 tq_avg = router_ifinfo->bat_iv.tq_avg; 163 tq_avg = router_ifinfo->bat_iv.tq_avg;
162 164
163 switch (atomic_read(&bat_priv->gw_sel_class)) { 165 switch (atomic_read(&bat_priv->gw_sel_class)) {
164 case 1: /* fast connection */ 166 case 1: /* fast connection */
165 tmp_gw_factor = tq_avg * tq_avg; 167 tmp_gw_factor = tq_avg * tq_avg;
166 tmp_gw_factor *= gw_node->bandwidth_down; 168 tmp_gw_factor *= gw_node->bandwidth_down;
167 tmp_gw_factor *= 100 * 100; 169 tmp_gw_factor *= 100 * 100;
168 tmp_gw_factor /= gw_divisor; 170 tmp_gw_factor /= gw_divisor;
169 171
170 if ((tmp_gw_factor > max_gw_factor) || 172 if ((tmp_gw_factor > max_gw_factor) ||
171 ((tmp_gw_factor == max_gw_factor) && 173 ((tmp_gw_factor == max_gw_factor) &&
172 (tq_avg > max_tq))) { 174 (tq_avg > max_tq))) {
173 if (curr_gw) 175 if (curr_gw)
174 batadv_gw_node_free_ref(curr_gw); 176 batadv_gw_node_free_ref(curr_gw);
175 curr_gw = gw_node; 177 curr_gw = gw_node;
176 atomic_inc(&curr_gw->refcount); 178 atomic_inc(&curr_gw->refcount);
177 } 179 }
178 break; 180 break;
179 181
180 default: /* 2: stable connection (use best statistic) 182 default: /* 2: stable connection (use best statistic)
181 * 3: fast-switch (use best statistic but change as 183 * 3: fast-switch (use best statistic but change as
182 * soon as a better gateway appears) 184 * soon as a better gateway appears)
183 * XX: late-switch (use best statistic but change as 185 * XX: late-switch (use best statistic but change as
184 * soon as a better gateway appears which has 186 * soon as a better gateway appears which has
185 * $routing_class more tq points) 187 * $routing_class more tq points)
186 */ 188 */
187 if (tq_avg > max_tq) { 189 if (tq_avg > max_tq) {
188 if (curr_gw) 190 if (curr_gw)
189 batadv_gw_node_free_ref(curr_gw); 191 batadv_gw_node_free_ref(curr_gw);
190 curr_gw = gw_node; 192 curr_gw = gw_node;
191 atomic_inc(&curr_gw->refcount); 193 atomic_inc(&curr_gw->refcount);
192 } 194 }
193 break; 195 break;
194 } 196 }
195 197
196 if (tq_avg > max_tq) 198 if (tq_avg > max_tq)
197 max_tq = tq_avg; 199 max_tq = tq_avg;
198 200
199 if (tmp_gw_factor > max_gw_factor) 201 if (tmp_gw_factor > max_gw_factor)
200 max_gw_factor = tmp_gw_factor; 202 max_gw_factor = tmp_gw_factor;
201 203
202 batadv_gw_node_free_ref(gw_node); 204 batadv_gw_node_free_ref(gw_node);
203 205
204 next: 206 next:
205 batadv_neigh_node_free_ref(router); 207 batadv_neigh_node_free_ref(router);
206 if (router_ifinfo) 208 if (router_ifinfo)
207 batadv_neigh_ifinfo_free_ref(router_ifinfo); 209 batadv_neigh_ifinfo_free_ref(router_ifinfo);
208 } 210 }
209 rcu_read_unlock(); 211 rcu_read_unlock();
210 212
211 return curr_gw; 213 return curr_gw;
212 } 214 }
213 215
214 /** 216 /**
215 * batadv_gw_check_client_stop - check if client mode has been switched off 217 * batadv_gw_check_client_stop - check if client mode has been switched off
216 * @bat_priv: the bat priv with all the soft interface information 218 * @bat_priv: the bat priv with all the soft interface information
217 * 219 *
218 * This function assumes the caller has checked that the gw state *is actually 220 * This function assumes the caller has checked that the gw state *is actually
219 * changing*. This function is not supposed to be called when there is no state 221 * changing*. This function is not supposed to be called when there is no state
220 * change. 222 * change.
221 */ 223 */
222 void batadv_gw_check_client_stop(struct batadv_priv *bat_priv) 224 void batadv_gw_check_client_stop(struct batadv_priv *bat_priv)
223 { 225 {
224 struct batadv_gw_node *curr_gw; 226 struct batadv_gw_node *curr_gw;
225 227
226 if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT) 228 if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT)
227 return; 229 return;
228 230
229 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 231 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
230 if (!curr_gw) 232 if (!curr_gw)
231 return; 233 return;
232 234
233 /* deselect the current gateway so that next time that client mode is 235 /* deselect the current gateway so that next time that client mode is
234 * enabled a proper GW_ADD event can be sent 236 * enabled a proper GW_ADD event can be sent
235 */ 237 */
236 batadv_gw_select(bat_priv, NULL); 238 batadv_gw_select(bat_priv, NULL);
237 239
238 /* if batman-adv is switching the gw client mode off and a gateway was 240 /* if batman-adv is switching the gw client mode off and a gateway was
239 * already selected, send a DEL uevent 241 * already selected, send a DEL uevent
240 */ 242 */
241 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL, NULL); 243 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL, NULL);
242 244
243 batadv_gw_node_free_ref(curr_gw); 245 batadv_gw_node_free_ref(curr_gw);
244 } 246 }
245 247
246 void batadv_gw_election(struct batadv_priv *bat_priv) 248 void batadv_gw_election(struct batadv_priv *bat_priv)
247 { 249 {
248 struct batadv_gw_node *curr_gw = NULL, *next_gw = NULL; 250 struct batadv_gw_node *curr_gw = NULL, *next_gw = NULL;
249 struct batadv_neigh_node *router = NULL; 251 struct batadv_neigh_node *router = NULL;
250 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 252 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
251 char gw_addr[18] = { '\0' }; 253 char gw_addr[18] = { '\0' };
252 254
253 if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT) 255 if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT)
254 goto out; 256 goto out;
255 257
256 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 258 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
257 259
258 if (!batadv_atomic_dec_not_zero(&bat_priv->gw.reselect) && curr_gw) 260 if (!batadv_atomic_dec_not_zero(&bat_priv->gw.reselect) && curr_gw)
259 goto out; 261 goto out;
260 262
261 next_gw = batadv_gw_get_best_gw_node(bat_priv); 263 next_gw = batadv_gw_get_best_gw_node(bat_priv);
262 264
263 if (curr_gw == next_gw) 265 if (curr_gw == next_gw)
264 goto out; 266 goto out;
265 267
266 if (next_gw) { 268 if (next_gw) {
267 sprintf(gw_addr, "%pM", next_gw->orig_node->orig); 269 sprintf(gw_addr, "%pM", next_gw->orig_node->orig);
268 270
269 router = batadv_orig_router_get(next_gw->orig_node, 271 router = batadv_orig_router_get(next_gw->orig_node,
270 BATADV_IF_DEFAULT); 272 BATADV_IF_DEFAULT);
271 if (!router) { 273 if (!router) {
272 batadv_gw_reselect(bat_priv); 274 batadv_gw_reselect(bat_priv);
273 goto out; 275 goto out;
274 } 276 }
275 277
276 router_ifinfo = batadv_neigh_ifinfo_get(router, 278 router_ifinfo = batadv_neigh_ifinfo_get(router,
277 BATADV_IF_DEFAULT); 279 BATADV_IF_DEFAULT);
278 if (!router_ifinfo) { 280 if (!router_ifinfo) {
279 batadv_gw_reselect(bat_priv); 281 batadv_gw_reselect(bat_priv);
280 goto out; 282 goto out;
281 } 283 }
282 } 284 }
283 285
284 if ((curr_gw) && (!next_gw)) { 286 if ((curr_gw) && (!next_gw)) {
285 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 287 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
286 "Removing selected gateway - no gateway in range\n"); 288 "Removing selected gateway - no gateway in range\n");
287 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL, 289 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL,
288 NULL); 290 NULL);
289 } else if ((!curr_gw) && (next_gw)) { 291 } else if ((!curr_gw) && (next_gw)) {
290 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 292 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
291 "Adding route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n", 293 "Adding route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n",
292 next_gw->orig_node->orig, 294 next_gw->orig_node->orig,
293 next_gw->bandwidth_down / 10, 295 next_gw->bandwidth_down / 10,
294 next_gw->bandwidth_down % 10, 296 next_gw->bandwidth_down % 10,
295 next_gw->bandwidth_up / 10, 297 next_gw->bandwidth_up / 10,
296 next_gw->bandwidth_up % 10, 298 next_gw->bandwidth_up % 10,
297 router_ifinfo->bat_iv.tq_avg); 299 router_ifinfo->bat_iv.tq_avg);
298 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_ADD, 300 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_ADD,
299 gw_addr); 301 gw_addr);
300 } else { 302 } else {
301 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 303 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
302 "Changing route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n", 304 "Changing route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n",
303 next_gw->orig_node->orig, 305 next_gw->orig_node->orig,
304 next_gw->bandwidth_down / 10, 306 next_gw->bandwidth_down / 10,
305 next_gw->bandwidth_down % 10, 307 next_gw->bandwidth_down % 10,
306 next_gw->bandwidth_up / 10, 308 next_gw->bandwidth_up / 10,
307 next_gw->bandwidth_up % 10, 309 next_gw->bandwidth_up % 10,
308 router_ifinfo->bat_iv.tq_avg); 310 router_ifinfo->bat_iv.tq_avg);
309 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_CHANGE, 311 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_CHANGE,
310 gw_addr); 312 gw_addr);
311 } 313 }
312 314
313 batadv_gw_select(bat_priv, next_gw); 315 batadv_gw_select(bat_priv, next_gw);
314 316
315 out: 317 out:
316 if (curr_gw) 318 if (curr_gw)
317 batadv_gw_node_free_ref(curr_gw); 319 batadv_gw_node_free_ref(curr_gw);
318 if (next_gw) 320 if (next_gw)
319 batadv_gw_node_free_ref(next_gw); 321 batadv_gw_node_free_ref(next_gw);
320 if (router) 322 if (router)
321 batadv_neigh_node_free_ref(router); 323 batadv_neigh_node_free_ref(router);
322 if (router_ifinfo) 324 if (router_ifinfo)
323 batadv_neigh_ifinfo_free_ref(router_ifinfo); 325 batadv_neigh_ifinfo_free_ref(router_ifinfo);
324 } 326 }
325 327
326 void batadv_gw_check_election(struct batadv_priv *bat_priv, 328 void batadv_gw_check_election(struct batadv_priv *bat_priv,
327 struct batadv_orig_node *orig_node) 329 struct batadv_orig_node *orig_node)
328 { 330 {
329 struct batadv_neigh_ifinfo *router_orig_tq = NULL; 331 struct batadv_neigh_ifinfo *router_orig_tq = NULL;
330 struct batadv_neigh_ifinfo *router_gw_tq = NULL; 332 struct batadv_neigh_ifinfo *router_gw_tq = NULL;
331 struct batadv_orig_node *curr_gw_orig; 333 struct batadv_orig_node *curr_gw_orig;
332 struct batadv_neigh_node *router_gw = NULL, *router_orig = NULL; 334 struct batadv_neigh_node *router_gw = NULL, *router_orig = NULL;
333 uint8_t gw_tq_avg, orig_tq_avg; 335 uint8_t gw_tq_avg, orig_tq_avg;
334 336
335 curr_gw_orig = batadv_gw_get_selected_orig(bat_priv); 337 curr_gw_orig = batadv_gw_get_selected_orig(bat_priv);
336 if (!curr_gw_orig) 338 if (!curr_gw_orig)
337 goto reselect; 339 goto reselect;
338 340
339 router_gw = batadv_orig_router_get(curr_gw_orig, BATADV_IF_DEFAULT); 341 router_gw = batadv_orig_router_get(curr_gw_orig, BATADV_IF_DEFAULT);
340 if (!router_gw) 342 if (!router_gw)
341 goto reselect; 343 goto reselect;
342 344
343 router_gw_tq = batadv_neigh_ifinfo_get(router_gw, 345 router_gw_tq = batadv_neigh_ifinfo_get(router_gw,
344 BATADV_IF_DEFAULT); 346 BATADV_IF_DEFAULT);
345 if (!router_gw_tq) 347 if (!router_gw_tq)
346 goto reselect; 348 goto reselect;
347 349
348 /* this node already is the gateway */ 350 /* this node already is the gateway */
349 if (curr_gw_orig == orig_node) 351 if (curr_gw_orig == orig_node)
350 goto out; 352 goto out;
351 353
352 router_orig = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); 354 router_orig = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
353 if (!router_orig) 355 if (!router_orig)
354 goto out; 356 goto out;
355 357
356 router_orig_tq = batadv_neigh_ifinfo_get(router_orig, 358 router_orig_tq = batadv_neigh_ifinfo_get(router_orig,
357 BATADV_IF_DEFAULT); 359 BATADV_IF_DEFAULT);
358 if (!router_orig_tq) 360 if (!router_orig_tq)
359 goto out; 361 goto out;
360 362
361 gw_tq_avg = router_gw_tq->bat_iv.tq_avg; 363 gw_tq_avg = router_gw_tq->bat_iv.tq_avg;
362 orig_tq_avg = router_orig_tq->bat_iv.tq_avg; 364 orig_tq_avg = router_orig_tq->bat_iv.tq_avg;
363 365
364 /* the TQ value has to be better */ 366 /* the TQ value has to be better */
365 if (orig_tq_avg < gw_tq_avg) 367 if (orig_tq_avg < gw_tq_avg)
366 goto out; 368 goto out;
367 369
368 /* if the routing class is greater than 3 the value tells us how much 370 /* if the routing class is greater than 3 the value tells us how much
369 * greater the TQ value of the new gateway must be 371 * greater the TQ value of the new gateway must be
370 */ 372 */
371 if ((atomic_read(&bat_priv->gw_sel_class) > 3) && 373 if ((atomic_read(&bat_priv->gw_sel_class) > 3) &&
372 (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class))) 374 (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class)))
373 goto out; 375 goto out;
374 376
375 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 377 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
376 "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n", 378 "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n",
377 gw_tq_avg, orig_tq_avg); 379 gw_tq_avg, orig_tq_avg);
378 380
379 reselect: 381 reselect:
380 batadv_gw_reselect(bat_priv); 382 batadv_gw_reselect(bat_priv);
381 out: 383 out:
382 if (curr_gw_orig) 384 if (curr_gw_orig)
383 batadv_orig_node_free_ref(curr_gw_orig); 385 batadv_orig_node_free_ref(curr_gw_orig);
384 if (router_gw) 386 if (router_gw)
385 batadv_neigh_node_free_ref(router_gw); 387 batadv_neigh_node_free_ref(router_gw);
386 if (router_orig) 388 if (router_orig)
387 batadv_neigh_node_free_ref(router_orig); 389 batadv_neigh_node_free_ref(router_orig);
388 if (router_gw_tq) 390 if (router_gw_tq)
389 batadv_neigh_ifinfo_free_ref(router_gw_tq); 391 batadv_neigh_ifinfo_free_ref(router_gw_tq);
390 if (router_orig_tq) 392 if (router_orig_tq)
391 batadv_neigh_ifinfo_free_ref(router_orig_tq); 393 batadv_neigh_ifinfo_free_ref(router_orig_tq);
392 } 394 }
393 395
394 /** 396 /**
395 * batadv_gw_node_add - add gateway node to list of available gateways 397 * batadv_gw_node_add - add gateway node to list of available gateways
396 * @bat_priv: the bat priv with all the soft interface information 398 * @bat_priv: the bat priv with all the soft interface information
397 * @orig_node: originator announcing gateway capabilities 399 * @orig_node: originator announcing gateway capabilities
398 * @gateway: announced bandwidth information 400 * @gateway: announced bandwidth information
399 */ 401 */
400 static void batadv_gw_node_add(struct batadv_priv *bat_priv, 402 static void batadv_gw_node_add(struct batadv_priv *bat_priv,
401 struct batadv_orig_node *orig_node, 403 struct batadv_orig_node *orig_node,
402 struct batadv_tvlv_gateway_data *gateway) 404 struct batadv_tvlv_gateway_data *gateway)
403 { 405 {
404 struct batadv_gw_node *gw_node; 406 struct batadv_gw_node *gw_node;
405 407
406 if (gateway->bandwidth_down == 0) 408 if (gateway->bandwidth_down == 0)
407 return; 409 return;
408 410
411 if (!atomic_inc_not_zero(&orig_node->refcount))
412 return;
413
409 gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC); 414 gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC);
410 if (!gw_node) 415 if (!gw_node) {
416 batadv_orig_node_free_ref(orig_node);
411 return; 417 return;
418 }
412 419
413 INIT_HLIST_NODE(&gw_node->list); 420 INIT_HLIST_NODE(&gw_node->list);
414 gw_node->orig_node = orig_node; 421 gw_node->orig_node = orig_node;
415 atomic_set(&gw_node->refcount, 1); 422 atomic_set(&gw_node->refcount, 1);
416 423
417 spin_lock_bh(&bat_priv->gw.list_lock); 424 spin_lock_bh(&bat_priv->gw.list_lock);
418 hlist_add_head_rcu(&gw_node->list, &bat_priv->gw.list); 425 hlist_add_head_rcu(&gw_node->list, &bat_priv->gw.list);
419 spin_unlock_bh(&bat_priv->gw.list_lock); 426 spin_unlock_bh(&bat_priv->gw.list_lock);
420 427
421 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 428 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
422 "Found new gateway %pM -> gw bandwidth: %u.%u/%u.%u MBit\n", 429 "Found new gateway %pM -> gw bandwidth: %u.%u/%u.%u MBit\n",
423 orig_node->orig, 430 orig_node->orig,
424 ntohl(gateway->bandwidth_down) / 10, 431 ntohl(gateway->bandwidth_down) / 10,
425 ntohl(gateway->bandwidth_down) % 10, 432 ntohl(gateway->bandwidth_down) % 10,
426 ntohl(gateway->bandwidth_up) / 10, 433 ntohl(gateway->bandwidth_up) / 10,
427 ntohl(gateway->bandwidth_up) % 10); 434 ntohl(gateway->bandwidth_up) % 10);
428 } 435 }
429 436
430 /** 437 /**
431 * batadv_gw_node_get - retrieve gateway node from list of available gateways 438 * batadv_gw_node_get - retrieve gateway node from list of available gateways
432 * @bat_priv: the bat priv with all the soft interface information 439 * @bat_priv: the bat priv with all the soft interface information
433 * @orig_node: originator announcing gateway capabilities 440 * @orig_node: originator announcing gateway capabilities
434 * 441 *
435 * Returns gateway node if found or NULL otherwise. 442 * Returns gateway node if found or NULL otherwise.
436 */ 443 */
437 static struct batadv_gw_node * 444 static struct batadv_gw_node *
438 batadv_gw_node_get(struct batadv_priv *bat_priv, 445 batadv_gw_node_get(struct batadv_priv *bat_priv,
439 struct batadv_orig_node *orig_node) 446 struct batadv_orig_node *orig_node)
440 { 447 {
441 struct batadv_gw_node *gw_node_tmp, *gw_node = NULL; 448 struct batadv_gw_node *gw_node_tmp, *gw_node = NULL;
442 449
443 rcu_read_lock(); 450 rcu_read_lock();
444 hlist_for_each_entry_rcu(gw_node_tmp, &bat_priv->gw.list, list) { 451 hlist_for_each_entry_rcu(gw_node_tmp, &bat_priv->gw.list, list) {
445 if (gw_node_tmp->orig_node != orig_node) 452 if (gw_node_tmp->orig_node != orig_node)
446 continue; 453 continue;
447 454
448 if (gw_node_tmp->deleted) 455 if (gw_node_tmp->deleted)
449 continue; 456 continue;
450 457
451 if (!atomic_inc_not_zero(&gw_node_tmp->refcount)) 458 if (!atomic_inc_not_zero(&gw_node_tmp->refcount))
452 continue; 459 continue;
453 460
454 gw_node = gw_node_tmp; 461 gw_node = gw_node_tmp;
455 break; 462 break;
456 } 463 }
457 rcu_read_unlock(); 464 rcu_read_unlock();
458 465
459 return gw_node; 466 return gw_node;
460 } 467 }
461 468
462 /** 469 /**
463 * batadv_gw_node_update - update list of available gateways with changed 470 * batadv_gw_node_update - update list of available gateways with changed
464 * bandwidth information 471 * bandwidth information
465 * @bat_priv: the bat priv with all the soft interface information 472 * @bat_priv: the bat priv with all the soft interface information
466 * @orig_node: originator announcing gateway capabilities 473 * @orig_node: originator announcing gateway capabilities
467 * @gateway: announced bandwidth information 474 * @gateway: announced bandwidth information
468 */ 475 */
469 void batadv_gw_node_update(struct batadv_priv *bat_priv, 476 void batadv_gw_node_update(struct batadv_priv *bat_priv,
470 struct batadv_orig_node *orig_node, 477 struct batadv_orig_node *orig_node,
471 struct batadv_tvlv_gateway_data *gateway) 478 struct batadv_tvlv_gateway_data *gateway)
472 { 479 {
473 struct batadv_gw_node *gw_node, *curr_gw = NULL; 480 struct batadv_gw_node *gw_node, *curr_gw = NULL;
474 481
475 gw_node = batadv_gw_node_get(bat_priv, orig_node); 482 gw_node = batadv_gw_node_get(bat_priv, orig_node);
476 if (!gw_node) { 483 if (!gw_node) {
477 batadv_gw_node_add(bat_priv, orig_node, gateway); 484 batadv_gw_node_add(bat_priv, orig_node, gateway);
478 goto out; 485 goto out;
479 } 486 }
480 487
481 if ((gw_node->bandwidth_down == ntohl(gateway->bandwidth_down)) && 488 if ((gw_node->bandwidth_down == ntohl(gateway->bandwidth_down)) &&
482 (gw_node->bandwidth_up == ntohl(gateway->bandwidth_up))) 489 (gw_node->bandwidth_up == ntohl(gateway->bandwidth_up)))
483 goto out; 490 goto out;
484 491
485 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 492 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
486 "Gateway bandwidth of originator %pM changed from %u.%u/%u.%u MBit to %u.%u/%u.%u MBit\n", 493 "Gateway bandwidth of originator %pM changed from %u.%u/%u.%u MBit to %u.%u/%u.%u MBit\n",
487 orig_node->orig, 494 orig_node->orig,
488 gw_node->bandwidth_down / 10, 495 gw_node->bandwidth_down / 10,
489 gw_node->bandwidth_down % 10, 496 gw_node->bandwidth_down % 10,
490 gw_node->bandwidth_up / 10, 497 gw_node->bandwidth_up / 10,
491 gw_node->bandwidth_up % 10, 498 gw_node->bandwidth_up % 10,
492 ntohl(gateway->bandwidth_down) / 10, 499 ntohl(gateway->bandwidth_down) / 10,
493 ntohl(gateway->bandwidth_down) % 10, 500 ntohl(gateway->bandwidth_down) % 10,
494 ntohl(gateway->bandwidth_up) / 10, 501 ntohl(gateway->bandwidth_up) / 10,
495 ntohl(gateway->bandwidth_up) % 10); 502 ntohl(gateway->bandwidth_up) % 10);
496 503
497 gw_node->bandwidth_down = ntohl(gateway->bandwidth_down); 504 gw_node->bandwidth_down = ntohl(gateway->bandwidth_down);
498 gw_node->bandwidth_up = ntohl(gateway->bandwidth_up); 505 gw_node->bandwidth_up = ntohl(gateway->bandwidth_up);
499 506
500 gw_node->deleted = 0; 507 gw_node->deleted = 0;
501 if (ntohl(gateway->bandwidth_down) == 0) { 508 if (ntohl(gateway->bandwidth_down) == 0) {
502 gw_node->deleted = jiffies; 509 gw_node->deleted = jiffies;
503 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 510 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
504 "Gateway %pM removed from gateway list\n", 511 "Gateway %pM removed from gateway list\n",
505 orig_node->orig); 512 orig_node->orig);
506 513
507 /* Note: We don't need a NULL check here, since curr_gw never 514 /* Note: We don't need a NULL check here, since curr_gw never
508 * gets dereferenced. 515 * gets dereferenced.
509 */ 516 */
510 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 517 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
511 if (gw_node == curr_gw) 518 if (gw_node == curr_gw)
512 batadv_gw_reselect(bat_priv); 519 batadv_gw_reselect(bat_priv);
513 } 520 }
514 521
515 out: 522 out:
516 if (curr_gw) 523 if (curr_gw)
517 batadv_gw_node_free_ref(curr_gw); 524 batadv_gw_node_free_ref(curr_gw);
518 if (gw_node) 525 if (gw_node)
519 batadv_gw_node_free_ref(gw_node); 526 batadv_gw_node_free_ref(gw_node);
520 } 527 }
521 528
522 void batadv_gw_node_delete(struct batadv_priv *bat_priv, 529 void batadv_gw_node_delete(struct batadv_priv *bat_priv,
523 struct batadv_orig_node *orig_node) 530 struct batadv_orig_node *orig_node)
524 { 531 {
525 struct batadv_tvlv_gateway_data gateway; 532 struct batadv_tvlv_gateway_data gateway;
526 533
527 gateway.bandwidth_down = 0; 534 gateway.bandwidth_down = 0;
528 gateway.bandwidth_up = 0; 535 gateway.bandwidth_up = 0;
529 536
530 batadv_gw_node_update(bat_priv, orig_node, &gateway); 537 batadv_gw_node_update(bat_priv, orig_node, &gateway);
531 } 538 }
532 539
533 void batadv_gw_node_purge(struct batadv_priv *bat_priv) 540 void batadv_gw_node_purge(struct batadv_priv *bat_priv)
534 { 541 {
535 struct batadv_gw_node *gw_node, *curr_gw; 542 struct batadv_gw_node *gw_node, *curr_gw;
536 struct hlist_node *node_tmp; 543 struct hlist_node *node_tmp;
537 unsigned long timeout = msecs_to_jiffies(2 * BATADV_PURGE_TIMEOUT); 544 unsigned long timeout = msecs_to_jiffies(2 * BATADV_PURGE_TIMEOUT);
538 int do_reselect = 0; 545 int do_reselect = 0;
539 546
540 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 547 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
541 548
542 spin_lock_bh(&bat_priv->gw.list_lock); 549 spin_lock_bh(&bat_priv->gw.list_lock);
543 550
544 hlist_for_each_entry_safe(gw_node, node_tmp, 551 hlist_for_each_entry_safe(gw_node, node_tmp,
545 &bat_priv->gw.list, list) { 552 &bat_priv->gw.list, list) {
546 if (((!gw_node->deleted) || 553 if (((!gw_node->deleted) ||
547 (time_before(jiffies, gw_node->deleted + timeout))) && 554 (time_before(jiffies, gw_node->deleted + timeout))) &&
548 atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) 555 atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE)
549 continue; 556 continue;
550 557
551 if (curr_gw == gw_node) 558 if (curr_gw == gw_node)
552 do_reselect = 1; 559 do_reselect = 1;
553 560
554 hlist_del_rcu(&gw_node->list); 561 hlist_del_rcu(&gw_node->list);
555 batadv_gw_node_free_ref(gw_node); 562 batadv_gw_node_free_ref(gw_node);
556 } 563 }
557 564
558 spin_unlock_bh(&bat_priv->gw.list_lock); 565 spin_unlock_bh(&bat_priv->gw.list_lock);
559 566
560 /* gw_reselect() needs to acquire the gw_list_lock */ 567 /* gw_reselect() needs to acquire the gw_list_lock */
561 if (do_reselect) 568 if (do_reselect)
562 batadv_gw_reselect(bat_priv); 569 batadv_gw_reselect(bat_priv);
563 570
564 if (curr_gw) 571 if (curr_gw)
565 batadv_gw_node_free_ref(curr_gw); 572 batadv_gw_node_free_ref(curr_gw);
566 } 573 }
567 574
568 /* fails if orig_node has no router */ 575 /* fails if orig_node has no router */
569 static int batadv_write_buffer_text(struct batadv_priv *bat_priv, 576 static int batadv_write_buffer_text(struct batadv_priv *bat_priv,
570 struct seq_file *seq, 577 struct seq_file *seq,
571 const struct batadv_gw_node *gw_node) 578 const struct batadv_gw_node *gw_node)
572 { 579 {
573 struct batadv_gw_node *curr_gw; 580 struct batadv_gw_node *curr_gw;
574 struct batadv_neigh_node *router; 581 struct batadv_neigh_node *router;
575 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 582 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
576 int ret = -1; 583 int ret = -1;
577 584
578 router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT); 585 router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
579 if (!router) 586 if (!router)
580 goto out; 587 goto out;
581 588
582 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); 589 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
583 if (!router_ifinfo) 590 if (!router_ifinfo)
584 goto out; 591 goto out;
585 592
586 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 593 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
587 594
588 ret = seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %u.%u/%u.%u MBit\n", 595 ret = seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %u.%u/%u.%u MBit\n",
589 (curr_gw == gw_node ? "=>" : " "), 596 (curr_gw == gw_node ? "=>" : " "),
590 gw_node->orig_node->orig, 597 gw_node->orig_node->orig,
591 router_ifinfo->bat_iv.tq_avg, router->addr, 598 router_ifinfo->bat_iv.tq_avg, router->addr,
592 router->if_incoming->net_dev->name, 599 router->if_incoming->net_dev->name,
593 gw_node->bandwidth_down / 10, 600 gw_node->bandwidth_down / 10,
594 gw_node->bandwidth_down % 10, 601 gw_node->bandwidth_down % 10,
595 gw_node->bandwidth_up / 10, 602 gw_node->bandwidth_up / 10,
596 gw_node->bandwidth_up % 10); 603 gw_node->bandwidth_up % 10);
597 604
598 if (curr_gw) 605 if (curr_gw)
599 batadv_gw_node_free_ref(curr_gw); 606 batadv_gw_node_free_ref(curr_gw);
600 out: 607 out:
601 if (router_ifinfo) 608 if (router_ifinfo)
602 batadv_neigh_ifinfo_free_ref(router_ifinfo); 609 batadv_neigh_ifinfo_free_ref(router_ifinfo);
603 if (router) 610 if (router)
604 batadv_neigh_node_free_ref(router); 611 batadv_neigh_node_free_ref(router);
605 return ret; 612 return ret;
606 } 613 }
607 614
608 int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset) 615 int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset)
609 { 616 {
610 struct net_device *net_dev = (struct net_device *)seq->private; 617 struct net_device *net_dev = (struct net_device *)seq->private;
611 struct batadv_priv *bat_priv = netdev_priv(net_dev); 618 struct batadv_priv *bat_priv = netdev_priv(net_dev);
612 struct batadv_hard_iface *primary_if; 619 struct batadv_hard_iface *primary_if;
613 struct batadv_gw_node *gw_node; 620 struct batadv_gw_node *gw_node;
614 int gw_count = 0; 621 int gw_count = 0;
615 622
616 primary_if = batadv_seq_print_text_primary_if_get(seq); 623 primary_if = batadv_seq_print_text_primary_if_get(seq);
617 if (!primary_if) 624 if (!primary_if)
618 goto out; 625 goto out;
619 626
620 seq_printf(seq, 627 seq_printf(seq,
621 " %-12s (%s/%i) %17s [%10s]: advertised uplink bandwidth ... [B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n", 628 " %-12s (%s/%i) %17s [%10s]: advertised uplink bandwidth ... [B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",
622 "Gateway", "#", BATADV_TQ_MAX_VALUE, "Nexthop", "outgoingIF", 629 "Gateway", "#", BATADV_TQ_MAX_VALUE, "Nexthop", "outgoingIF",
623 BATADV_SOURCE_VERSION, primary_if->net_dev->name, 630 BATADV_SOURCE_VERSION, primary_if->net_dev->name,
624 primary_if->net_dev->dev_addr, net_dev->name); 631 primary_if->net_dev->dev_addr, net_dev->name);
625 632
626 rcu_read_lock(); 633 rcu_read_lock();
627 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) { 634 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
628 if (gw_node->deleted) 635 if (gw_node->deleted)
629 continue; 636 continue;
630 637
631 /* fails if orig_node has no router */ 638 /* fails if orig_node has no router */
632 if (batadv_write_buffer_text(bat_priv, seq, gw_node) < 0) 639 if (batadv_write_buffer_text(bat_priv, seq, gw_node) < 0)
633 continue; 640 continue;
634 641
635 gw_count++; 642 gw_count++;
636 } 643 }
637 rcu_read_unlock(); 644 rcu_read_unlock();
638 645
639 if (gw_count == 0) 646 if (gw_count == 0)
640 seq_puts(seq, "No gateways in range ...\n"); 647 seq_puts(seq, "No gateways in range ...\n");
641 648
642 out: 649 out:
643 if (primary_if) 650 if (primary_if)
644 batadv_hardif_free_ref(primary_if); 651 batadv_hardif_free_ref(primary_if);
645 return 0; 652 return 0;
646 } 653 }
647 654
648 /** 655 /**
649 * batadv_gw_dhcp_recipient_get - check if a packet is a DHCP message 656 * batadv_gw_dhcp_recipient_get - check if a packet is a DHCP message
650 * @skb: the packet to check 657 * @skb: the packet to check
651 * @header_len: a pointer to the batman-adv header size 658 * @header_len: a pointer to the batman-adv header size
652 * @chaddr: buffer where the client address will be stored. Valid 659 * @chaddr: buffer where the client address will be stored. Valid
653 * only if the function returns BATADV_DHCP_TO_CLIENT 660 * only if the function returns BATADV_DHCP_TO_CLIENT
654 * 661 *
655 * Returns: 662 * Returns:
656 * - BATADV_DHCP_NO if the packet is not a dhcp message or if there was an error 663 * - BATADV_DHCP_NO if the packet is not a dhcp message or if there was an error
657 * while parsing it 664 * while parsing it
658 * - BATADV_DHCP_TO_SERVER if this is a message going to the DHCP server 665 * - BATADV_DHCP_TO_SERVER if this is a message going to the DHCP server
659 * - BATADV_DHCP_TO_CLIENT if this is a message going to a DHCP client 666 * - BATADV_DHCP_TO_CLIENT if this is a message going to a DHCP client
660 * 667 *
661 * This function may re-allocate the data buffer of the skb passed as argument. 668 * This function may re-allocate the data buffer of the skb passed as argument.
662 */ 669 */
663 enum batadv_dhcp_recipient 670 enum batadv_dhcp_recipient
664 batadv_gw_dhcp_recipient_get(struct sk_buff *skb, unsigned int *header_len, 671 batadv_gw_dhcp_recipient_get(struct sk_buff *skb, unsigned int *header_len,
665 uint8_t *chaddr) 672 uint8_t *chaddr)
666 { 673 {
667 enum batadv_dhcp_recipient ret = BATADV_DHCP_NO; 674 enum batadv_dhcp_recipient ret = BATADV_DHCP_NO;
668 struct ethhdr *ethhdr; 675 struct ethhdr *ethhdr;
669 struct iphdr *iphdr; 676 struct iphdr *iphdr;
670 struct ipv6hdr *ipv6hdr; 677 struct ipv6hdr *ipv6hdr;
671 struct udphdr *udphdr; 678 struct udphdr *udphdr;
672 struct vlan_ethhdr *vhdr; 679 struct vlan_ethhdr *vhdr;
673 int chaddr_offset; 680 int chaddr_offset;
674 __be16 proto; 681 __be16 proto;
675 uint8_t *p; 682 uint8_t *p;
676 683
677 /* check for ethernet header */ 684 /* check for ethernet header */
678 if (!pskb_may_pull(skb, *header_len + ETH_HLEN)) 685 if (!pskb_may_pull(skb, *header_len + ETH_HLEN))
679 return BATADV_DHCP_NO; 686 return BATADV_DHCP_NO;
680 687
681 ethhdr = eth_hdr(skb); 688 ethhdr = eth_hdr(skb);
682 proto = ethhdr->h_proto; 689 proto = ethhdr->h_proto;
683 *header_len += ETH_HLEN; 690 *header_len += ETH_HLEN;
684 691
685 /* check for initial vlan header */ 692 /* check for initial vlan header */
686 if (proto == htons(ETH_P_8021Q)) { 693 if (proto == htons(ETH_P_8021Q)) {
687 if (!pskb_may_pull(skb, *header_len + VLAN_HLEN)) 694 if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))
688 return BATADV_DHCP_NO; 695 return BATADV_DHCP_NO;
689 696
690 vhdr = vlan_eth_hdr(skb); 697 vhdr = vlan_eth_hdr(skb);
691 proto = vhdr->h_vlan_encapsulated_proto; 698 proto = vhdr->h_vlan_encapsulated_proto;
692 *header_len += VLAN_HLEN; 699 *header_len += VLAN_HLEN;
693 } 700 }
694 701
695 /* check for ip header */ 702 /* check for ip header */
696 switch (proto) { 703 switch (proto) {
697 case htons(ETH_P_IP): 704 case htons(ETH_P_IP):
698 if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr))) 705 if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))
699 return BATADV_DHCP_NO; 706 return BATADV_DHCP_NO;
700 707
701 iphdr = (struct iphdr *)(skb->data + *header_len); 708 iphdr = (struct iphdr *)(skb->data + *header_len);
702 *header_len += iphdr->ihl * 4; 709 *header_len += iphdr->ihl * 4;
703 710
704 /* check for udp header */ 711 /* check for udp header */
705 if (iphdr->protocol != IPPROTO_UDP) 712 if (iphdr->protocol != IPPROTO_UDP)
706 return BATADV_DHCP_NO; 713 return BATADV_DHCP_NO;
707 714
708 break; 715 break;
709 case htons(ETH_P_IPV6): 716 case htons(ETH_P_IPV6):
710 if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr))) 717 if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))
711 return BATADV_DHCP_NO; 718 return BATADV_DHCP_NO;
712 719
713 ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len); 720 ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);
714 *header_len += sizeof(*ipv6hdr); 721 *header_len += sizeof(*ipv6hdr);
715 722
716 /* check for udp header */ 723 /* check for udp header */
717 if (ipv6hdr->nexthdr != IPPROTO_UDP) 724 if (ipv6hdr->nexthdr != IPPROTO_UDP)
718 return BATADV_DHCP_NO; 725 return BATADV_DHCP_NO;
719 726
720 break; 727 break;
721 default: 728 default:
722 return BATADV_DHCP_NO; 729 return BATADV_DHCP_NO;
723 } 730 }
724 731
725 if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr))) 732 if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
726 return BATADV_DHCP_NO; 733 return BATADV_DHCP_NO;
727 734
728 /* skb->data might have been reallocated by pskb_may_pull() */ 735 /* skb->data might have been reallocated by pskb_may_pull() */
729 ethhdr = eth_hdr(skb); 736 ethhdr = eth_hdr(skb);
730 if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) 737 if (ntohs(ethhdr->h_proto) == ETH_P_8021Q)
731 ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN); 738 ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);
732 739
733 udphdr = (struct udphdr *)(skb->data + *header_len); 740 udphdr = (struct udphdr *)(skb->data + *header_len);
734 *header_len += sizeof(*udphdr); 741 *header_len += sizeof(*udphdr);
735 742
736 /* check for bootp port */ 743 /* check for bootp port */
737 switch (proto) { 744 switch (proto) {
738 case htons(ETH_P_IP): 745 case htons(ETH_P_IP):
739 if (udphdr->dest == htons(67)) 746 if (udphdr->dest == htons(67))
740 ret = BATADV_DHCP_TO_SERVER; 747 ret = BATADV_DHCP_TO_SERVER;
741 else if (udphdr->source == htons(67)) 748 else if (udphdr->source == htons(67))
742 ret = BATADV_DHCP_TO_CLIENT; 749 ret = BATADV_DHCP_TO_CLIENT;
743 break; 750 break;
744 case htons(ETH_P_IPV6): 751 case htons(ETH_P_IPV6):
745 if (udphdr->dest == htons(547)) 752 if (udphdr->dest == htons(547))
746 ret = BATADV_DHCP_TO_SERVER; 753 ret = BATADV_DHCP_TO_SERVER;
747 else if (udphdr->source == htons(547)) 754 else if (udphdr->source == htons(547))
748 ret = BATADV_DHCP_TO_CLIENT; 755 ret = BATADV_DHCP_TO_CLIENT;
749 break; 756 break;
750 } 757 }
751 758
752 chaddr_offset = *header_len + BATADV_DHCP_CHADDR_OFFSET; 759 chaddr_offset = *header_len + BATADV_DHCP_CHADDR_OFFSET;
753 /* store the client address if the message is going to a client */ 760 /* store the client address if the message is going to a client */
754 if (ret == BATADV_DHCP_TO_CLIENT && 761 if (ret == BATADV_DHCP_TO_CLIENT &&
755 pskb_may_pull(skb, chaddr_offset + ETH_ALEN)) { 762 pskb_may_pull(skb, chaddr_offset + ETH_ALEN)) {
756 /* check if the DHCP packet carries an Ethernet DHCP */ 763 /* check if the DHCP packet carries an Ethernet DHCP */
757 p = skb->data + *header_len + BATADV_DHCP_HTYPE_OFFSET; 764 p = skb->data + *header_len + BATADV_DHCP_HTYPE_OFFSET;
758 if (*p != BATADV_DHCP_HTYPE_ETHERNET) 765 if (*p != BATADV_DHCP_HTYPE_ETHERNET)
759 return BATADV_DHCP_NO; 766 return BATADV_DHCP_NO;
760 767
761 /* check if the DHCP packet carries a valid Ethernet address */ 768 /* check if the DHCP packet carries a valid Ethernet address */
762 p = skb->data + *header_len + BATADV_DHCP_HLEN_OFFSET; 769 p = skb->data + *header_len + BATADV_DHCP_HLEN_OFFSET;
763 if (*p != ETH_ALEN) 770 if (*p != ETH_ALEN)
764 return BATADV_DHCP_NO; 771 return BATADV_DHCP_NO;
765 772
766 ether_addr_copy(chaddr, skb->data + chaddr_offset); 773 ether_addr_copy(chaddr, skb->data + chaddr_offset);
767 } 774 }
768 775
769 return ret; 776 return ret;
770 } 777 }
771 /** 778 /**
772 * batadv_gw_out_of_range - check if the dhcp request destination is the best gw 779 * batadv_gw_out_of_range - check if the dhcp request destination is the best gw
773 * @bat_priv: the bat priv with all the soft interface information 780 * @bat_priv: the bat priv with all the soft interface information
774 * @skb: the outgoing packet 781 * @skb: the outgoing packet
775 * 782 *
776 * Check if the skb is a DHCP request and if it is sent to the current best GW 783 * Check if the skb is a DHCP request and if it is sent to the current best GW
777 * server. Due to topology changes it may be the case that the GW server 784 * server. Due to topology changes it may be the case that the GW server
778 * previously selected is not the best one anymore. 785 * previously selected is not the best one anymore.
779 * 786 *
780 * Returns true if the packet destination is unicast and it is not the best gw, 787 * Returns true if the packet destination is unicast and it is not the best gw,
781 * false otherwise. 788 * false otherwise.
782 * 789 *
783 * This call might reallocate skb data. 790 * This call might reallocate skb data.
784 * Must be invoked only when the DHCP packet is going TO a DHCP SERVER. 791 * Must be invoked only when the DHCP packet is going TO a DHCP SERVER.
785 */ 792 */
786 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv, 793 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
787 struct sk_buff *skb) 794 struct sk_buff *skb)
788 { 795 {
789 struct batadv_neigh_node *neigh_curr = NULL, *neigh_old = NULL; 796 struct batadv_neigh_node *neigh_curr = NULL, *neigh_old = NULL;
790 struct batadv_orig_node *orig_dst_node = NULL; 797 struct batadv_orig_node *orig_dst_node = NULL;
791 struct batadv_gw_node *gw_node = NULL, *curr_gw = NULL; 798 struct batadv_gw_node *gw_node = NULL, *curr_gw = NULL;
792 struct batadv_neigh_ifinfo *curr_ifinfo, *old_ifinfo; 799 struct batadv_neigh_ifinfo *curr_ifinfo, *old_ifinfo;
793 struct ethhdr *ethhdr = (struct ethhdr *)skb->data; 800 struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
794 bool out_of_range = false; 801 bool out_of_range = false;
795 uint8_t curr_tq_avg; 802 uint8_t curr_tq_avg;
796 unsigned short vid; 803 unsigned short vid;
797 804
798 vid = batadv_get_vid(skb, 0); 805 vid = batadv_get_vid(skb, 0);
799 806
800 orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source, 807 orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
801 ethhdr->h_dest, vid); 808 ethhdr->h_dest, vid);
802 if (!orig_dst_node) 809 if (!orig_dst_node)
803 goto out; 810 goto out;
804 811
805 gw_node = batadv_gw_node_get(bat_priv, orig_dst_node); 812 gw_node = batadv_gw_node_get(bat_priv, orig_dst_node);
806 if (!gw_node->bandwidth_down == 0) 813 if (!gw_node->bandwidth_down == 0)
807 goto out; 814 goto out;
808 815
809 switch (atomic_read(&bat_priv->gw_mode)) { 816 switch (atomic_read(&bat_priv->gw_mode)) {
810 case BATADV_GW_MODE_SERVER: 817 case BATADV_GW_MODE_SERVER:
811 /* If we are a GW then we are our best GW. We can artificially 818 /* If we are a GW then we are our best GW. We can artificially
812 * set the tq towards ourself as the maximum value 819 * set the tq towards ourself as the maximum value
813 */ 820 */
814 curr_tq_avg = BATADV_TQ_MAX_VALUE; 821 curr_tq_avg = BATADV_TQ_MAX_VALUE;
815 break; 822 break;
816 case BATADV_GW_MODE_CLIENT: 823 case BATADV_GW_MODE_CLIENT:
817 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 824 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
818 if (!curr_gw) 825 if (!curr_gw)
819 goto out; 826 goto out;
820 827
821 /* packet is going to our gateway */ 828 /* packet is going to our gateway */
822 if (curr_gw->orig_node == orig_dst_node) 829 if (curr_gw->orig_node == orig_dst_node)
823 goto out; 830 goto out;
824 831
825 /* If the dhcp packet has been sent to a different gw, 832 /* If the dhcp packet has been sent to a different gw,
826 * we have to evaluate whether the old gw is still 833 * we have to evaluate whether the old gw is still
827 * reliable enough 834 * reliable enough
828 */ 835 */
829 neigh_curr = batadv_find_router(bat_priv, curr_gw->orig_node, 836 neigh_curr = batadv_find_router(bat_priv, curr_gw->orig_node,
830 NULL); 837 NULL);
831 if (!neigh_curr) 838 if (!neigh_curr)
832 goto out; 839 goto out;
833 840
834 curr_ifinfo = batadv_neigh_ifinfo_get(neigh_curr, 841 curr_ifinfo = batadv_neigh_ifinfo_get(neigh_curr,
835 BATADV_IF_DEFAULT); 842 BATADV_IF_DEFAULT);
836 if (!curr_ifinfo) 843 if (!curr_ifinfo)
837 goto out; 844 goto out;
838 845
839 curr_tq_avg = curr_ifinfo->bat_iv.tq_avg; 846 curr_tq_avg = curr_ifinfo->bat_iv.tq_avg;
840 batadv_neigh_ifinfo_free_ref(curr_ifinfo); 847 batadv_neigh_ifinfo_free_ref(curr_ifinfo);
841 848
842 break; 849 break;
843 case BATADV_GW_MODE_OFF: 850 case BATADV_GW_MODE_OFF:
844 default: 851 default:
845 goto out; 852 goto out;
846 } 853 }
847 854
848 neigh_old = batadv_find_router(bat_priv, orig_dst_node, NULL); 855 neigh_old = batadv_find_router(bat_priv, orig_dst_node, NULL);
849 if (!neigh_old) 856 if (!neigh_old)
850 goto out; 857 goto out;
851 858
852 old_ifinfo = batadv_neigh_ifinfo_get(neigh_old, BATADV_IF_DEFAULT); 859 old_ifinfo = batadv_neigh_ifinfo_get(neigh_old, BATADV_IF_DEFAULT);
853 if (!old_ifinfo) 860 if (!old_ifinfo)
854 goto out; 861 goto out;
855 862
856 if ((curr_tq_avg - old_ifinfo->bat_iv.tq_avg) > BATADV_GW_THRESHOLD) 863 if ((curr_tq_avg - old_ifinfo->bat_iv.tq_avg) > BATADV_GW_THRESHOLD)
857 out_of_range = true; 864 out_of_range = true;
858 batadv_neigh_ifinfo_free_ref(old_ifinfo); 865 batadv_neigh_ifinfo_free_ref(old_ifinfo);
859 866
860 out: 867 out:
861 if (orig_dst_node) 868 if (orig_dst_node)
862 batadv_orig_node_free_ref(orig_dst_node); 869 batadv_orig_node_free_ref(orig_dst_node);
863 if (curr_gw) 870 if (curr_gw)
864 batadv_gw_node_free_ref(curr_gw); 871 batadv_gw_node_free_ref(curr_gw);
865 if (gw_node) 872 if (gw_node)
866 batadv_gw_node_free_ref(gw_node); 873 batadv_gw_node_free_ref(gw_node);
867 if (neigh_old) 874 if (neigh_old)
868 batadv_neigh_node_free_ref(neigh_old); 875 batadv_neigh_node_free_ref(neigh_old);
869 if (neigh_curr) 876 if (neigh_curr)
870 batadv_neigh_node_free_ref(neigh_curr); 877 batadv_neigh_node_free_ref(neigh_curr);
871 return out_of_range; 878 return out_of_range;
872 } 879 }
873 880