1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) B.A.T.M.A.N. contributors:
3 *
4 * Marek Lindner
5 */
6
7 #include "gateway_client.h"
8 #include "main.h"
9
10 #include <linux/atomic.h>
11 #include <linux/byteorder/generic.h>
12 #include <linux/container_of.h>
13 #include <linux/errno.h>
14 #include <linux/etherdevice.h>
15 #include <linux/gfp.h>
16 #include <linux/if_ether.h>
17 #include <linux/if_vlan.h>
18 #include <linux/in.h>
19 #include <linux/ip.h>
20 #include <linux/ipv6.h>
21 #include <linux/kref.h>
22 #include <linux/list.h>
23 #include <linux/lockdep.h>
24 #include <linux/netdevice.h>
25 #include <linux/netlink.h>
26 #include <linux/rculist.h>
27 #include <linux/rcupdate.h>
28 #include <linux/skbuff.h>
29 #include <linux/slab.h>
30 #include <linux/spinlock.h>
31 #include <linux/sprintf.h>
32 #include <linux/stddef.h>
33 #include <linux/udp.h>
34 #include <net/sock.h>
35 #include <uapi/linux/batadv_packet.h>
36 #include <uapi/linux/batman_adv.h>
37
38 #include "hard-interface.h"
39 #include "log.h"
40 #include "netlink.h"
41 #include "originator.h"
42 #include "routing.h"
43 #include "soft-interface.h"
44 #include "translation-table.h"
45
46 /* These are the offsets of the "hw type" and "hw address length" in the dhcp
47 * packet starting at the beginning of the dhcp header
48 */
49 #define BATADV_DHCP_HTYPE_OFFSET 1
50 #define BATADV_DHCP_HLEN_OFFSET 2
51 /* Value of htype representing Ethernet */
52 #define BATADV_DHCP_HTYPE_ETHERNET 0x01
53 /* This is the offset of the "chaddr" field in the dhcp packet starting at the
54 * beginning of the dhcp header
55 */
56 #define BATADV_DHCP_CHADDR_OFFSET 28
57
58 /**
59 * batadv_gw_node_release() - release gw_node from lists and queue for free
60 * after rcu grace period
61 * @ref: kref pointer of the gw_node
62 */
63 void batadv_gw_node_release(struct kref *ref)
64 {
65 struct batadv_gw_node *gw_node;
66
67 gw_node = container_of(ref, struct batadv_gw_node, refcount);
68
69 batadv_orig_node_put(gw_node->orig_node);
70 kfree_rcu(gw_node, rcu);
71 }
72
73 /**
74 * batadv_gw_get_selected_gw_node() - Get currently selected gateway
75 * @bat_priv: the bat priv with all the soft interface information
76 *
77 * Return: selected gateway (with increased refcnt), NULL on errors
78 */
79 struct batadv_gw_node *
80 batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv)
81 {
82 struct batadv_gw_node *gw_node;
83
84 rcu_read_lock();
85 gw_node = rcu_dereference(bat_priv->gw.curr_gw);
86 if (!gw_node)
87 goto out;
88
89 if (!kref_get_unless_zero(&gw_node->refcount))
90 gw_node = NULL;
91
92 out:
93 rcu_read_unlock();
94 return gw_node;
95 }
96
97 /**
98 * batadv_gw_get_selected_orig() - Get originator of currently selected gateway
99 * @bat_priv: the bat priv with all the soft interface information
100 *
101 * Return: orig_node of selected gateway (with increased refcnt), NULL on errors
102 */
103 struct batadv_orig_node *
104 batadv_gw_get_selected_orig(struct batadv_priv *bat_priv)
105 {
106 struct batadv_gw_node *gw_node;
107 struct batadv_orig_node *orig_node = NULL;
108
109 gw_node = batadv_gw_get_selected_gw_node(bat_priv);
110 if (!gw_node)
111 goto out;
112
113 rcu_read_lock();
114 orig_node = gw_node->orig_node;
115 if (!orig_node)
116 goto unlock;
117
118 if (!kref_get_unless_zero(&orig_node->refcount))
119 orig_node = NULL;
120
121 unlock:
122 rcu_read_unlock();
123 out:
124 batadv_gw_node_put(gw_node);
125 return orig_node;
126 }
127
128 static void batadv_gw_select(struct batadv_priv *bat_priv,
129 struct batadv_gw_node *new_gw_node)
130 {
131 struct batadv_gw_node *curr_gw_node;
132
133 spin_lock_bh(&bat_priv->gw.list_lock);
134
135 if (new_gw_node)
136 kref_get(&new_gw_node->refcount);
137
138 curr_gw_node = rcu_replace_pointer(bat_priv->gw.curr_gw, new_gw_node,
139 true);
140
141 batadv_gw_node_put(curr_gw_node);
142
143 spin_unlock_bh(&bat_priv->gw.list_lock);
144 }
145
146 /**
147 * batadv_gw_reselect() - force a gateway reselection
148 * @bat_priv: the bat priv with all the soft interface information
149 *
150 * Set a flag to remind the GW component to perform a new gateway reselection.
151 * However this function does not ensure that the current gateway is going to be
152 * deselected. The reselection mechanism may elect the same gateway once again.
153 *
154 * This means that invoking batadv_gw_reselect() does not guarantee a gateway
155 * change and therefore a uevent is not necessarily expected.
156 */
157 void batadv_gw_reselect(struct batadv_priv *bat_priv)
158 {
159 atomic_set(&bat_priv->gw.reselect, 1);
160 }
161
162 /**
163 * batadv_gw_check_client_stop() - check if client mode has been switched off
164 * @bat_priv: the bat priv with all the soft interface information
165 *
166 * This function assumes the caller has checked that the gw state *is actually
167 * changing*. This function is not supposed to be called when there is no state
168 * change.
169 */
170 void batadv_gw_check_client_stop(struct batadv_priv *bat_priv)
171 {
172 struct batadv_gw_node *curr_gw;
173
174 if (atomic_read(&bat_priv->gw.mode) != BATADV_GW_MODE_CLIENT)
175 return;
176
177 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
178 if (!curr_gw)
179 return;
180
181 /* deselect the current gateway so that next time that client mode is
182 * enabled a proper GW_ADD event can be sent
183 */
184 batadv_gw_select(bat_priv, NULL);
185
186 /* if batman-adv is switching the gw client mode off and a gateway was
187 * already selected, send a DEL uevent
188 */
189 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL, NULL);
190
191 batadv_gw_node_put(curr_gw);
192 }
193
194 /**
195 * batadv_gw_election() - Elect the best gateway
196 * @bat_priv: the bat priv with all the soft interface information
197 */
198 void batadv_gw_election(struct batadv_priv *bat_priv)
199 {
200 struct batadv_gw_node *curr_gw = NULL;
201 struct batadv_gw_node *next_gw = NULL;
202 struct batadv_neigh_node *router = NULL;
203 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
204 char gw_addr[18] = { '\0' };
205
206 if (atomic_read(&bat_priv->gw.mode) != BATADV_GW_MODE_CLIENT)
207 goto out;
208
209 if (!bat_priv->algo_ops->gw.get_best_gw_node)
210 goto out;
211
212 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
213
214 if (!batadv_atomic_dec_not_zero(&bat_priv->gw.reselect) && curr_gw)
215 goto out;
216
217 /* if gw.reselect is set to 1 it means that a previous call to
218 * gw.is_eligible() said that we have a new best GW, therefore it can
219 * now be picked from the list and selected
220 */
221 next_gw = bat_priv->algo_ops->gw.get_best_gw_node(bat_priv);
222
223 if (curr_gw == next_gw)
224 goto out;
225
226 if (next_gw) {
227 sprintf(gw_addr, "%pM", next_gw->orig_node->orig);
228
229 router = batadv_orig_router_get(next_gw->orig_node,
230 BATADV_IF_DEFAULT);
231 if (!router) {
232 batadv_gw_reselect(bat_priv);
233 goto out;
234 }
235
236 router_ifinfo = batadv_neigh_ifinfo_get(router,
237 BATADV_IF_DEFAULT);
238 if (!router_ifinfo) {
239 batadv_gw_reselect(bat_priv);
240 goto out;
241 }
242 }
243
244 if (curr_gw && !next_gw) {
245 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
246 "Removing selected gateway - no gateway in range\n");
247 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL,
248 NULL);
249 } else if (!curr_gw && next_gw) {
250 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
251 "Adding route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n",
252 next_gw->orig_node->orig,
253 next_gw->bandwidth_down / 10,
254 next_gw->bandwidth_down % 10,
255 next_gw->bandwidth_up / 10,
256 next_gw->bandwidth_up % 10,
257 router_ifinfo->bat_iv.tq_avg);
258 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_ADD,
259 gw_addr);
260 } else {
261 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
262 "Changing route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n",
263 next_gw->orig_node->orig,
264 next_gw->bandwidth_down / 10,
265 next_gw->bandwidth_down % 10,
266 next_gw->bandwidth_up / 10,
267 next_gw->bandwidth_up % 10,
268 router_ifinfo->bat_iv.tq_avg);
269 batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_CHANGE,
270 gw_addr);
271 }
272
273 batadv_gw_select(bat_priv, next_gw);
274
275 out:
276 batadv_gw_node_put(curr_gw);
277 batadv_gw_node_put(next_gw);
278 batadv_neigh_node_put(router);
279 batadv_neigh_ifinfo_put(router_ifinfo);
280 }
281
282 /**
283 * batadv_gw_check_election() - Elect orig node as best gateway when eligible
284 * @bat_priv: the bat priv with all the soft interface information
285 * @orig_node: orig node which is to be checked
286 */
287 void batadv_gw_check_election(struct batadv_priv *bat_priv,
288 struct batadv_orig_node *orig_node)
289 {
290 struct batadv_orig_node *curr_gw_orig;
291
292 /* abort immediately if the routing algorithm does not support gateway
293 * election
294 */
295 if (!bat_priv->algo_ops->gw.is_eligible)
296 return;
297
298 curr_gw_orig = batadv_gw_get_selected_orig(bat_priv);
299 if (!curr_gw_orig)
300 goto reselect;
301
302 /* this node already is the gateway */
303 if (curr_gw_orig == orig_node)
304 goto out;
305
306 if (!bat_priv->algo_ops->gw.is_eligible(bat_priv, curr_gw_orig,
307 orig_node))
308 goto out;
309
310 reselect:
311 batadv_gw_reselect(bat_priv);
312 out:
313 batadv_orig_node_put(curr_gw_orig);
314 }
315
316 /**
317 * batadv_gw_node_add() - add gateway node to list of available gateways
318 * @bat_priv: the bat priv with all the soft interface information
319 * @orig_node: originator announcing gateway capabilities
320 * @gateway: announced bandwidth information
321 *
322 * Has to be called with the appropriate locks being acquired
323 * (gw.list_lock).
324 */
325 static void batadv_gw_node_add(struct batadv_priv *bat_priv,
326 struct batadv_orig_node *orig_node,
327 struct batadv_tvlv_gateway_data *gateway)
328 {
329 struct batadv_gw_node *gw_node;
330
331 lockdep_assert_held(&bat_priv->gw.list_lock);
332
333 if (gateway->bandwidth_down == 0)
334 return;
335
336 gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC);
337 if (!gw_node)
338 return;
339
340 kref_init(&gw_node->refcount);
341 INIT_HLIST_NODE(&gw_node->list);
342 kref_get(&orig_node->refcount);
343 gw_node->orig_node = orig_node;
344 gw_node->bandwidth_down = ntohl(gateway->bandwidth_down);
345 gw_node->bandwidth_up = ntohl(gateway->bandwidth_up);
346
347 kref_get(&gw_node->refcount);
348 hlist_add_head_rcu(&gw_node->list, &bat_priv->gw.gateway_list);
349 bat_priv->gw.generation++;
350
351 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
352 "Found new gateway %pM -> gw bandwidth: %u.%u/%u.%u MBit\n",
353 orig_node->orig,
354 ntohl(gateway->bandwidth_down) / 10,
355 ntohl(gateway->bandwidth_down) % 10,
356 ntohl(gateway->bandwidth_up) / 10,
357 ntohl(gateway->bandwidth_up) % 10);
358
359 /* don't return reference to new gw_node */
360 batadv_gw_node_put(gw_node);
361 }
362
363 /**
364 * batadv_gw_node_get() - retrieve gateway node from list of available gateways
365 * @bat_priv: the bat priv with all the soft interface information
366 * @orig_node: originator announcing gateway capabilities
367 *
368 * Return: gateway node if found or NULL otherwise.
369 */
370 struct batadv_gw_node *batadv_gw_node_get(struct batadv_priv *bat_priv,
371 struct batadv_orig_node *orig_node)
372 {
373 struct batadv_gw_node *gw_node_tmp, *gw_node = NULL;
374
375 rcu_read_lock();
376 hlist_for_each_entry_rcu(gw_node_tmp, &bat_priv->gw.gateway_list,
377 list) {
378 if (gw_node_tmp->orig_node != orig_node)
379 continue;
380
381 if (!kref_get_unless_zero(&gw_node_tmp->refcount))
382 continue;
383
384 gw_node = gw_node_tmp;
385 break;
386 }
387 rcu_read_unlock();
388
389 return gw_node;
390 }
391
392 /**
393 * batadv_gw_node_update() - update list of available gateways with changed
394 * bandwidth information
395 * @bat_priv: the bat priv with all the soft interface information
396 * @orig_node: originator announcing gateway capabilities
397 * @gateway: announced bandwidth information
398 */
399 void batadv_gw_node_update(struct batadv_priv *bat_priv,
400 struct batadv_orig_node *orig_node,
401 struct batadv_tvlv_gateway_data *gateway)
402 {
403 struct batadv_gw_node *gw_node, *curr_gw = NULL;
404
405 spin_lock_bh(&bat_priv->gw.list_lock);
406 gw_node = batadv_gw_node_get(bat_priv, orig_node);
407 if (!gw_node) {
408 batadv_gw_node_add(bat_priv, orig_node, gateway);
409 spin_unlock_bh(&bat_priv->gw.list_lock);
410 goto out;
411 }
412 spin_unlock_bh(&bat_priv->gw.list_lock);
413
414 if (gw_node->bandwidth_down == ntohl(gateway->bandwidth_down) &&
415 gw_node->bandwidth_up == ntohl(gateway->bandwidth_up))
416 goto out;
417
418 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
419 "Gateway bandwidth of originator %pM changed from %u.%u/%u.%u MBit to %u.%u/%u.%u MBit\n",
420 orig_node->orig,
421 gw_node->bandwidth_down / 10,
422 gw_node->bandwidth_down % 10,
423 gw_node->bandwidth_up / 10,
424 gw_node->bandwidth_up % 10,
425 ntohl(gateway->bandwidth_down) / 10,
426 ntohl(gateway->bandwidth_down) % 10,
427 ntohl(gateway->bandwidth_up) / 10,
428 ntohl(gateway->bandwidth_up) % 10);
429
430 gw_node->bandwidth_down = ntohl(gateway->bandwidth_down);
431 gw_node->bandwidth_up = ntohl(gateway->bandwidth_up);
432
433 if (ntohl(gateway->bandwidth_down) == 0) {
434 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
435 "Gateway %pM removed from gateway list\n",
436 orig_node->orig);
437
438 /* Note: We don't need a NULL check here, since curr_gw never
439 * gets dereferenced.
440 */
441 spin_lock_bh(&bat_priv->gw.list_lock);
442 if (!hlist_unhashed(&gw_node->list)) {
443 hlist_del_init_rcu(&gw_node->list);
444 batadv_gw_node_put(gw_node);
445 bat_priv->gw.generation++;
446 }
447 spin_unlock_bh(&bat_priv->gw.list_lock);
448
449 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
450 if (gw_node == curr_gw)
451 batadv_gw_reselect(bat_priv);
452
453 batadv_gw_node_put(curr_gw);
454 }
455
456 out:
457 batadv_gw_node_put(gw_node);
458 }
459
460 /**
461 * batadv_gw_node_delete() - Remove orig_node from gateway list
462 * @bat_priv: the bat priv with all the soft interface information
463 * @orig_node: orig node which is currently in process of being removed
464 */
465 void batadv_gw_node_delete(struct batadv_priv *bat_priv,
466 struct batadv_orig_node *orig_node)
467 {
468 struct batadv_tvlv_gateway_data gateway;
469
470 gateway.bandwidth_down = 0;
471 gateway.bandwidth_up = 0;
472
473 batadv_gw_node_update(bat_priv, orig_node, &gateway);
474 }
475
476 /**
477 * batadv_gw_node_free() - Free gateway information from soft interface
478 * @bat_priv: the bat priv with all the soft interface information
479 */
480 void batadv_gw_node_free(struct batadv_priv *bat_priv)
481 {
482 struct batadv_gw_node *gw_node;
483 struct hlist_node *node_tmp;
484
485 spin_lock_bh(&bat_priv->gw.list_lock);
486 hlist_for_each_entry_safe(gw_node, node_tmp,
487 &bat_priv->gw.gateway_list, list) {
488 hlist_del_init_rcu(&gw_node->list);
489 batadv_gw_node_put(gw_node);
490 bat_priv->gw.generation++;
491 }
492 spin_unlock_bh(&bat_priv->gw.list_lock);
493 }
494
495 /**
496 * batadv_gw_dump() - Dump gateways into a message
497 * @msg: Netlink message to dump into
498 * @cb: Control block containing additional options
499 *
500 * Return: Error code, or length of message
501 */
502 int batadv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb)
503 {
504 struct batadv_hard_iface *primary_if = NULL;
505 struct net *net = sock_net(cb->skb->sk);
506 struct net_device *soft_iface;
507 struct batadv_priv *bat_priv;
508 int ifindex;
509 int ret;
510
511 ifindex = batadv_netlink_get_ifindex(cb->nlh,
512 BATADV_ATTR_MESH_IFINDEX);
513 if (!ifindex)
514 return -EINVAL;
515
516 soft_iface = dev_get_by_index(net, ifindex);
517 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
518 ret = -ENODEV;
519 goto out;
520 }
521
522 bat_priv = netdev_priv(soft_iface);
523
524 primary_if = batadv_primary_if_get_selected(bat_priv);
525 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
526 ret = -ENOENT;
527 goto out;
528 }
529
530 if (!bat_priv->algo_ops->gw.dump) {
531 ret = -EOPNOTSUPP;
532 goto out;
533 }
534
535 bat_priv->algo_ops->gw.dump(msg, cb, bat_priv);
536
537 ret = msg->len;
538
539 out:
540 batadv_hardif_put(primary_if);
541 dev_put(soft_iface);
542
543 return ret;
544 }
545
546 /**
547 * batadv_gw_dhcp_recipient_get() - check if a packet is a DHCP message
548 * @skb: the packet to check
549 * @header_len: a pointer to the batman-adv header size
550 * @chaddr: buffer where the client address will be stored. Valid
551 * only if the function returns BATADV_DHCP_TO_CLIENT
552 *
553 * This function may re-allocate the data buffer of the skb passed as argument.
554 *
555 * Return:
556 * - BATADV_DHCP_NO if the packet is not a dhcp message or if there was an error
557 * while parsing it
558 * - BATADV_DHCP_TO_SERVER if this is a message going to the DHCP server
559 * - BATADV_DHCP_TO_CLIENT if this is a message going to a DHCP client
560 */
561 enum batadv_dhcp_recipient
562 batadv_gw_dhcp_recipient_get(struct sk_buff *skb, unsigned int *header_len,
563 u8 *chaddr)
564 {
565 enum batadv_dhcp_recipient ret = BATADV_DHCP_NO;
566 struct ethhdr *ethhdr;
567 struct iphdr *iphdr;
568 struct ipv6hdr *ipv6hdr;
569 struct udphdr *udphdr;
570 struct vlan_ethhdr *vhdr;
571 int chaddr_offset;
572 __be16 proto;
573 u8 *p;
574
575 /* check for ethernet header */
576 if (!pskb_may_pull(skb, *header_len + ETH_HLEN))
577 return BATADV_DHCP_NO;
578
579 ethhdr = eth_hdr(skb);
580 proto = ethhdr->h_proto;
581 *header_len += ETH_HLEN;
582
583 /* check for initial vlan header */
584 if (proto == htons(ETH_P_8021Q)) {
585 if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))
586 return BATADV_DHCP_NO;
587
588 vhdr = vlan_eth_hdr(skb);
589 proto = vhdr->h_vlan_encapsulated_proto;
590 *header_len += VLAN_HLEN;
591 }
592
593 /* check for ip header */
594 switch (proto) {
595 case htons(ETH_P_IP):
596 if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))
597 return BATADV_DHCP_NO;
598
599 iphdr = (struct iphdr *)(skb->data + *header_len);
600 *header_len += iphdr->ihl * 4;
601
602 /* check for udp header */
603 if (iphdr->protocol != IPPROTO_UDP)
604 return BATADV_DHCP_NO;
605
606 break;
607 case htons(ETH_P_IPV6):
608 if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))
609 return BATADV_DHCP_NO;
610
611 ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);
612 *header_len += sizeof(*ipv6hdr);
613
614 /* check for udp header */
615 if (ipv6hdr->nexthdr != IPPROTO_UDP)
616 return BATADV_DHCP_NO;
617
618 break;
619 default:
620 return BATADV_DHCP_NO;
621 }
622
623 if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
624 return BATADV_DHCP_NO;
625
626 udphdr = (struct udphdr *)(skb->data + *header_len);
627 *header_len += sizeof(*udphdr);
628
629 /* check for bootp port */
630 switch (proto) {
631 case htons(ETH_P_IP):
632 if (udphdr->dest == htons(67))
633 ret = BATADV_DHCP_TO_SERVER;
634 else if (udphdr->source == htons(67))
635 ret = BATADV_DHCP_TO_CLIENT;
636 break;
637 case htons(ETH_P_IPV6):
638 if (udphdr->dest == htons(547))
639 ret = BATADV_DHCP_TO_SERVER;
640 else if (udphdr->source == htons(547))
641 ret = BATADV_DHCP_TO_CLIENT;
642 break;
643 }
644
645 chaddr_offset = *header_len + BATADV_DHCP_CHADDR_OFFSET;
646 /* store the client address if the message is going to a client */
647 if (ret == BATADV_DHCP_TO_CLIENT) {
648 if (!pskb_may_pull(skb, chaddr_offset + ETH_ALEN))
649 return BATADV_DHCP_NO;
650
651 /* check if the DHCP packet carries an Ethernet DHCP */
652 p = skb->data + *header_len + BATADV_DHCP_HTYPE_OFFSET;
653 if (*p != BATADV_DHCP_HTYPE_ETHERNET)
654 return BATADV_DHCP_NO;
655
656 /* check if the DHCP packet carries a valid Ethernet address */
657 p = skb->data + *header_len + BATADV_DHCP_HLEN_OFFSET;
658 if (*p != ETH_ALEN)
659 return BATADV_DHCP_NO;
660
661 ether_addr_copy(chaddr, skb->data + chaddr_offset);
662 }
663
664 return ret;
665 }
666
667 /**
668 * batadv_gw_out_of_range() - check if the dhcp request destination is the best
669 * gateway
670 * @bat_priv: the bat priv with all the soft interface information
671 * @skb: the outgoing packet
672 *
673 * Check if the skb is a DHCP request and if it is sent to the current best GW
674 * server. Due to topology changes it may be the case that the GW server
675 * previously selected is not the best one anymore.
676 *
677 * This call might reallocate skb data.
678 * Must be invoked only when the DHCP packet is going TO a DHCP SERVER.
679 *
680 * Return: true if the packet destination is unicast and it is not the best gw,
681 * false otherwise.
682 */
683 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
684 struct sk_buff *skb)
685 {
686 struct batadv_neigh_node *neigh_curr = NULL;
687 struct batadv_neigh_node *neigh_old = NULL;
688 struct batadv_orig_node *orig_dst_node = NULL;
689 struct batadv_gw_node *gw_node = NULL;
690 struct batadv_gw_node *curr_gw = NULL;
691 struct batadv_neigh_ifinfo *curr_ifinfo, *old_ifinfo;
692 struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
693 bool out_of_range = false;
694 u8 curr_tq_avg;
695 unsigned short vid;
696
697 vid = batadv_get_vid(skb, 0);
698
699 if (is_multicast_ether_addr(ethhdr->h_dest))
700 goto out;
701
702 orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
703 ethhdr->h_dest, vid);
704 if (!orig_dst_node)
705 goto out;
706
707 gw_node = batadv_gw_node_get(bat_priv, orig_dst_node);
708 if (!gw_node)
709 goto out;
710
711 switch (atomic_read(&bat_priv->gw.mode)) {
712 case BATADV_GW_MODE_SERVER:
713 /* If we are a GW then we are our best GW. We can artificially
714 * set the tq towards ourself as the maximum value
715 */
716 curr_tq_avg = BATADV_TQ_MAX_VALUE;
717 break;
718 case BATADV_GW_MODE_CLIENT:
719 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
720 if (!curr_gw)
721 goto out;
722
723 /* packet is going to our gateway */
724 if (curr_gw->orig_node == orig_dst_node)
725 goto out;
726
727 /* If the dhcp packet has been sent to a different gw,
728 * we have to evaluate whether the old gw is still
729 * reliable enough
730 */
731 neigh_curr = batadv_find_router(bat_priv, curr_gw->orig_node,
732 NULL);
733 if (!neigh_curr)
734 goto out;
735
736 curr_ifinfo = batadv_neigh_ifinfo_get(neigh_curr,
737 BATADV_IF_DEFAULT);
738 if (!curr_ifinfo)
739 goto out;
740
741 curr_tq_avg = curr_ifinfo->bat_iv.tq_avg;
742 batadv_neigh_ifinfo_put(curr_ifinfo);
743
744 break;
745 case BATADV_GW_MODE_OFF:
746 default:
747 goto out;
748 }
749
750 neigh_old = batadv_find_router(bat_priv, orig_dst_node, NULL);
751 if (!neigh_old)
752 goto out;
753
754 old_ifinfo = batadv_neigh_ifinfo_get(neigh_old, BATADV_IF_DEFAULT);
755 if (!old_ifinfo)
756 goto out;
757
758 if ((curr_tq_avg - old_ifinfo->bat_iv.tq_avg) > BATADV_GW_THRESHOLD)
759 out_of_range = true;
760 batadv_neigh_ifinfo_put(old_ifinfo);
761
762 out:
763 batadv_orig_node_put(orig_dst_node);
764 batadv_gw_node_put(curr_gw);
765 batadv_gw_node_put(gw_node);
766 batadv_neigh_node_put(neigh_old);
767 batadv_neigh_node_put(neigh_curr);
768 return out_of_range;
769 }
770
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.