1
2
3
4
5
6
7#include "send.h"
8#include "main.h"
9
10#include <linux/atomic.h>
11#include <linux/bug.h>
12#include <linux/byteorder/generic.h>
13#include <linux/errno.h>
14#include <linux/etherdevice.h>
15#include <linux/gfp.h>
16#include <linux/if.h>
17#include <linux/if_ether.h>
18#include <linux/jiffies.h>
19#include <linux/kernel.h>
20#include <linux/kref.h>
21#include <linux/list.h>
22#include <linux/netdevice.h>
23#include <linux/printk.h>
24#include <linux/rculist.h>
25#include <linux/rcupdate.h>
26#include <linux/skbuff.h>
27#include <linux/slab.h>
28#include <linux/spinlock.h>
29#include <linux/stddef.h>
30#include <linux/workqueue.h>
31
32#include "distributed-arp-table.h"
33#include "fragmentation.h"
34#include "gateway_client.h"
35#include "hard-interface.h"
36#include "log.h"
37#include "network-coding.h"
38#include "originator.h"
39#include "routing.h"
40#include "soft-interface.h"
41#include "translation-table.h"
42
43static void batadv_send_outstanding_bcast_packet(struct work_struct *work);
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63int batadv_send_skb_packet(struct sk_buff *skb,
64 struct batadv_hard_iface *hard_iface,
65 const u8 *dst_addr)
66{
67 struct batadv_priv *bat_priv;
68 struct ethhdr *ethhdr;
69 int ret;
70
71 bat_priv = netdev_priv(hard_iface->soft_iface);
72
73 if (hard_iface->if_status != BATADV_IF_ACTIVE)
74 goto send_skb_err;
75
76 if (unlikely(!hard_iface->net_dev))
77 goto send_skb_err;
78
79 if (!(hard_iface->net_dev->flags & IFF_UP)) {
80 pr_warn("Interface %s is not up - can't send packet via that interface!\n",
81 hard_iface->net_dev->name);
82 goto send_skb_err;
83 }
84
85
86 if (batadv_skb_head_push(skb, ETH_HLEN) < 0)
87 goto send_skb_err;
88
89 skb_reset_mac_header(skb);
90
91 ethhdr = eth_hdr(skb);
92 ether_addr_copy(ethhdr->h_source, hard_iface->net_dev->dev_addr);
93 ether_addr_copy(ethhdr->h_dest, dst_addr);
94 ethhdr->h_proto = htons(ETH_P_BATMAN);
95
96 skb_set_network_header(skb, ETH_HLEN);
97 skb->protocol = htons(ETH_P_BATMAN);
98
99 skb->dev = hard_iface->net_dev;
100
101
102 batadv_nc_skb_store_for_decoding(bat_priv, skb);
103
104
105
106
107
108 ret = dev_queue_xmit(skb);
109 return net_xmit_eval(ret);
110send_skb_err:
111 kfree_skb(skb);
112 return NET_XMIT_DROP;
113}
114
115
116
117
118
119
120
121
122
123
124int batadv_send_broadcast_skb(struct sk_buff *skb,
125 struct batadv_hard_iface *hard_iface)
126{
127 return batadv_send_skb_packet(skb, hard_iface, batadv_broadcast_addr);
128}
129
130
131
132
133
134
135
136
137
138
139int batadv_send_unicast_skb(struct sk_buff *skb,
140 struct batadv_neigh_node *neigh)
141{
142#ifdef CONFIG_BATMAN_ADV_BATMAN_V
143 struct batadv_hardif_neigh_node *hardif_neigh;
144#endif
145 int ret;
146
147 ret = batadv_send_skb_packet(skb, neigh->if_incoming, neigh->addr);
148
149#ifdef CONFIG_BATMAN_ADV_BATMAN_V
150 hardif_neigh = batadv_hardif_neigh_get(neigh->if_incoming, neigh->addr);
151
152 if (hardif_neigh && ret != NET_XMIT_DROP)
153 hardif_neigh->bat_v.last_unicast_tx = jiffies;
154
155 batadv_hardif_neigh_put(hardif_neigh);
156#endif
157
158 return ret;
159}
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176int batadv_send_skb_to_orig(struct sk_buff *skb,
177 struct batadv_orig_node *orig_node,
178 struct batadv_hard_iface *recv_if)
179{
180 struct batadv_priv *bat_priv = orig_node->bat_priv;
181 struct batadv_neigh_node *neigh_node;
182 int ret;
183
184
185 neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
186 if (!neigh_node) {
187 ret = -EINVAL;
188 goto free_skb;
189 }
190
191
192
193
194 if (atomic_read(&bat_priv->fragmentation) &&
195 skb->len > neigh_node->if_incoming->net_dev->mtu) {
196
197 ret = batadv_frag_send_packet(skb, orig_node, neigh_node);
198
199 skb = NULL;
200
201 goto put_neigh_node;
202 }
203
204
205
206
207
208 if (recv_if && batadv_nc_skb_forward(skb, neigh_node))
209 ret = -EINPROGRESS;
210 else
211 ret = batadv_send_unicast_skb(skb, neigh_node);
212
213
214 skb = NULL;
215
216put_neigh_node:
217 batadv_neigh_node_put(neigh_node);
218free_skb:
219 kfree_skb(skb);
220
221 return ret;
222}
223
224
225
226
227
228
229
230
231
232
233static bool
234batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size,
235 struct batadv_orig_node *orig_node)
236{
237 struct batadv_unicast_packet *unicast_packet;
238 u8 ttvn = (u8)atomic_read(&orig_node->last_ttvn);
239
240 if (batadv_skb_head_push(skb, hdr_size) < 0)
241 return false;
242
243 unicast_packet = (struct batadv_unicast_packet *)skb->data;
244 unicast_packet->version = BATADV_COMPAT_VERSION;
245
246 unicast_packet->packet_type = BATADV_UNICAST;
247
248 unicast_packet->ttl = BATADV_TTL;
249
250 ether_addr_copy(unicast_packet->dest, orig_node->orig);
251
252 unicast_packet->ttvn = ttvn;
253
254 return true;
255}
256
257
258
259
260
261
262
263
264static bool batadv_send_skb_prepare_unicast(struct sk_buff *skb,
265 struct batadv_orig_node *orig_node)
266{
267 size_t uni_size = sizeof(struct batadv_unicast_packet);
268
269 return batadv_send_skb_push_fill_unicast(skb, uni_size, orig_node);
270}
271
272
273
274
275
276
277
278
279
280
281
282bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv,
283 struct sk_buff *skb,
284 struct batadv_orig_node *orig,
285 int packet_subtype)
286{
287 struct batadv_hard_iface *primary_if;
288 struct batadv_unicast_4addr_packet *uc_4addr_packet;
289 bool ret = false;
290
291 primary_if = batadv_primary_if_get_selected(bat_priv);
292 if (!primary_if)
293 goto out;
294
295
296
297
298
299 if (!batadv_send_skb_push_fill_unicast(skb, sizeof(*uc_4addr_packet),
300 orig))
301 goto out;
302
303 uc_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
304 uc_4addr_packet->u.packet_type = BATADV_UNICAST_4ADDR;
305 ether_addr_copy(uc_4addr_packet->src, primary_if->net_dev->dev_addr);
306 uc_4addr_packet->subtype = packet_subtype;
307 uc_4addr_packet->reserved = 0;
308
309 ret = true;
310out:
311 batadv_hardif_put(primary_if);
312 return ret;
313}
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331int batadv_send_skb_unicast(struct batadv_priv *bat_priv,
332 struct sk_buff *skb, int packet_type,
333 int packet_subtype,
334 struct batadv_orig_node *orig_node,
335 unsigned short vid)
336{
337 struct batadv_unicast_packet *unicast_packet;
338 struct ethhdr *ethhdr;
339 int ret = NET_XMIT_DROP;
340
341 if (!orig_node)
342 goto out;
343
344 switch (packet_type) {
345 case BATADV_UNICAST:
346 if (!batadv_send_skb_prepare_unicast(skb, orig_node))
347 goto out;
348 break;
349 case BATADV_UNICAST_4ADDR:
350 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, skb,
351 orig_node,
352 packet_subtype))
353 goto out;
354 break;
355 default:
356
357
358
359 goto out;
360 }
361
362
363
364
365 ethhdr = eth_hdr(skb);
366 unicast_packet = (struct batadv_unicast_packet *)skb->data;
367
368
369
370
371
372
373 if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest, vid))
374 unicast_packet->ttvn = unicast_packet->ttvn - 1;
375
376 ret = batadv_send_skb_to_orig(skb, orig_node, NULL);
377
378 skb = NULL;
379
380out:
381 kfree_skb(skb);
382 return ret;
383}
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403int batadv_send_skb_via_tt_generic(struct batadv_priv *bat_priv,
404 struct sk_buff *skb, int packet_type,
405 int packet_subtype, u8 *dst_hint,
406 unsigned short vid)
407{
408 struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
409 struct batadv_orig_node *orig_node;
410 u8 *src, *dst;
411 int ret;
412
413 src = ethhdr->h_source;
414 dst = ethhdr->h_dest;
415
416
417 if (dst_hint) {
418 src = NULL;
419 dst = dst_hint;
420 }
421 orig_node = batadv_transtable_search(bat_priv, src, dst, vid);
422
423 ret = batadv_send_skb_unicast(bat_priv, skb, packet_type,
424 packet_subtype, orig_node, vid);
425
426 batadv_orig_node_put(orig_node);
427
428 return ret;
429}
430
431
432
433
434
435
436
437
438
439
440
441
442int batadv_send_skb_via_gw(struct batadv_priv *bat_priv, struct sk_buff *skb,
443 unsigned short vid)
444{
445 struct batadv_orig_node *orig_node;
446 int ret;
447
448 orig_node = batadv_gw_get_selected_orig(bat_priv);
449 ret = batadv_send_skb_unicast(bat_priv, skb, BATADV_UNICAST_4ADDR,
450 BATADV_P_DATA, orig_node, vid);
451
452 batadv_orig_node_put(orig_node);
453
454 return ret;
455}
456
457
458
459
460
461
462
463
464
465void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet,
466 bool dropped)
467{
468 if (dropped)
469 kfree_skb(forw_packet->skb);
470 else
471 consume_skb(forw_packet->skb);
472
473 batadv_hardif_put(forw_packet->if_incoming);
474 batadv_hardif_put(forw_packet->if_outgoing);
475 if (forw_packet->queue_left)
476 atomic_inc(forw_packet->queue_left);
477 kfree(forw_packet);
478}
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494struct batadv_forw_packet *
495batadv_forw_packet_alloc(struct batadv_hard_iface *if_incoming,
496 struct batadv_hard_iface *if_outgoing,
497 atomic_t *queue_left,
498 struct batadv_priv *bat_priv,
499 struct sk_buff *skb)
500{
501 struct batadv_forw_packet *forw_packet;
502 const char *qname;
503
504 if (queue_left && !batadv_atomic_dec_not_zero(queue_left)) {
505 qname = "unknown";
506
507 if (queue_left == &bat_priv->bcast_queue_left)
508 qname = "bcast";
509
510 if (queue_left == &bat_priv->batman_queue_left)
511 qname = "batman";
512
513 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
514 "%s queue is full\n", qname);
515
516 return NULL;
517 }
518
519 forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC);
520 if (!forw_packet)
521 goto err;
522
523 if (if_incoming)
524 kref_get(&if_incoming->refcount);
525
526 if (if_outgoing)
527 kref_get(&if_outgoing->refcount);
528
529 INIT_HLIST_NODE(&forw_packet->list);
530 INIT_HLIST_NODE(&forw_packet->cleanup_list);
531 forw_packet->skb = skb;
532 forw_packet->queue_left = queue_left;
533 forw_packet->if_incoming = if_incoming;
534 forw_packet->if_outgoing = if_outgoing;
535 forw_packet->num_packets = 0;
536
537 return forw_packet;
538
539err:
540 if (queue_left)
541 atomic_inc(queue_left);
542
543 return NULL;
544}
545
546
547
548
549
550
551
552
553
554
555static bool
556batadv_forw_packet_was_stolen(struct batadv_forw_packet *forw_packet)
557{
558 return !hlist_unhashed(&forw_packet->cleanup_list);
559}
560
561
562
563
564
565
566
567
568
569
570
571
572
573bool batadv_forw_packet_steal(struct batadv_forw_packet *forw_packet,
574 spinlock_t *lock)
575{
576
577 spin_lock_bh(lock);
578 if (batadv_forw_packet_was_stolen(forw_packet)) {
579 spin_unlock_bh(lock);
580 return false;
581 }
582
583 hlist_del_init(&forw_packet->list);
584
585
586 hlist_add_fake(&forw_packet->cleanup_list);
587
588 spin_unlock_bh(lock);
589 return true;
590}
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605static void
606batadv_forw_packet_list_steal(struct hlist_head *forw_list,
607 struct hlist_head *cleanup_list,
608 const struct batadv_hard_iface *hard_iface)
609{
610 struct batadv_forw_packet *forw_packet;
611 struct hlist_node *safe_tmp_node;
612
613 hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
614 forw_list, list) {
615
616
617
618 if (hard_iface &&
619 forw_packet->if_incoming != hard_iface &&
620 forw_packet->if_outgoing != hard_iface)
621 continue;
622
623 hlist_del(&forw_packet->list);
624 hlist_add_head(&forw_packet->cleanup_list, cleanup_list);
625 }
626}
627
628
629
630
631
632
633
634
635
636
637
638static void batadv_forw_packet_list_free(struct hlist_head *head)
639{
640 struct batadv_forw_packet *forw_packet;
641 struct hlist_node *safe_tmp_node;
642
643 hlist_for_each_entry_safe(forw_packet, safe_tmp_node, head,
644 cleanup_list) {
645 cancel_delayed_work_sync(&forw_packet->delayed_work);
646
647 hlist_del(&forw_packet->cleanup_list);
648 batadv_forw_packet_free(forw_packet, true);
649 }
650}
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669static void batadv_forw_packet_queue(struct batadv_forw_packet *forw_packet,
670 spinlock_t *lock, struct hlist_head *head,
671 unsigned long send_time)
672{
673 spin_lock_bh(lock);
674
675
676 if (batadv_forw_packet_was_stolen(forw_packet)) {
677
678
679
680 WARN_ONCE(hlist_fake(&forw_packet->cleanup_list),
681 "Requeuing after batadv_forw_packet_steal() not allowed!\n");
682
683 spin_unlock_bh(lock);
684 return;
685 }
686
687 hlist_del_init(&forw_packet->list);
688 hlist_add_head(&forw_packet->list, head);
689
690 queue_delayed_work(batadv_event_workqueue,
691 &forw_packet->delayed_work,
692 send_time - jiffies);
693 spin_unlock_bh(lock);
694}
695
696
697
698
699
700
701
702
703
704
705
706static void
707batadv_forw_packet_bcast_queue(struct batadv_priv *bat_priv,
708 struct batadv_forw_packet *forw_packet,
709 unsigned long send_time)
710{
711 batadv_forw_packet_queue(forw_packet, &bat_priv->forw_bcast_list_lock,
712 &bat_priv->forw_bcast_list, send_time);
713}
714
715
716
717
718
719
720
721
722
723
724
725void batadv_forw_packet_ogmv1_queue(struct batadv_priv *bat_priv,
726 struct batadv_forw_packet *forw_packet,
727 unsigned long send_time)
728{
729 batadv_forw_packet_queue(forw_packet, &bat_priv->forw_bat_list_lock,
730 &bat_priv->forw_bat_list, send_time);
731}
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751static int batadv_forw_bcast_packet_to_list(struct batadv_priv *bat_priv,
752 struct sk_buff *skb,
753 unsigned long delay,
754 bool own_packet,
755 struct batadv_hard_iface *if_in,
756 struct batadv_hard_iface *if_out)
757{
758 struct batadv_forw_packet *forw_packet;
759 unsigned long send_time = jiffies;
760 struct sk_buff *newskb;
761
762 newskb = skb_clone(skb, GFP_ATOMIC);
763 if (!newskb)
764 goto err;
765
766 forw_packet = batadv_forw_packet_alloc(if_in, if_out,
767 &bat_priv->bcast_queue_left,
768 bat_priv, newskb);
769 if (!forw_packet)
770 goto err_packet_free;
771
772 forw_packet->own = own_packet;
773
774 INIT_DELAYED_WORK(&forw_packet->delayed_work,
775 batadv_send_outstanding_bcast_packet);
776
777 send_time += delay ? delay : msecs_to_jiffies(5);
778
779 batadv_forw_packet_bcast_queue(bat_priv, forw_packet, send_time);
780 return NETDEV_TX_OK;
781
782err_packet_free:
783 kfree_skb(newskb);
784err:
785 return NETDEV_TX_BUSY;
786}
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807static int batadv_forw_bcast_packet_if(struct batadv_priv *bat_priv,
808 struct sk_buff *skb,
809 unsigned long delay,
810 bool own_packet,
811 struct batadv_hard_iface *if_in,
812 struct batadv_hard_iface *if_out)
813{
814 unsigned int num_bcasts = if_out->num_bcasts;
815 struct sk_buff *newskb;
816 int ret = NETDEV_TX_OK;
817
818 if (!delay) {
819 newskb = skb_clone(skb, GFP_ATOMIC);
820 if (!newskb)
821 return NETDEV_TX_BUSY;
822
823 batadv_send_broadcast_skb(newskb, if_out);
824 num_bcasts--;
825 }
826
827
828 if (num_bcasts >= 1) {
829 BATADV_SKB_CB(skb)->num_bcasts = num_bcasts;
830
831 ret = batadv_forw_bcast_packet_to_list(bat_priv, skb, delay,
832 own_packet, if_in,
833 if_out);
834 }
835
836 return ret;
837}
838
839
840
841
842
843
844
845
846
847
848
849static bool batadv_send_no_broadcast(struct batadv_priv *bat_priv,
850 struct sk_buff *skb, bool own_packet,
851 struct batadv_hard_iface *if_out)
852{
853 struct batadv_hardif_neigh_node *neigh_node = NULL;
854 struct batadv_bcast_packet *bcast_packet;
855 u8 *orig_neigh;
856 u8 *neigh_addr;
857 char *type;
858 int ret;
859
860 if (!own_packet) {
861 neigh_addr = eth_hdr(skb)->h_source;
862 neigh_node = batadv_hardif_neigh_get(if_out,
863 neigh_addr);
864 }
865
866 bcast_packet = (struct batadv_bcast_packet *)skb->data;
867 orig_neigh = neigh_node ? neigh_node->orig : NULL;
868
869 ret = batadv_hardif_no_broadcast(if_out, bcast_packet->orig,
870 orig_neigh);
871
872 batadv_hardif_neigh_put(neigh_node);
873
874
875 if (!ret)
876 return false;
877
878
879 switch (ret) {
880 case BATADV_HARDIF_BCAST_NORECIPIENT:
881 type = "no neighbor";
882 break;
883 case BATADV_HARDIF_BCAST_DUPFWD:
884 type = "single neighbor is source";
885 break;
886 case BATADV_HARDIF_BCAST_DUPORIG:
887 type = "single neighbor is originator";
888 break;
889 default:
890 type = "unknown";
891 }
892
893 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
894 "BCAST packet from orig %pM on %s suppressed: %s\n",
895 bcast_packet->orig,
896 if_out->net_dev->name, type);
897
898 return true;
899}
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918static int __batadv_forw_bcast_packet(struct batadv_priv *bat_priv,
919 struct sk_buff *skb,
920 unsigned long delay,
921 bool own_packet)
922{
923 struct batadv_hard_iface *hard_iface;
924 struct batadv_hard_iface *primary_if;
925 int ret = NETDEV_TX_OK;
926
927 primary_if = batadv_primary_if_get_selected(bat_priv);
928 if (!primary_if)
929 return NETDEV_TX_BUSY;
930
931 rcu_read_lock();
932 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
933 if (hard_iface->soft_iface != bat_priv->soft_iface)
934 continue;
935
936 if (!kref_get_unless_zero(&hard_iface->refcount))
937 continue;
938
939 if (batadv_send_no_broadcast(bat_priv, skb, own_packet,
940 hard_iface)) {
941 batadv_hardif_put(hard_iface);
942 continue;
943 }
944
945 ret = batadv_forw_bcast_packet_if(bat_priv, skb, delay,
946 own_packet, primary_if,
947 hard_iface);
948 batadv_hardif_put(hard_iface);
949
950 if (ret == NETDEV_TX_BUSY)
951 break;
952 }
953 rcu_read_unlock();
954
955 batadv_hardif_put(primary_if);
956 return ret;
957}
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972int batadv_forw_bcast_packet(struct batadv_priv *bat_priv,
973 struct sk_buff *skb,
974 unsigned long delay,
975 bool own_packet)
976{
977 return __batadv_forw_bcast_packet(bat_priv, skb, delay, own_packet);
978}
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993void batadv_send_bcast_packet(struct batadv_priv *bat_priv,
994 struct sk_buff *skb,
995 unsigned long delay,
996 bool own_packet)
997{
998 __batadv_forw_bcast_packet(bat_priv, skb, delay, own_packet);
999 consume_skb(skb);
1000}
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015static bool
1016batadv_forw_packet_bcasts_left(struct batadv_forw_packet *forw_packet)
1017{
1018 return BATADV_SKB_CB(forw_packet->skb)->num_bcasts;
1019}
1020
1021
1022
1023
1024
1025
1026static void
1027batadv_forw_packet_bcasts_dec(struct batadv_forw_packet *forw_packet)
1028{
1029 BATADV_SKB_CB(forw_packet->skb)->num_bcasts--;
1030}
1031
1032
1033
1034
1035
1036
1037
1038bool batadv_forw_packet_is_rebroadcast(struct batadv_forw_packet *forw_packet)
1039{
1040 unsigned char num_bcasts = BATADV_SKB_CB(forw_packet->skb)->num_bcasts;
1041
1042 return num_bcasts != forw_packet->if_outgoing->num_bcasts;
1043}
1044
1045
1046
1047
1048
1049
1050
1051static void batadv_send_outstanding_bcast_packet(struct work_struct *work)
1052{
1053 unsigned long send_time = jiffies + msecs_to_jiffies(5);
1054 struct batadv_forw_packet *forw_packet;
1055 struct delayed_work *delayed_work;
1056 struct batadv_priv *bat_priv;
1057 struct sk_buff *skb1;
1058 bool dropped = false;
1059
1060 delayed_work = to_delayed_work(work);
1061 forw_packet = container_of(delayed_work, struct batadv_forw_packet,
1062 delayed_work);
1063 bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
1064
1065 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) {
1066 dropped = true;
1067 goto out;
1068 }
1069
1070 if (batadv_dat_drop_broadcast_packet(bat_priv, forw_packet)) {
1071 dropped = true;
1072 goto out;
1073 }
1074
1075
1076 skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC);
1077 if (!skb1)
1078 goto out;
1079
1080 batadv_send_broadcast_skb(skb1, forw_packet->if_outgoing);
1081 batadv_forw_packet_bcasts_dec(forw_packet);
1082
1083 if (batadv_forw_packet_bcasts_left(forw_packet)) {
1084 batadv_forw_packet_bcast_queue(bat_priv, forw_packet,
1085 send_time);
1086 return;
1087 }
1088
1089out:
1090
1091 if (batadv_forw_packet_steal(forw_packet,
1092 &bat_priv->forw_bcast_list_lock))
1093 batadv_forw_packet_free(forw_packet, dropped);
1094}
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107void
1108batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
1109 const struct batadv_hard_iface *hard_iface)
1110{
1111 struct hlist_head head = HLIST_HEAD_INIT;
1112
1113 if (hard_iface)
1114 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1115 "%s(): %s\n",
1116 __func__, hard_iface->net_dev->name);
1117 else
1118 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1119 "%s()\n", __func__);
1120
1121
1122 spin_lock_bh(&bat_priv->forw_bcast_list_lock);
1123 batadv_forw_packet_list_steal(&bat_priv->forw_bcast_list, &head,
1124 hard_iface);
1125 spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
1126
1127
1128 spin_lock_bh(&bat_priv->forw_bat_list_lock);
1129 batadv_forw_packet_list_steal(&bat_priv->forw_bat_list, &head,
1130 hard_iface);
1131 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
1132
1133
1134 batadv_forw_packet_list_free(&head);
1135}
1136