Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gateway_client.c
Go to the documentation of this file.
1 /* Copyright (C) 2009-2012 B.A.T.M.A.N. contributors:
2  *
3  * Marek Lindner
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
18  */
19 
20 #include "main.h"
21 #include "sysfs.h"
22 #include "gateway_client.h"
23 #include "gateway_common.h"
24 #include "hard-interface.h"
25 #include "originator.h"
26 #include "translation-table.h"
27 #include "routing.h"
28 #include <linux/ip.h>
29 #include <linux/ipv6.h>
30 #include <linux/udp.h>
31 #include <linux/if_vlan.h>
32 
33 /* This is the offset of the options field in a dhcp packet starting at
34  * the beginning of the dhcp header
35  */
36 #define BATADV_DHCP_OPTIONS_OFFSET 240
37 #define BATADV_DHCP_REQUEST 3
38 
39 static void batadv_gw_node_free_ref(struct batadv_gw_node *gw_node)
40 {
41  if (atomic_dec_and_test(&gw_node->refcount))
42  kfree_rcu(gw_node, rcu);
43 }
44 
45 static struct batadv_gw_node *
46 batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv)
47 {
48  struct batadv_gw_node *gw_node;
49 
50  rcu_read_lock();
51  gw_node = rcu_dereference(bat_priv->gw.curr_gw);
52  if (!gw_node)
53  goto out;
54 
55  if (!atomic_inc_not_zero(&gw_node->refcount))
56  gw_node = NULL;
57 
58 out:
59  rcu_read_unlock();
60  return gw_node;
61 }
62 
63 struct batadv_orig_node *
65 {
66  struct batadv_gw_node *gw_node;
67  struct batadv_orig_node *orig_node = NULL;
68 
69  gw_node = batadv_gw_get_selected_gw_node(bat_priv);
70  if (!gw_node)
71  goto out;
72 
73  rcu_read_lock();
74  orig_node = gw_node->orig_node;
75  if (!orig_node)
76  goto unlock;
77 
78  if (!atomic_inc_not_zero(&orig_node->refcount))
79  orig_node = NULL;
80 
81 unlock:
82  rcu_read_unlock();
83 out:
84  if (gw_node)
85  batadv_gw_node_free_ref(gw_node);
86  return orig_node;
87 }
88 
89 static void batadv_gw_select(struct batadv_priv *bat_priv,
90  struct batadv_gw_node *new_gw_node)
91 {
92  struct batadv_gw_node *curr_gw_node;
93 
94  spin_lock_bh(&bat_priv->gw.list_lock);
95 
96  if (new_gw_node && !atomic_inc_not_zero(&new_gw_node->refcount))
97  new_gw_node = NULL;
98 
99  curr_gw_node = rcu_dereference_protected(bat_priv->gw.curr_gw, 1);
100  rcu_assign_pointer(bat_priv->gw.curr_gw, new_gw_node);
101 
102  if (curr_gw_node)
103  batadv_gw_node_free_ref(curr_gw_node);
104 
105  spin_unlock_bh(&bat_priv->gw.list_lock);
106 }
107 
108 void batadv_gw_deselect(struct batadv_priv *bat_priv)
109 {
110  atomic_set(&bat_priv->gw.reselect, 1);
111 }
112 
113 static struct batadv_gw_node *
114 batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
115 {
116  struct batadv_neigh_node *router;
117  struct hlist_node *node;
118  struct batadv_gw_node *gw_node, *curr_gw = NULL;
119  uint32_t max_gw_factor = 0, tmp_gw_factor = 0;
120  uint32_t gw_divisor;
121  uint8_t max_tq = 0;
122  int down, up;
123  uint8_t tq_avg;
124  struct batadv_orig_node *orig_node;
125 
127  gw_divisor *= 64;
128 
129  rcu_read_lock();
130  hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
131  if (gw_node->deleted)
132  continue;
133 
134  orig_node = gw_node->orig_node;
135  router = batadv_orig_node_get_router(orig_node);
136  if (!router)
137  continue;
138 
139  if (!atomic_inc_not_zero(&gw_node->refcount))
140  goto next;
141 
142  tq_avg = router->tq_avg;
143 
144  switch (atomic_read(&bat_priv->gw_sel_class)) {
145  case 1: /* fast connection */
147  &down, &up);
148 
149  tmp_gw_factor = tq_avg * tq_avg * down * 100 * 100;
150  tmp_gw_factor /= gw_divisor;
151 
152  if ((tmp_gw_factor > max_gw_factor) ||
153  ((tmp_gw_factor == max_gw_factor) &&
154  (tq_avg > max_tq))) {
155  if (curr_gw)
156  batadv_gw_node_free_ref(curr_gw);
157  curr_gw = gw_node;
158  atomic_inc(&curr_gw->refcount);
159  }
160  break;
161 
162  default: /* 2: stable connection (use best statistic)
163  * 3: fast-switch (use best statistic but change as
164  * soon as a better gateway appears)
165  * XX: late-switch (use best statistic but change as
166  * soon as a better gateway appears which has
167  * $routing_class more tq points)
168  */
169  if (tq_avg > max_tq) {
170  if (curr_gw)
171  batadv_gw_node_free_ref(curr_gw);
172  curr_gw = gw_node;
173  atomic_inc(&curr_gw->refcount);
174  }
175  break;
176  }
177 
178  if (tq_avg > max_tq)
179  max_tq = tq_avg;
180 
181  if (tmp_gw_factor > max_gw_factor)
182  max_gw_factor = tmp_gw_factor;
183 
184  batadv_gw_node_free_ref(gw_node);
185 
186 next:
188  }
189  rcu_read_unlock();
190 
191  return curr_gw;
192 }
193 
194 void batadv_gw_election(struct batadv_priv *bat_priv)
195 {
196  struct batadv_gw_node *curr_gw = NULL, *next_gw = NULL;
197  struct batadv_neigh_node *router = NULL;
198  char gw_addr[18] = { '\0' };
199 
200  /* The batman daemon checks here if we already passed a full originator
201  * cycle in order to make sure we don't choose the first gateway we
202  * hear about. This check is based on the daemon's uptime which we
203  * don't have.
204  */
205  if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT)
206  goto out;
207 
208  curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
209 
210  if (!batadv_atomic_dec_not_zero(&bat_priv->gw.reselect) && curr_gw)
211  goto out;
212 
213  next_gw = batadv_gw_get_best_gw_node(bat_priv);
214 
215  if (curr_gw == next_gw)
216  goto out;
217 
218  if (next_gw) {
219  sprintf(gw_addr, "%pM", next_gw->orig_node->orig);
220 
221  router = batadv_orig_node_get_router(next_gw->orig_node);
222  if (!router) {
223  batadv_gw_deselect(bat_priv);
224  goto out;
225  }
226  }
227 
228  if ((curr_gw) && (!next_gw)) {
229  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
230  "Removing selected gateway - no gateway in range\n");
232  NULL);
233  } else if ((!curr_gw) && (next_gw)) {
234  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
235  "Adding route to gateway %pM (gw_flags: %i, tq: %i)\n",
236  next_gw->orig_node->orig,
237  next_gw->orig_node->gw_flags, router->tq_avg);
239  gw_addr);
240  } else {
241  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
242  "Changing route to gateway %pM (gw_flags: %i, tq: %i)\n",
243  next_gw->orig_node->orig,
244  next_gw->orig_node->gw_flags, router->tq_avg);
246  gw_addr);
247  }
248 
249  batadv_gw_select(bat_priv, next_gw);
250 
251 out:
252  if (curr_gw)
253  batadv_gw_node_free_ref(curr_gw);
254  if (next_gw)
255  batadv_gw_node_free_ref(next_gw);
256  if (router)
258 }
259 
260 void batadv_gw_check_election(struct batadv_priv *bat_priv,
261  struct batadv_orig_node *orig_node)
262 {
263  struct batadv_orig_node *curr_gw_orig;
264  struct batadv_neigh_node *router_gw = NULL, *router_orig = NULL;
265  uint8_t gw_tq_avg, orig_tq_avg;
266 
267  curr_gw_orig = batadv_gw_get_selected_orig(bat_priv);
268  if (!curr_gw_orig)
269  goto deselect;
270 
271  router_gw = batadv_orig_node_get_router(curr_gw_orig);
272  if (!router_gw)
273  goto deselect;
274 
275  /* this node already is the gateway */
276  if (curr_gw_orig == orig_node)
277  goto out;
278 
279  router_orig = batadv_orig_node_get_router(orig_node);
280  if (!router_orig)
281  goto out;
282 
283  gw_tq_avg = router_gw->tq_avg;
284  orig_tq_avg = router_orig->tq_avg;
285 
286  /* the TQ value has to be better */
287  if (orig_tq_avg < gw_tq_avg)
288  goto out;
289 
290  /* if the routing class is greater than 3 the value tells us how much
291  * greater the TQ value of the new gateway must be
292  */
293  if ((atomic_read(&bat_priv->gw_sel_class) > 3) &&
294  (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class)))
295  goto out;
296 
297  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
298  "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n",
299  gw_tq_avg, orig_tq_avg);
300 
301 deselect:
302  batadv_gw_deselect(bat_priv);
303 out:
304  if (curr_gw_orig)
305  batadv_orig_node_free_ref(curr_gw_orig);
306  if (router_gw)
307  batadv_neigh_node_free_ref(router_gw);
308  if (router_orig)
309  batadv_neigh_node_free_ref(router_orig);
310 
311  return;
312 }
313 
314 static void batadv_gw_node_add(struct batadv_priv *bat_priv,
315  struct batadv_orig_node *orig_node,
316  uint8_t new_gwflags)
317 {
318  struct batadv_gw_node *gw_node;
319  int down, up;
320 
321  gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC);
322  if (!gw_node)
323  return;
324 
325  INIT_HLIST_NODE(&gw_node->list);
326  gw_node->orig_node = orig_node;
327  atomic_set(&gw_node->refcount, 1);
328 
329  spin_lock_bh(&bat_priv->gw.list_lock);
330  hlist_add_head_rcu(&gw_node->list, &bat_priv->gw.list);
331  spin_unlock_bh(&bat_priv->gw.list_lock);
332 
333  batadv_gw_bandwidth_to_kbit(new_gwflags, &down, &up);
334  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
335  "Found new gateway %pM -> gw_class: %i - %i%s/%i%s\n",
336  orig_node->orig, new_gwflags,
337  (down > 2048 ? down / 1024 : down),
338  (down > 2048 ? "MBit" : "KBit"),
339  (up > 2048 ? up / 1024 : up),
340  (up > 2048 ? "MBit" : "KBit"));
341 }
342 
343 void batadv_gw_node_update(struct batadv_priv *bat_priv,
344  struct batadv_orig_node *orig_node,
345  uint8_t new_gwflags)
346 {
347  struct hlist_node *node;
348  struct batadv_gw_node *gw_node, *curr_gw;
349 
350  /* Note: We don't need a NULL check here, since curr_gw never gets
351  * dereferenced. If curr_gw is NULL we also should not exit as we may
352  * have this gateway in our list (duplication check!) even though we
353  * have no currently selected gateway.
354  */
355  curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
356 
357  rcu_read_lock();
358  hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
359  if (gw_node->orig_node != orig_node)
360  continue;
361 
362  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
363  "Gateway class of originator %pM changed from %i to %i\n",
364  orig_node->orig, gw_node->orig_node->gw_flags,
365  new_gwflags);
366 
367  gw_node->deleted = 0;
368 
369  if (new_gwflags == BATADV_NO_FLAGS) {
370  gw_node->deleted = jiffies;
371  batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
372  "Gateway %pM removed from gateway list\n",
373  orig_node->orig);
374 
375  if (gw_node == curr_gw)
376  goto deselect;
377  }
378 
379  goto unlock;
380  }
381 
382  if (new_gwflags == BATADV_NO_FLAGS)
383  goto unlock;
384 
385  batadv_gw_node_add(bat_priv, orig_node, new_gwflags);
386  goto unlock;
387 
388 deselect:
389  batadv_gw_deselect(bat_priv);
390 unlock:
391  rcu_read_unlock();
392 
393  if (curr_gw)
394  batadv_gw_node_free_ref(curr_gw);
395 }
396 
397 void batadv_gw_node_delete(struct batadv_priv *bat_priv,
398  struct batadv_orig_node *orig_node)
399 {
400  batadv_gw_node_update(bat_priv, orig_node, 0);
401 }
402 
403 void batadv_gw_node_purge(struct batadv_priv *bat_priv)
404 {
405  struct batadv_gw_node *gw_node, *curr_gw;
406  struct hlist_node *node, *node_tmp;
407  unsigned long timeout = msecs_to_jiffies(2 * BATADV_PURGE_TIMEOUT);
408  int do_deselect = 0;
409 
410  curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
411 
412  spin_lock_bh(&bat_priv->gw.list_lock);
413 
414  hlist_for_each_entry_safe(gw_node, node, node_tmp,
415  &bat_priv->gw.list, list) {
416  if (((!gw_node->deleted) ||
417  (time_before(jiffies, gw_node->deleted + timeout))) &&
419  continue;
420 
421  if (curr_gw == gw_node)
422  do_deselect = 1;
423 
424  hlist_del_rcu(&gw_node->list);
425  batadv_gw_node_free_ref(gw_node);
426  }
427 
428  spin_unlock_bh(&bat_priv->gw.list_lock);
429 
430  /* gw_deselect() needs to acquire the gw_list_lock */
431  if (do_deselect)
432  batadv_gw_deselect(bat_priv);
433 
434  if (curr_gw)
435  batadv_gw_node_free_ref(curr_gw);
436 }
437 
438 /* fails if orig_node has no router */
439 static int batadv_write_buffer_text(struct batadv_priv *bat_priv,
440  struct seq_file *seq,
441  const struct batadv_gw_node *gw_node)
442 {
443  struct batadv_gw_node *curr_gw;
444  struct batadv_neigh_node *router;
445  int down, up, ret = -1;
446 
447  batadv_gw_bandwidth_to_kbit(gw_node->orig_node->gw_flags, &down, &up);
448 
449  router = batadv_orig_node_get_router(gw_node->orig_node);
450  if (!router)
451  goto out;
452 
453  curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
454 
455  ret = seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %3i - %i%s/%i%s\n",
456  (curr_gw == gw_node ? "=>" : " "),
457  gw_node->orig_node->orig,
458  router->tq_avg, router->addr,
459  router->if_incoming->net_dev->name,
460  gw_node->orig_node->gw_flags,
461  (down > 2048 ? down / 1024 : down),
462  (down > 2048 ? "MBit" : "KBit"),
463  (up > 2048 ? up / 1024 : up),
464  (up > 2048 ? "MBit" : "KBit"));
465 
467  if (curr_gw)
468  batadv_gw_node_free_ref(curr_gw);
469 out:
470  return ret;
471 }
472 
474 {
475  struct net_device *net_dev = (struct net_device *)seq->private;
476  struct batadv_priv *bat_priv = netdev_priv(net_dev);
477  struct batadv_hard_iface *primary_if;
478  struct batadv_gw_node *gw_node;
479  struct hlist_node *node;
480  int gw_count = 0, ret = 0;
481 
482  primary_if = batadv_primary_if_get_selected(bat_priv);
483  if (!primary_if) {
484  ret = seq_printf(seq,
485  "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
486  net_dev->name);
487  goto out;
488  }
489 
490  if (primary_if->if_status != BATADV_IF_ACTIVE) {
491  ret = seq_printf(seq,
492  "BATMAN mesh %s disabled - primary interface not active\n",
493  net_dev->name);
494  goto out;
495  }
496 
497  seq_printf(seq,
498  " %-12s (%s/%i) %17s [%10s]: gw_class ... [B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",
499  "Gateway", "#", BATADV_TQ_MAX_VALUE, "Nexthop", "outgoingIF",
500  BATADV_SOURCE_VERSION, primary_if->net_dev->name,
501  primary_if->net_dev->dev_addr, net_dev->name);
502 
503  rcu_read_lock();
504  hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw.list, list) {
505  if (gw_node->deleted)
506  continue;
507 
508  /* fails if orig_node has no router */
509  if (batadv_write_buffer_text(bat_priv, seq, gw_node) < 0)
510  continue;
511 
512  gw_count++;
513  }
514  rcu_read_unlock();
515 
516  if (gw_count == 0)
517  seq_printf(seq, "No gateways in range ...\n");
518 
519 out:
520  if (primary_if)
521  batadv_hardif_free_ref(primary_if);
522  return ret;
523 }
524 
525 static bool batadv_is_type_dhcprequest(struct sk_buff *skb, int header_len)
526 {
527  int ret = false;
528  unsigned char *p;
529  int pkt_len;
530 
531  if (skb_linearize(skb) < 0)
532  goto out;
533 
534  pkt_len = skb_headlen(skb);
535 
536  if (pkt_len < header_len + BATADV_DHCP_OPTIONS_OFFSET + 1)
537  goto out;
538 
539  p = skb->data + header_len + BATADV_DHCP_OPTIONS_OFFSET;
540  pkt_len -= header_len + BATADV_DHCP_OPTIONS_OFFSET + 1;
541 
542  /* Access the dhcp option lists. Each entry is made up by:
543  * - octet 1: option type
544  * - octet 2: option data len (only if type != 255 and 0)
545  * - octet 3: option data
546  */
547  while (*p != 255 && !ret) {
548  /* p now points to the first octet: option type */
549  if (*p == 53) {
550  /* type 53 is the message type option.
551  * Jump the len octet and go to the data octet
552  */
553  if (pkt_len < 2)
554  goto out;
555  p += 2;
556 
557  /* check if the message type is what we need */
558  if (*p == BATADV_DHCP_REQUEST)
559  ret = true;
560  break;
561  } else if (*p == 0) {
562  /* option type 0 (padding), just go forward */
563  if (pkt_len < 1)
564  goto out;
565  pkt_len--;
566  p++;
567  } else {
568  /* This is any other option. So we get the length... */
569  if (pkt_len < 1)
570  goto out;
571  pkt_len--;
572  p++;
573 
574  /* ...and then we jump over the data */
575  if (pkt_len < 1 + (*p))
576  goto out;
577  pkt_len -= 1 + (*p);
578  p += 1 + (*p);
579  }
580  }
581 out:
582  return ret;
583 }
584 
585 bool batadv_gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len)
586 {
587  struct ethhdr *ethhdr;
588  struct iphdr *iphdr;
589  struct ipv6hdr *ipv6hdr;
590  struct udphdr *udphdr;
591 
592  /* check for ethernet header */
593  if (!pskb_may_pull(skb, *header_len + ETH_HLEN))
594  return false;
595  ethhdr = (struct ethhdr *)skb->data;
596  *header_len += ETH_HLEN;
597 
598  /* check for initial vlan header */
599  if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
600  if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))
601  return false;
602  ethhdr = (struct ethhdr *)(skb->data + VLAN_HLEN);
603  *header_len += VLAN_HLEN;
604  }
605 
606  /* check for ip header */
607  switch (ntohs(ethhdr->h_proto)) {
608  case ETH_P_IP:
609  if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))
610  return false;
611  iphdr = (struct iphdr *)(skb->data + *header_len);
612  *header_len += iphdr->ihl * 4;
613 
614  /* check for udp header */
615  if (iphdr->protocol != IPPROTO_UDP)
616  return false;
617 
618  break;
619  case ETH_P_IPV6:
620  if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))
621  return false;
622  ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);
623  *header_len += sizeof(*ipv6hdr);
624 
625  /* check for udp header */
626  if (ipv6hdr->nexthdr != IPPROTO_UDP)
627  return false;
628 
629  break;
630  default:
631  return false;
632  }
633 
634  if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
635  return false;
636  udphdr = (struct udphdr *)(skb->data + *header_len);
637  *header_len += sizeof(*udphdr);
638 
639  /* check for bootp port */
640  if ((ntohs(ethhdr->h_proto) == ETH_P_IP) &&
641  (ntohs(udphdr->dest) != 67))
642  return false;
643 
644  if ((ntohs(ethhdr->h_proto) == ETH_P_IPV6) &&
645  (ntohs(udphdr->dest) != 547))
646  return false;
647 
648  return true;
649 }
650 
651 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
652  struct sk_buff *skb, struct ethhdr *ethhdr)
653 {
654  struct batadv_neigh_node *neigh_curr = NULL, *neigh_old = NULL;
655  struct batadv_orig_node *orig_dst_node = NULL;
656  struct batadv_gw_node *curr_gw = NULL;
657  bool ret, out_of_range = false;
658  unsigned int header_len = 0;
659  uint8_t curr_tq_avg;
660 
661  ret = batadv_gw_is_dhcp_target(skb, &header_len);
662  if (!ret)
663  goto out;
664 
665  orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
666  ethhdr->h_dest);
667  if (!orig_dst_node)
668  goto out;
669 
670  if (!orig_dst_node->gw_flags)
671  goto out;
672 
673  ret = batadv_is_type_dhcprequest(skb, header_len);
674  if (!ret)
675  goto out;
676 
677  switch (atomic_read(&bat_priv->gw_mode)) {
679  /* If we are a GW then we are our best GW. We can artificially
680  * set the tq towards ourself as the maximum value
681  */
682  curr_tq_avg = BATADV_TQ_MAX_VALUE;
683  break;
685  curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
686  if (!curr_gw)
687  goto out;
688 
689  /* packet is going to our gateway */
690  if (curr_gw->orig_node == orig_dst_node)
691  goto out;
692 
693  /* If the dhcp packet has been sent to a different gw,
694  * we have to evaluate whether the old gw is still
695  * reliable enough
696  */
697  neigh_curr = batadv_find_router(bat_priv, curr_gw->orig_node,
698  NULL);
699  if (!neigh_curr)
700  goto out;
701 
702  curr_tq_avg = neigh_curr->tq_avg;
703  break;
704  case BATADV_GW_MODE_OFF:
705  default:
706  goto out;
707  }
708 
709  neigh_old = batadv_find_router(bat_priv, orig_dst_node, NULL);
710  if (!neigh_old)
711  goto out;
712 
713  if (curr_tq_avg - neigh_old->tq_avg > BATADV_GW_THRESHOLD)
714  out_of_range = true;
715 
716 out:
717  if (orig_dst_node)
718  batadv_orig_node_free_ref(orig_dst_node);
719  if (curr_gw)
720  batadv_gw_node_free_ref(curr_gw);
721  if (neigh_old)
722  batadv_neigh_node_free_ref(neigh_old);
723  if (neigh_curr)
724  batadv_neigh_node_free_ref(neigh_curr);
725  return out_of_range;
726 }