1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "main.h"
21#include "routing.h"
22#include "send.h"
23#include "soft-interface.h"
24#include "hard-interface.h"
25#include "icmp_socket.h"
26#include "translation-table.h"
27#include "originator.h"
28#include "vis.h"
29#include "unicast.h"
30#include "bridge_loop_avoidance.h"
31#include "distributed-arp-table.h"
32#include "network-coding.h"
33
34static int batadv_route_unicast_packet(struct sk_buff *skb,
35 struct batadv_hard_iface *recv_if);
36
37static void _batadv_update_route(struct batadv_priv *bat_priv,
38 struct batadv_orig_node *orig_node,
39 struct batadv_neigh_node *neigh_node)
40{
41 struct batadv_neigh_node *curr_router;
42
43 curr_router = batadv_orig_node_get_router(orig_node);
44
45
46 if ((curr_router) && (!neigh_node)) {
47 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
48 "Deleting route towards: %pM\n", orig_node->orig);
49 batadv_tt_global_del_orig(bat_priv, orig_node,
50 "Deleted route towards originator");
51
52
53 } else if ((!curr_router) && (neigh_node)) {
54 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
55 "Adding route towards: %pM (via %pM)\n",
56 orig_node->orig, neigh_node->addr);
57
58 } else if (neigh_node && curr_router) {
59 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
60 "Changing route towards: %pM (now via %pM - was via %pM)\n",
61 orig_node->orig, neigh_node->addr,
62 curr_router->addr);
63 }
64
65 if (curr_router)
66 batadv_neigh_node_free_ref(curr_router);
67
68
69 if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))
70 neigh_node = NULL;
71
72 spin_lock_bh(&orig_node->neigh_list_lock);
73 rcu_assign_pointer(orig_node->router, neigh_node);
74 spin_unlock_bh(&orig_node->neigh_list_lock);
75
76
77 if (curr_router)
78 batadv_neigh_node_free_ref(curr_router);
79}
80
81void batadv_update_route(struct batadv_priv *bat_priv,
82 struct batadv_orig_node *orig_node,
83 struct batadv_neigh_node *neigh_node)
84{
85 struct batadv_neigh_node *router = NULL;
86
87 if (!orig_node)
88 goto out;
89
90 router = batadv_orig_node_get_router(orig_node);
91
92 if (router != neigh_node)
93 _batadv_update_route(bat_priv, orig_node, neigh_node);
94
95out:
96 if (router)
97 batadv_neigh_node_free_ref(router);
98}
99
100
101void batadv_bonding_candidate_del(struct batadv_orig_node *orig_node,
102 struct batadv_neigh_node *neigh_node)
103{
104
105 if (list_empty(&neigh_node->bonding_list))
106 goto out;
107
108 list_del_rcu(&neigh_node->bonding_list);
109 INIT_LIST_HEAD(&neigh_node->bonding_list);
110 batadv_neigh_node_free_ref(neigh_node);
111 atomic_dec(&orig_node->bond_candidates);
112
113out:
114 return;
115}
116
117void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node,
118 struct batadv_neigh_node *neigh_node)
119{
120 struct batadv_neigh_node *tmp_neigh_node, *router = NULL;
121 uint8_t interference_candidate = 0;
122
123 spin_lock_bh(&orig_node->neigh_list_lock);
124
125
126 if (!batadv_compare_eth(orig_node->orig,
127 neigh_node->orig_node->primary_addr))
128 goto candidate_del;
129
130 router = batadv_orig_node_get_router(orig_node);
131 if (!router)
132 goto candidate_del;
133
134
135 if (neigh_node->tq_avg < router->tq_avg - BATADV_BONDING_TQ_THRESHOLD)
136 goto candidate_del;
137
138
139
140
141
142 hlist_for_each_entry_rcu(tmp_neigh_node,
143 &orig_node->neigh_list, list) {
144 if (tmp_neigh_node == neigh_node)
145 continue;
146
147
148
149
150 if (list_empty(&tmp_neigh_node->bonding_list))
151 continue;
152
153 if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) ||
154 (batadv_compare_eth(neigh_node->addr,
155 tmp_neigh_node->addr))) {
156 interference_candidate = 1;
157 break;
158 }
159 }
160
161
162 if (interference_candidate)
163 goto candidate_del;
164
165
166 if (!list_empty(&neigh_node->bonding_list))
167 goto out;
168
169 if (!atomic_inc_not_zero(&neigh_node->refcount))
170 goto out;
171
172 list_add_rcu(&neigh_node->bonding_list, &orig_node->bond_list);
173 atomic_inc(&orig_node->bond_candidates);
174 goto out;
175
176candidate_del:
177 batadv_bonding_candidate_del(orig_node, neigh_node);
178
179out:
180 spin_unlock_bh(&orig_node->neigh_list_lock);
181
182 if (router)
183 batadv_neigh_node_free_ref(router);
184}
185
186
187void
188batadv_bonding_save_primary(const struct batadv_orig_node *orig_node,
189 struct batadv_orig_node *orig_neigh_node,
190 const struct batadv_ogm_packet *batman_ogm_packet)
191{
192 if (!(batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP))
193 return;
194
195 memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
196}
197
198
199
200
201
202
203int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff,
204 unsigned long *last_reset)
205{
206 if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE ||
207 seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
208 if (!batadv_has_timed_out(*last_reset,
209 BATADV_RESET_PROTECTION_MS))
210 return 1;
211
212 *last_reset = jiffies;
213 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
214 "old packet received, start protection\n");
215 }
216
217 return 0;
218}
219
220bool batadv_check_management_packet(struct sk_buff *skb,
221 struct batadv_hard_iface *hard_iface,
222 int header_len)
223{
224 struct ethhdr *ethhdr;
225
226
227 if (unlikely(!pskb_may_pull(skb, header_len)))
228 return false;
229
230 ethhdr = eth_hdr(skb);
231
232
233 if (!is_broadcast_ether_addr(ethhdr->h_dest))
234 return false;
235
236
237 if (is_broadcast_ether_addr(ethhdr->h_source))
238 return false;
239
240
241 if (skb_cow(skb, 0) < 0)
242 return false;
243
244
245 if (skb_linearize(skb) < 0)
246 return false;
247
248 return true;
249}
250
251static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
252 struct sk_buff *skb, size_t icmp_len)
253{
254 struct batadv_hard_iface *primary_if = NULL;
255 struct batadv_orig_node *orig_node = NULL;
256 struct batadv_icmp_packet_rr *icmp_packet;
257 int ret = NET_RX_DROP;
258
259 icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
260
261
262 if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
263 batadv_socket_receive_packet(icmp_packet, icmp_len);
264 goto out;
265 }
266
267 primary_if = batadv_primary_if_get_selected(bat_priv);
268 if (!primary_if)
269 goto out;
270
271
272
273 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
274 if (!orig_node)
275 goto out;
276
277
278 if (skb_cow(skb, ETH_HLEN) < 0)
279 goto out;
280
281 icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
282
283 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
284 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
285 icmp_packet->msg_type = BATADV_ECHO_REPLY;
286 icmp_packet->header.ttl = BATADV_TTL;
287
288 if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
289 ret = NET_RX_SUCCESS;
290
291out:
292 if (primary_if)
293 batadv_hardif_free_ref(primary_if);
294 if (orig_node)
295 batadv_orig_node_free_ref(orig_node);
296 return ret;
297}
298
299static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
300 struct sk_buff *skb)
301{
302 struct batadv_hard_iface *primary_if = NULL;
303 struct batadv_orig_node *orig_node = NULL;
304 struct batadv_icmp_packet *icmp_packet;
305 int ret = NET_RX_DROP;
306
307 icmp_packet = (struct batadv_icmp_packet *)skb->data;
308
309
310 if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
311 pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
312 icmp_packet->orig, icmp_packet->dst);
313 goto out;
314 }
315
316 primary_if = batadv_primary_if_get_selected(bat_priv);
317 if (!primary_if)
318 goto out;
319
320
321 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
322 if (!orig_node)
323 goto out;
324
325
326 if (skb_cow(skb, ETH_HLEN) < 0)
327 goto out;
328
329 icmp_packet = (struct batadv_icmp_packet *)skb->data;
330
331 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN);
332 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN);
333 icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
334 icmp_packet->header.ttl = BATADV_TTL;
335
336 if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
337 ret = NET_RX_SUCCESS;
338
339out:
340 if (primary_if)
341 batadv_hardif_free_ref(primary_if);
342 if (orig_node)
343 batadv_orig_node_free_ref(orig_node);
344 return ret;
345}
346
347
348int batadv_recv_icmp_packet(struct sk_buff *skb,
349 struct batadv_hard_iface *recv_if)
350{
351 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
352 struct batadv_icmp_packet_rr *icmp_packet;
353 struct ethhdr *ethhdr;
354 struct batadv_orig_node *orig_node = NULL;
355 int hdr_size = sizeof(struct batadv_icmp_packet);
356 int ret = NET_RX_DROP;
357
358
359 if (skb->len >= sizeof(struct batadv_icmp_packet_rr))
360 hdr_size = sizeof(struct batadv_icmp_packet_rr);
361
362
363 if (unlikely(!pskb_may_pull(skb, hdr_size)))
364 goto out;
365
366 ethhdr = eth_hdr(skb);
367
368
369 if (is_broadcast_ether_addr(ethhdr->h_dest))
370 goto out;
371
372
373 if (is_broadcast_ether_addr(ethhdr->h_source))
374 goto out;
375
376
377 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
378 goto out;
379
380 icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
381
382
383 if ((hdr_size == sizeof(struct batadv_icmp_packet_rr)) &&
384 (icmp_packet->rr_cur < BATADV_RR_LEN)) {
385 memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]),
386 ethhdr->h_dest, ETH_ALEN);
387 icmp_packet->rr_cur++;
388 }
389
390
391 if (batadv_is_my_mac(bat_priv, icmp_packet->dst))
392 return batadv_recv_my_icmp_packet(bat_priv, skb, hdr_size);
393
394
395 if (icmp_packet->header.ttl < 2)
396 return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
397
398
399 orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->dst);
400 if (!orig_node)
401 goto out;
402
403
404 if (skb_cow(skb, ETH_HLEN) < 0)
405 goto out;
406
407 icmp_packet = (struct batadv_icmp_packet_rr *)skb->data;
408
409
410 icmp_packet->header.ttl--;
411
412
413 if (batadv_send_skb_to_orig(skb, orig_node, recv_if) != NET_XMIT_DROP)
414 ret = NET_RX_SUCCESS;
415
416out:
417 if (orig_node)
418 batadv_orig_node_free_ref(orig_node);
419 return ret;
420}
421
422
423
424
425
426
427
428static struct batadv_neigh_node *
429batadv_find_bond_router(struct batadv_orig_node *primary_orig,
430 const struct batadv_hard_iface *recv_if)
431{
432 struct batadv_neigh_node *tmp_neigh_node;
433 struct batadv_neigh_node *router = NULL, *first_candidate = NULL;
434
435 rcu_read_lock();
436 list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,
437 bonding_list) {
438 if (!first_candidate)
439 first_candidate = tmp_neigh_node;
440
441
442 if (tmp_neigh_node->if_incoming == recv_if)
443 continue;
444
445 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
446 continue;
447
448 router = tmp_neigh_node;
449 break;
450 }
451
452
453 if (!router && first_candidate &&
454 atomic_inc_not_zero(&first_candidate->refcount))
455 router = first_candidate;
456
457 if (!router)
458 goto out;
459
460
461
462
463 spin_lock_bh(&primary_orig->neigh_list_lock);
464
465
466
467 list_del_rcu(&primary_orig->bond_list);
468 list_add_rcu(&primary_orig->bond_list,
469 &router->bonding_list);
470 spin_unlock_bh(&primary_orig->neigh_list_lock);
471
472out:
473 rcu_read_unlock();
474 return router;
475}
476
477
478
479
480
481
482
483static struct batadv_neigh_node *
484batadv_find_ifalter_router(struct batadv_orig_node *primary_orig,
485 const struct batadv_hard_iface *recv_if)
486{
487 struct batadv_neigh_node *tmp_neigh_node;
488 struct batadv_neigh_node *router = NULL, *first_candidate = NULL;
489
490 rcu_read_lock();
491 list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list,
492 bonding_list) {
493 if (!first_candidate)
494 first_candidate = tmp_neigh_node;
495
496
497 if (tmp_neigh_node->if_incoming == recv_if)
498 continue;
499
500 if (router && tmp_neigh_node->tq_avg <= router->tq_avg)
501 continue;
502
503 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
504 continue;
505
506
507 if (router)
508 batadv_neigh_node_free_ref(router);
509
510
511 router = tmp_neigh_node;
512 }
513
514
515 if (!router && first_candidate &&
516 atomic_inc_not_zero(&first_candidate->refcount))
517 router = first_candidate;
518
519 rcu_read_unlock();
520 return router;
521}
522
523
524
525
526
527
528
529
530
531
532
533
534static int batadv_check_unicast_packet(struct batadv_priv *bat_priv,
535 struct sk_buff *skb, int hdr_size)
536{
537 struct ethhdr *ethhdr;
538
539
540 if (unlikely(!pskb_may_pull(skb, hdr_size)))
541 return -ENODATA;
542
543 ethhdr = eth_hdr(skb);
544
545
546 if (is_broadcast_ether_addr(ethhdr->h_dest))
547 return -EBADR;
548
549
550 if (is_broadcast_ether_addr(ethhdr->h_source))
551 return -EBADR;
552
553
554 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
555 return -EREMOTE;
556
557 return 0;
558}
559
560int batadv_recv_tt_query(struct sk_buff *skb, struct batadv_hard_iface *recv_if)
561{
562 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
563 struct batadv_tt_query_packet *tt_query;
564 uint16_t tt_size;
565 int hdr_size = sizeof(*tt_query);
566 char tt_flag;
567 size_t packet_size;
568
569 if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
570 return NET_RX_DROP;
571
572
573 if (skb_cow(skb, sizeof(struct batadv_tt_query_packet)) < 0)
574 goto out;
575
576 tt_query = (struct batadv_tt_query_packet *)skb->data;
577
578 switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) {
579 case BATADV_TT_REQUEST:
580 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
581
582
583
584
585 if (!batadv_send_tt_response(bat_priv, tt_query)) {
586 if (tt_query->flags & BATADV_TT_FULL_TABLE)
587 tt_flag = 'F';
588 else
589 tt_flag = '.';
590
591 batadv_dbg(BATADV_DBG_TT, bat_priv,
592 "Routing TT_REQUEST to %pM [%c]\n",
593 tt_query->dst,
594 tt_flag);
595 return batadv_route_unicast_packet(skb, recv_if);
596 }
597 break;
598 case BATADV_TT_RESPONSE:
599 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
600
601 if (batadv_is_my_mac(bat_priv, tt_query->dst)) {
602
603
604
605 if (skb_linearize(skb) < 0)
606 goto out;
607
608 tt_query = (struct batadv_tt_query_packet *)skb->data;
609
610 tt_size = batadv_tt_len(ntohs(tt_query->tt_data));
611
612
613 packet_size = sizeof(struct batadv_tt_query_packet);
614 packet_size += tt_size;
615 if (unlikely(skb_headlen(skb) < packet_size))
616 goto out;
617
618 batadv_handle_tt_response(bat_priv, tt_query);
619 } else {
620 if (tt_query->flags & BATADV_TT_FULL_TABLE)
621 tt_flag = 'F';
622 else
623 tt_flag = '.';
624 batadv_dbg(BATADV_DBG_TT, bat_priv,
625 "Routing TT_RESPONSE to %pM [%c]\n",
626 tt_query->dst,
627 tt_flag);
628 return batadv_route_unicast_packet(skb, recv_if);
629 }
630 break;
631 }
632
633out:
634
635 return NET_RX_DROP;
636}
637
638int batadv_recv_roam_adv(struct sk_buff *skb, struct batadv_hard_iface *recv_if)
639{
640 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
641 struct batadv_roam_adv_packet *roam_adv_packet;
642 struct batadv_orig_node *orig_node;
643
644 if (batadv_check_unicast_packet(bat_priv, skb,
645 sizeof(*roam_adv_packet)) < 0)
646 goto out;
647
648 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
649
650 roam_adv_packet = (struct batadv_roam_adv_packet *)skb->data;
651
652 if (!batadv_is_my_mac(bat_priv, roam_adv_packet->dst))
653 return batadv_route_unicast_packet(skb, recv_if);
654
655
656
657
658
659 if (batadv_bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src))
660 goto out;
661
662 orig_node = batadv_orig_hash_find(bat_priv, roam_adv_packet->src);
663 if (!orig_node)
664 goto out;
665
666 batadv_dbg(BATADV_DBG_TT, bat_priv,
667 "Received ROAMING_ADV from %pM (client %pM)\n",
668 roam_adv_packet->src, roam_adv_packet->client);
669
670 batadv_tt_global_add(bat_priv, orig_node, roam_adv_packet->client,
671 BATADV_TT_CLIENT_ROAM,
672 atomic_read(&orig_node->last_ttvn) + 1);
673
674 batadv_orig_node_free_ref(orig_node);
675out:
676
677 return NET_RX_DROP;
678}
679
680
681
682
683
684struct batadv_neigh_node *
685batadv_find_router(struct batadv_priv *bat_priv,
686 struct batadv_orig_node *orig_node,
687 const struct batadv_hard_iface *recv_if)
688{
689 struct batadv_orig_node *primary_orig_node;
690 struct batadv_orig_node *router_orig;
691 struct batadv_neigh_node *router;
692 static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0};
693 int bonding_enabled;
694 uint8_t *primary_addr;
695
696 if (!orig_node)
697 return NULL;
698
699 router = batadv_orig_node_get_router(orig_node);
700 if (!router)
701 goto err;
702
703
704
705
706 bonding_enabled = atomic_read(&bat_priv->bonding);
707
708 rcu_read_lock();
709
710 router_orig = router->orig_node;
711 if (!router_orig)
712 goto err_unlock;
713
714 if ((!recv_if) && (!bonding_enabled))
715 goto return_router;
716
717 primary_addr = router_orig->primary_addr;
718
719
720
721
722 if (batadv_compare_eth(primary_addr, zero_mac))
723 goto return_router;
724
725
726
727
728 if (batadv_compare_eth(primary_addr, router_orig->orig)) {
729 primary_orig_node = router_orig;
730 } else {
731 primary_orig_node = batadv_orig_hash_find(bat_priv,
732 primary_addr);
733 if (!primary_orig_node)
734 goto return_router;
735
736 batadv_orig_node_free_ref(primary_orig_node);
737 }
738
739
740
741
742 if (atomic_read(&primary_orig_node->bond_candidates) < 2)
743 goto return_router;
744
745
746
747
748
749 batadv_neigh_node_free_ref(router);
750
751 if (bonding_enabled)
752 router = batadv_find_bond_router(primary_orig_node, recv_if);
753 else
754 router = batadv_find_ifalter_router(primary_orig_node, recv_if);
755
756return_router:
757 if (router && router->if_incoming->if_status != BATADV_IF_ACTIVE)
758 goto err_unlock;
759
760 rcu_read_unlock();
761 return router;
762err_unlock:
763 rcu_read_unlock();
764err:
765 if (router)
766 batadv_neigh_node_free_ref(router);
767 return NULL;
768}
769
770static int batadv_route_unicast_packet(struct sk_buff *skb,
771 struct batadv_hard_iface *recv_if)
772{
773 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
774 struct batadv_orig_node *orig_node = NULL;
775 struct batadv_neigh_node *neigh_node = NULL;
776 struct batadv_unicast_packet *unicast_packet;
777 struct ethhdr *ethhdr = eth_hdr(skb);
778 int res, ret = NET_RX_DROP;
779 struct sk_buff *new_skb;
780
781 unicast_packet = (struct batadv_unicast_packet *)skb->data;
782
783
784 if (unicast_packet->header.ttl < 2) {
785 pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
786 ethhdr->h_source, unicast_packet->dest);
787 goto out;
788 }
789
790
791 orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
792
793 if (!orig_node)
794 goto out;
795
796
797 neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
798
799 if (!neigh_node)
800 goto out;
801
802
803 if (skb_cow(skb, ETH_HLEN) < 0)
804 goto out;
805
806 unicast_packet = (struct batadv_unicast_packet *)skb->data;
807
808 if (unicast_packet->header.packet_type == BATADV_UNICAST &&
809 atomic_read(&bat_priv->fragmentation) &&
810 skb->len > neigh_node->if_incoming->net_dev->mtu) {
811 ret = batadv_frag_send_skb(skb, bat_priv,
812 neigh_node->if_incoming,
813 neigh_node->addr);
814 goto out;
815 }
816
817 if (unicast_packet->header.packet_type == BATADV_UNICAST_FRAG &&
818 batadv_frag_can_reassemble(skb,
819 neigh_node->if_incoming->net_dev->mtu)) {
820 ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
821
822 if (ret == NET_RX_DROP)
823 goto out;
824
825
826 if (!new_skb) {
827 ret = NET_RX_SUCCESS;
828 goto out;
829 }
830
831 skb = new_skb;
832 unicast_packet = (struct batadv_unicast_packet *)skb->data;
833 }
834
835
836 unicast_packet->header.ttl--;
837
838 res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
839
840
841 if (res == NET_XMIT_SUCCESS) {
842
843 batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
844 batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
845 skb->len + ETH_HLEN);
846
847 ret = NET_RX_SUCCESS;
848 } else if (res == NET_XMIT_POLICED) {
849
850 ret = NET_RX_SUCCESS;
851 }
852
853out:
854 if (neigh_node)
855 batadv_neigh_node_free_ref(neigh_node);
856 if (orig_node)
857 batadv_orig_node_free_ref(orig_node);
858 return ret;
859}
860
861
862
863
864
865
866
867
868
869
870
871
872
873static bool
874batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
875 struct batadv_unicast_packet *unicast_packet,
876 uint8_t *dst_addr)
877{
878 struct batadv_orig_node *orig_node = NULL;
879 struct batadv_hard_iface *primary_if = NULL;
880 bool ret = false;
881 uint8_t *orig_addr, orig_ttvn;
882
883 if (batadv_is_my_client(bat_priv, dst_addr)) {
884 primary_if = batadv_primary_if_get_selected(bat_priv);
885 if (!primary_if)
886 goto out;
887 orig_addr = primary_if->net_dev->dev_addr;
888 orig_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
889 } else {
890 orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr);
891 if (!orig_node)
892 goto out;
893
894 if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
895 goto out;
896
897 orig_addr = orig_node->orig;
898 orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
899 }
900
901
902 memcpy(unicast_packet->dest, orig_addr, ETH_ALEN);
903 unicast_packet->ttvn = orig_ttvn;
904
905 ret = true;
906out:
907 if (primary_if)
908 batadv_hardif_free_ref(primary_if);
909 if (orig_node)
910 batadv_orig_node_free_ref(orig_node);
911
912 return ret;
913}
914
915static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
916 struct sk_buff *skb, int hdr_len) {
917 uint8_t curr_ttvn, old_ttvn;
918 struct batadv_orig_node *orig_node;
919 struct ethhdr *ethhdr;
920 struct batadv_hard_iface *primary_if;
921 struct batadv_unicast_packet *unicast_packet;
922 int is_old_ttvn;
923
924
925 if (pskb_may_pull(skb, hdr_len + ETH_HLEN) < 0)
926 return 0;
927
928
929 if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
930 return 0;
931
932 unicast_packet = (struct batadv_unicast_packet *)skb->data;
933 ethhdr = (struct ethhdr *)(skb->data + hdr_len);
934
935
936
937
938
939
940 if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest)) {
941 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
942 ethhdr->h_dest))
943 net_ratelimited_function(batadv_dbg, BATADV_DBG_TT,
944 bat_priv,
945 "Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
946 unicast_packet->dest,
947 ethhdr->h_dest);
948
949
950
951
952
953 return 1;
954 }
955
956
957
958
959
960 curr_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
961 if (!batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
962 orig_node = batadv_orig_hash_find(bat_priv,
963 unicast_packet->dest);
964
965
966
967
968 if (!orig_node)
969 return 0;
970
971 curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
972 batadv_orig_node_free_ref(orig_node);
973 }
974
975
976
977
978 is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
979 if (!is_old_ttvn)
980 return 1;
981
982 old_ttvn = unicast_packet->ttvn;
983
984
985
986
987 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
988 ethhdr->h_dest)) {
989 net_ratelimited_function(batadv_dbg, BATADV_DBG_TT, bat_priv,
990 "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
991 unicast_packet->dest, ethhdr->h_dest,
992 old_ttvn, curr_ttvn);
993 return 1;
994 }
995
996
997
998
999
1000 if (!batadv_is_my_client(bat_priv, ethhdr->h_dest))
1001 return 0;
1002
1003
1004
1005
1006 primary_if = batadv_primary_if_get_selected(bat_priv);
1007 if (!primary_if)
1008 return 0;
1009
1010 memcpy(unicast_packet->dest, primary_if->net_dev->dev_addr, ETH_ALEN);
1011
1012 batadv_hardif_free_ref(primary_if);
1013
1014 unicast_packet->ttvn = curr_ttvn;
1015
1016 return 1;
1017}
1018
1019int batadv_recv_unicast_packet(struct sk_buff *skb,
1020 struct batadv_hard_iface *recv_if)
1021{
1022 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1023 struct batadv_unicast_packet *unicast_packet;
1024 struct batadv_unicast_4addr_packet *unicast_4addr_packet;
1025 uint8_t *orig_addr;
1026 struct batadv_orig_node *orig_node = NULL;
1027 int check, hdr_size = sizeof(*unicast_packet);
1028 bool is4addr;
1029
1030 unicast_packet = (struct batadv_unicast_packet *)skb->data;
1031 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
1032
1033 is4addr = unicast_packet->header.packet_type == BATADV_UNICAST_4ADDR;
1034
1035 if (is4addr)
1036 hdr_size = sizeof(*unicast_4addr_packet);
1037
1038
1039 check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
1040
1041
1042
1043
1044 if (check == -EREMOTE)
1045 batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);
1046
1047 if (check < 0)
1048 return NET_RX_DROP;
1049 if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
1050 return NET_RX_DROP;
1051
1052
1053 if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
1054 if (is4addr) {
1055 batadv_dat_inc_counter(bat_priv,
1056 unicast_4addr_packet->subtype);
1057 orig_addr = unicast_4addr_packet->src;
1058 orig_node = batadv_orig_hash_find(bat_priv, orig_addr);
1059 }
1060
1061 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
1062 hdr_size))
1063 goto rx_success;
1064 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
1065 hdr_size))
1066 goto rx_success;
1067
1068 batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1069 orig_node);
1070
1071rx_success:
1072 if (orig_node)
1073 batadv_orig_node_free_ref(orig_node);
1074
1075 return NET_RX_SUCCESS;
1076 }
1077
1078 return batadv_route_unicast_packet(skb, recv_if);
1079}
1080
1081int batadv_recv_ucast_frag_packet(struct sk_buff *skb,
1082 struct batadv_hard_iface *recv_if)
1083{
1084 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1085 struct batadv_unicast_frag_packet *unicast_packet;
1086 int hdr_size = sizeof(*unicast_packet);
1087 struct sk_buff *new_skb = NULL;
1088 int ret;
1089
1090 if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
1091 return NET_RX_DROP;
1092
1093 if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
1094 return NET_RX_DROP;
1095
1096 unicast_packet = (struct batadv_unicast_frag_packet *)skb->data;
1097
1098
1099 if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
1100 ret = batadv_frag_reassemble_skb(skb, bat_priv, &new_skb);
1101
1102 if (ret == NET_RX_DROP)
1103 return NET_RX_DROP;
1104
1105
1106 if (!new_skb)
1107 return NET_RX_SUCCESS;
1108
1109 if (batadv_dat_snoop_incoming_arp_request(bat_priv, new_skb,
1110 hdr_size))
1111 goto rx_success;
1112 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, new_skb,
1113 hdr_size))
1114 goto rx_success;
1115
1116 batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if,
1117 sizeof(struct batadv_unicast_packet), NULL);
1118
1119rx_success:
1120 return NET_RX_SUCCESS;
1121 }
1122
1123 return batadv_route_unicast_packet(skb, recv_if);
1124}
1125
1126
1127int batadv_recv_bcast_packet(struct sk_buff *skb,
1128 struct batadv_hard_iface *recv_if)
1129{
1130 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1131 struct batadv_orig_node *orig_node = NULL;
1132 struct batadv_bcast_packet *bcast_packet;
1133 struct ethhdr *ethhdr;
1134 int hdr_size = sizeof(*bcast_packet);
1135 int ret = NET_RX_DROP;
1136 int32_t seq_diff;
1137
1138
1139 if (unlikely(!pskb_may_pull(skb, hdr_size)))
1140 goto out;
1141
1142 ethhdr = eth_hdr(skb);
1143
1144
1145 if (!is_broadcast_ether_addr(ethhdr->h_dest))
1146 goto out;
1147
1148
1149 if (is_broadcast_ether_addr(ethhdr->h_source))
1150 goto out;
1151
1152
1153 if (batadv_is_my_mac(bat_priv, ethhdr->h_source))
1154 goto out;
1155
1156 bcast_packet = (struct batadv_bcast_packet *)skb->data;
1157
1158
1159 if (batadv_is_my_mac(bat_priv, bcast_packet->orig))
1160 goto out;
1161
1162 if (bcast_packet->header.ttl < 2)
1163 goto out;
1164
1165 orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1166
1167 if (!orig_node)
1168 goto out;
1169
1170 spin_lock_bh(&orig_node->bcast_seqno_lock);
1171
1172
1173 if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1174 ntohl(bcast_packet->seqno)))
1175 goto spin_unlock;
1176
1177 seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno;
1178
1179
1180 if (batadv_window_protected(bat_priv, seq_diff,
1181 &orig_node->bcast_seqno_reset))
1182 goto spin_unlock;
1183
1184
1185
1186
1187 if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1188 orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno);
1189
1190 spin_unlock_bh(&orig_node->bcast_seqno_lock);
1191
1192
1193 if (batadv_bla_check_bcast_duplist(bat_priv, skb))
1194 goto out;
1195
1196
1197 batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1198
1199
1200
1201
1202 if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1203 goto out;
1204
1205 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
1206 goto rx_success;
1207 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
1208 goto rx_success;
1209
1210
1211 batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1212 orig_node);
1213
1214rx_success:
1215 ret = NET_RX_SUCCESS;
1216 goto out;
1217
1218spin_unlock:
1219 spin_unlock_bh(&orig_node->bcast_seqno_lock);
1220out:
1221 if (orig_node)
1222 batadv_orig_node_free_ref(orig_node);
1223 return ret;
1224}
1225
1226int batadv_recv_vis_packet(struct sk_buff *skb,
1227 struct batadv_hard_iface *recv_if)
1228{
1229 struct batadv_vis_packet *vis_packet;
1230 struct ethhdr *ethhdr;
1231 struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1232 int hdr_size = sizeof(*vis_packet);
1233
1234
1235 if (skb_linearize(skb) < 0)
1236 return NET_RX_DROP;
1237
1238 if (unlikely(!pskb_may_pull(skb, hdr_size)))
1239 return NET_RX_DROP;
1240
1241 vis_packet = (struct batadv_vis_packet *)skb->data;
1242 ethhdr = eth_hdr(skb);
1243
1244
1245 if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
1246 return NET_RX_DROP;
1247
1248
1249 if (batadv_is_my_mac(bat_priv, vis_packet->vis_orig))
1250 return NET_RX_DROP;
1251
1252 if (batadv_is_my_mac(bat_priv, vis_packet->sender_orig))
1253 return NET_RX_DROP;
1254
1255 switch (vis_packet->vis_type) {
1256 case BATADV_VIS_TYPE_SERVER_SYNC:
1257 batadv_receive_server_sync_packet(bat_priv, vis_packet,
1258 skb_headlen(skb));
1259 break;
1260
1261 case BATADV_VIS_TYPE_CLIENT_UPDATE:
1262 batadv_receive_client_update_packet(bat_priv, vis_packet,
1263 skb_headlen(skb));
1264 break;
1265
1266 default:
1267 break;
1268 }
1269
1270
1271
1272
1273 return NET_RX_DROP;
1274}
1275