1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/crc32c.h>
19#include <linux/highmem.h>
20#include <linux/if_vlan.h>
21#include <net/ip.h>
22#include <net/ipv6.h>
23#include <net/dsfield.h>
24#include "main.h"
25#include "sysfs.h"
26#include "debugfs.h"
27#include "routing.h"
28#include "send.h"
29#include "originator.h"
30#include "soft-interface.h"
31#include "icmp_socket.h"
32#include "translation-table.h"
33#include "hard-interface.h"
34#include "gateway_client.h"
35#include "bridge_loop_avoidance.h"
36#include "distributed-arp-table.h"
37#include "multicast.h"
38#include "gateway_common.h"
39#include "hash.h"
40#include "bat_algo.h"
41#include "network-coding.h"
42#include "fragmentation.h"
43
44
45
46
47struct list_head batadv_hardif_list;
48static int (*batadv_rx_handler[256])(struct sk_buff *,
49 struct batadv_hard_iface *);
50char batadv_routing_algo[20] = "BATMAN_IV";
51static struct hlist_head batadv_algo_list;
52
53unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
54
55struct workqueue_struct *batadv_event_workqueue;
56
57static void batadv_recv_handler_init(void);
58
59static int __init batadv_init(void)
60{
61 INIT_LIST_HEAD(&batadv_hardif_list);
62 INIT_HLIST_HEAD(&batadv_algo_list);
63
64 batadv_recv_handler_init();
65
66 batadv_iv_init();
67 batadv_nc_init();
68
69 batadv_event_workqueue = create_singlethread_workqueue("bat_events");
70
71 if (!batadv_event_workqueue)
72 return -ENOMEM;
73
74 batadv_socket_init();
75 batadv_debugfs_init();
76
77 register_netdevice_notifier(&batadv_hard_if_notifier);
78 rtnl_link_register(&batadv_link_ops);
79
80 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
81 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
82
83 return 0;
84}
85
86static void __exit batadv_exit(void)
87{
88 batadv_debugfs_destroy();
89 rtnl_link_unregister(&batadv_link_ops);
90 unregister_netdevice_notifier(&batadv_hard_if_notifier);
91 batadv_hardif_remove_interfaces();
92
93 flush_workqueue(batadv_event_workqueue);
94 destroy_workqueue(batadv_event_workqueue);
95 batadv_event_workqueue = NULL;
96
97 rcu_barrier();
98}
99
100int batadv_mesh_init(struct net_device *soft_iface)
101{
102 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
103 int ret;
104
105 spin_lock_init(&bat_priv->forw_bat_list_lock);
106 spin_lock_init(&bat_priv->forw_bcast_list_lock);
107 spin_lock_init(&bat_priv->tt.changes_list_lock);
108 spin_lock_init(&bat_priv->tt.req_list_lock);
109 spin_lock_init(&bat_priv->tt.roam_list_lock);
110 spin_lock_init(&bat_priv->tt.last_changeset_lock);
111 spin_lock_init(&bat_priv->tt.commit_lock);
112 spin_lock_init(&bat_priv->gw.list_lock);
113#ifdef CONFIG_BATMAN_ADV_MCAST
114 spin_lock_init(&bat_priv->mcast.want_lists_lock);
115#endif
116 spin_lock_init(&bat_priv->tvlv.container_list_lock);
117 spin_lock_init(&bat_priv->tvlv.handler_list_lock);
118 spin_lock_init(&bat_priv->softif_vlan_list_lock);
119
120 INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
121 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
122 INIT_HLIST_HEAD(&bat_priv->gw.list);
123#ifdef CONFIG_BATMAN_ADV_MCAST
124 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_unsnoopables_list);
125 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv4_list);
126 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv6_list);
127#endif
128 INIT_LIST_HEAD(&bat_priv->tt.changes_list);
129 INIT_LIST_HEAD(&bat_priv->tt.req_list);
130 INIT_LIST_HEAD(&bat_priv->tt.roam_list);
131#ifdef CONFIG_BATMAN_ADV_MCAST
132 INIT_HLIST_HEAD(&bat_priv->mcast.mla_list);
133#endif
134 INIT_HLIST_HEAD(&bat_priv->tvlv.container_list);
135 INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list);
136 INIT_HLIST_HEAD(&bat_priv->softif_vlan_list);
137
138 ret = batadv_originator_init(bat_priv);
139 if (ret < 0)
140 goto err;
141
142 ret = batadv_tt_init(bat_priv);
143 if (ret < 0)
144 goto err;
145
146 ret = batadv_bla_init(bat_priv);
147 if (ret < 0)
148 goto err;
149
150 ret = batadv_dat_init(bat_priv);
151 if (ret < 0)
152 goto err;
153
154 ret = batadv_nc_mesh_init(bat_priv);
155 if (ret < 0)
156 goto err;
157
158 batadv_gw_init(bat_priv);
159 batadv_mcast_init(bat_priv);
160
161 atomic_set(&bat_priv->gw.reselect, 0);
162 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
163
164 return 0;
165
166err:
167 batadv_mesh_free(soft_iface);
168 return ret;
169}
170
171void batadv_mesh_free(struct net_device *soft_iface)
172{
173 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
174
175 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
176
177 batadv_purge_outstanding_packets(bat_priv, NULL);
178
179 batadv_gw_node_purge(bat_priv);
180 batadv_nc_mesh_free(bat_priv);
181 batadv_dat_free(bat_priv);
182 batadv_bla_free(bat_priv);
183
184 batadv_mcast_free(bat_priv);
185
186
187
188
189
190 batadv_tt_free(bat_priv);
191
192
193
194
195
196
197 batadv_originator_free(bat_priv);
198
199 batadv_gw_free(bat_priv);
200
201 free_percpu(bat_priv->bat_counters);
202 bat_priv->bat_counters = NULL;
203
204 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
205}
206
207
208
209
210
211
212
213int batadv_is_my_mac(struct batadv_priv *bat_priv, const uint8_t *addr)
214{
215 const struct batadv_hard_iface *hard_iface;
216
217 rcu_read_lock();
218 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
219 if (hard_iface->if_status != BATADV_IF_ACTIVE)
220 continue;
221
222 if (hard_iface->soft_iface != bat_priv->soft_iface)
223 continue;
224
225 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
226 rcu_read_unlock();
227 return 1;
228 }
229 }
230 rcu_read_unlock();
231 return 0;
232}
233
234
235
236
237
238
239
240
241struct batadv_hard_iface *
242batadv_seq_print_text_primary_if_get(struct seq_file *seq)
243{
244 struct net_device *net_dev = (struct net_device *)seq->private;
245 struct batadv_priv *bat_priv = netdev_priv(net_dev);
246 struct batadv_hard_iface *primary_if;
247
248 primary_if = batadv_primary_if_get_selected(bat_priv);
249
250 if (!primary_if) {
251 seq_printf(seq,
252 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
253 net_dev->name);
254 goto out;
255 }
256
257 if (primary_if->if_status == BATADV_IF_ACTIVE)
258 goto out;
259
260 seq_printf(seq,
261 "BATMAN mesh %s disabled - primary interface not active\n",
262 net_dev->name);
263 batadv_hardif_free_ref(primary_if);
264 primary_if = NULL;
265
266out:
267 return primary_if;
268}
269
270
271
272
273
274
275
276int batadv_max_header_len(void)
277{
278 int header_len = 0;
279
280 header_len = max_t(int, header_len,
281 sizeof(struct batadv_unicast_packet));
282 header_len = max_t(int, header_len,
283 sizeof(struct batadv_unicast_4addr_packet));
284 header_len = max_t(int, header_len,
285 sizeof(struct batadv_bcast_packet));
286
287#ifdef CONFIG_BATMAN_ADV_NC
288 header_len = max_t(int, header_len,
289 sizeof(struct batadv_coded_packet));
290#endif
291
292 return header_len + ETH_HLEN;
293}
294
295
296
297
298
299
300
301
302
303void batadv_skb_set_priority(struct sk_buff *skb, int offset)
304{
305 struct iphdr ip_hdr_tmp, *ip_hdr;
306 struct ipv6hdr ip6_hdr_tmp, *ip6_hdr;
307 struct ethhdr ethhdr_tmp, *ethhdr;
308 struct vlan_ethhdr *vhdr, vhdr_tmp;
309 u32 prio;
310
311
312 if (skb->priority >= 256 && skb->priority <= 263)
313 return;
314
315 ethhdr = skb_header_pointer(skb, offset, sizeof(*ethhdr), ðhdr_tmp);
316 if (!ethhdr)
317 return;
318
319 switch (ethhdr->h_proto) {
320 case htons(ETH_P_8021Q):
321 vhdr = skb_header_pointer(skb, offset + sizeof(*vhdr),
322 sizeof(*vhdr), &vhdr_tmp);
323 if (!vhdr)
324 return;
325 prio = ntohs(vhdr->h_vlan_TCI) & VLAN_PRIO_MASK;
326 prio = prio >> VLAN_PRIO_SHIFT;
327 break;
328 case htons(ETH_P_IP):
329 ip_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
330 sizeof(*ip_hdr), &ip_hdr_tmp);
331 if (!ip_hdr)
332 return;
333 prio = (ipv4_get_dsfield(ip_hdr) & 0xfc) >> 5;
334 break;
335 case htons(ETH_P_IPV6):
336 ip6_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
337 sizeof(*ip6_hdr), &ip6_hdr_tmp);
338 if (!ip6_hdr)
339 return;
340 prio = (ipv6_get_dsfield(ip6_hdr) & 0xfc) >> 5;
341 break;
342 default:
343 return;
344 }
345
346 skb->priority = prio + 256;
347}
348
349static int batadv_recv_unhandled_packet(struct sk_buff *skb,
350 struct batadv_hard_iface *recv_if)
351{
352 return NET_RX_DROP;
353}
354
355
356
357
358int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
359 struct packet_type *ptype,
360 struct net_device *orig_dev)
361{
362 struct batadv_priv *bat_priv;
363 struct batadv_ogm_packet *batadv_ogm_packet;
364 struct batadv_hard_iface *hard_iface;
365 uint8_t idx;
366 int ret;
367
368 hard_iface = container_of(ptype, struct batadv_hard_iface,
369 batman_adv_ptype);
370 skb = skb_share_check(skb, GFP_ATOMIC);
371
372
373 if (!skb)
374 goto err_out;
375
376
377 if (unlikely(!pskb_may_pull(skb, 2)))
378 goto err_free;
379
380
381 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
382 goto err_free;
383
384 if (!hard_iface->soft_iface)
385 goto err_free;
386
387 bat_priv = netdev_priv(hard_iface->soft_iface);
388
389 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
390 goto err_free;
391
392
393 if (hard_iface->if_status != BATADV_IF_ACTIVE)
394 goto err_free;
395
396 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
397
398 if (batadv_ogm_packet->version != BATADV_COMPAT_VERSION) {
399 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
400 "Drop packet: incompatible batman version (%i)\n",
401 batadv_ogm_packet->version);
402 goto err_free;
403 }
404
405
406 memset(skb->cb, 0, sizeof(struct batadv_skb_cb));
407
408
409
410
411 idx = batadv_ogm_packet->packet_type;
412 ret = (*batadv_rx_handler[idx])(skb, hard_iface);
413
414 if (ret == NET_RX_DROP)
415 kfree_skb(skb);
416
417
418
419
420
421 return NET_RX_SUCCESS;
422
423err_free:
424 kfree_skb(skb);
425err_out:
426 return NET_RX_DROP;
427}
428
429static void batadv_recv_handler_init(void)
430{
431 int i;
432
433 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
434 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
435
436 for (i = BATADV_UNICAST_MIN; i <= BATADV_UNICAST_MAX; i++)
437 batadv_rx_handler[i] = batadv_recv_unhandled_unicast_packet;
438
439
440 BUILD_BUG_ON(sizeof(struct batadv_bla_claim_dst) != 6);
441 BUILD_BUG_ON(sizeof(struct batadv_ogm_packet) != 24);
442 BUILD_BUG_ON(sizeof(struct batadv_icmp_header) != 20);
443 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet) != 20);
444 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet_rr) != 116);
445 BUILD_BUG_ON(sizeof(struct batadv_unicast_packet) != 10);
446 BUILD_BUG_ON(sizeof(struct batadv_unicast_4addr_packet) != 18);
447 BUILD_BUG_ON(sizeof(struct batadv_frag_packet) != 20);
448 BUILD_BUG_ON(sizeof(struct batadv_bcast_packet) != 14);
449 BUILD_BUG_ON(sizeof(struct batadv_coded_packet) != 46);
450 BUILD_BUG_ON(sizeof(struct batadv_unicast_tvlv_packet) != 20);
451 BUILD_BUG_ON(sizeof(struct batadv_tvlv_hdr) != 4);
452 BUILD_BUG_ON(sizeof(struct batadv_tvlv_gateway_data) != 8);
453 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_vlan_data) != 8);
454 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_change) != 12);
455 BUILD_BUG_ON(sizeof(struct batadv_tvlv_roam_adv) != 8);
456
457
458 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
459
460
461
462 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
463
464 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
465
466 batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv;
467
468 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
469
470 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_frag_packet;
471}
472
473int
474batadv_recv_handler_register(uint8_t packet_type,
475 int (*recv_handler)(struct sk_buff *,
476 struct batadv_hard_iface *))
477{
478 int (*curr)(struct sk_buff *,
479 struct batadv_hard_iface *);
480 curr = batadv_rx_handler[packet_type];
481
482 if ((curr != batadv_recv_unhandled_packet) &&
483 (curr != batadv_recv_unhandled_unicast_packet))
484 return -EBUSY;
485
486 batadv_rx_handler[packet_type] = recv_handler;
487 return 0;
488}
489
490void batadv_recv_handler_unregister(uint8_t packet_type)
491{
492 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
493}
494
495static struct batadv_algo_ops *batadv_algo_get(char *name)
496{
497 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
498
499 hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
500 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
501 continue;
502
503 bat_algo_ops = bat_algo_ops_tmp;
504 break;
505 }
506
507 return bat_algo_ops;
508}
509
510int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
511{
512 struct batadv_algo_ops *bat_algo_ops_tmp;
513 int ret;
514
515 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
516 if (bat_algo_ops_tmp) {
517 pr_info("Trying to register already registered routing algorithm: %s\n",
518 bat_algo_ops->name);
519 ret = -EEXIST;
520 goto out;
521 }
522
523
524 if (!bat_algo_ops->bat_iface_enable ||
525 !bat_algo_ops->bat_iface_disable ||
526 !bat_algo_ops->bat_iface_update_mac ||
527 !bat_algo_ops->bat_primary_iface_set ||
528 !bat_algo_ops->bat_ogm_schedule ||
529 !bat_algo_ops->bat_ogm_emit ||
530 !bat_algo_ops->bat_neigh_cmp ||
531 !bat_algo_ops->bat_neigh_is_equiv_or_better) {
532 pr_info("Routing algo '%s' does not implement required ops\n",
533 bat_algo_ops->name);
534 ret = -EINVAL;
535 goto out;
536 }
537
538 INIT_HLIST_NODE(&bat_algo_ops->list);
539 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
540 ret = 0;
541
542out:
543 return ret;
544}
545
546int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
547{
548 struct batadv_algo_ops *bat_algo_ops;
549 int ret = -EINVAL;
550
551 bat_algo_ops = batadv_algo_get(name);
552 if (!bat_algo_ops)
553 goto out;
554
555 bat_priv->bat_algo_ops = bat_algo_ops;
556 ret = 0;
557
558out:
559 return ret;
560}
561
562int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
563{
564 struct batadv_algo_ops *bat_algo_ops;
565
566 seq_puts(seq, "Available routing algorithms:\n");
567
568 hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
569 seq_printf(seq, "%s\n", bat_algo_ops->name);
570 }
571
572 return 0;
573}
574
575
576
577
578
579
580
581
582
583
584
585__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
586{
587 u32 crc = 0;
588 unsigned int from;
589 unsigned int to = skb->len;
590 struct skb_seq_state st;
591 const u8 *data;
592 unsigned int len;
593 unsigned int consumed = 0;
594
595 from = (unsigned int)(payload_ptr - skb->data);
596
597 skb_prepare_seq_read(skb, from, to, &st);
598 while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
599 crc = crc32c(crc, data, len);
600 consumed += len;
601 }
602
603 return htonl(crc);
604}
605
606
607
608
609
610
611static void
612batadv_tvlv_handler_free_ref(struct batadv_tvlv_handler *tvlv_handler)
613{
614 if (atomic_dec_and_test(&tvlv_handler->refcount))
615 kfree_rcu(tvlv_handler, rcu);
616}
617
618
619
620
621
622
623
624
625
626
627static struct batadv_tvlv_handler
628*batadv_tvlv_handler_get(struct batadv_priv *bat_priv,
629 uint8_t type, uint8_t version)
630{
631 struct batadv_tvlv_handler *tvlv_handler_tmp, *tvlv_handler = NULL;
632
633 rcu_read_lock();
634 hlist_for_each_entry_rcu(tvlv_handler_tmp,
635 &bat_priv->tvlv.handler_list, list) {
636 if (tvlv_handler_tmp->type != type)
637 continue;
638
639 if (tvlv_handler_tmp->version != version)
640 continue;
641
642 if (!atomic_inc_not_zero(&tvlv_handler_tmp->refcount))
643 continue;
644
645 tvlv_handler = tvlv_handler_tmp;
646 break;
647 }
648 rcu_read_unlock();
649
650 return tvlv_handler;
651}
652
653
654
655
656
657
658static void batadv_tvlv_container_free_ref(struct batadv_tvlv_container *tvlv)
659{
660 if (atomic_dec_and_test(&tvlv->refcount))
661 kfree(tvlv);
662}
663
664
665
666
667
668
669
670
671
672
673
674
675
676static struct batadv_tvlv_container
677*batadv_tvlv_container_get(struct batadv_priv *bat_priv,
678 uint8_t type, uint8_t version)
679{
680 struct batadv_tvlv_container *tvlv_tmp, *tvlv = NULL;
681
682 hlist_for_each_entry(tvlv_tmp, &bat_priv->tvlv.container_list, list) {
683 if (tvlv_tmp->tvlv_hdr.type != type)
684 continue;
685
686 if (tvlv_tmp->tvlv_hdr.version != version)
687 continue;
688
689 if (!atomic_inc_not_zero(&tvlv_tmp->refcount))
690 continue;
691
692 tvlv = tvlv_tmp;
693 break;
694 }
695
696 return tvlv;
697}
698
699
700
701
702
703
704
705
706
707
708
709static uint16_t batadv_tvlv_container_list_size(struct batadv_priv *bat_priv)
710{
711 struct batadv_tvlv_container *tvlv;
712 uint16_t tvlv_len = 0;
713
714 hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
715 tvlv_len += sizeof(struct batadv_tvlv_hdr);
716 tvlv_len += ntohs(tvlv->tvlv_hdr.len);
717 }
718
719 return tvlv_len;
720}
721
722
723
724
725
726
727
728
729
730static void batadv_tvlv_container_remove(struct batadv_tvlv_container *tvlv)
731{
732 if (!tvlv)
733 return;
734
735 hlist_del(&tvlv->list);
736
737
738 batadv_tvlv_container_free_ref(tvlv);
739 batadv_tvlv_container_free_ref(tvlv);
740}
741
742
743
744
745
746
747
748
749void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
750 uint8_t type, uint8_t version)
751{
752 struct batadv_tvlv_container *tvlv;
753
754 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
755 tvlv = batadv_tvlv_container_get(bat_priv, type, version);
756 batadv_tvlv_container_remove(tvlv);
757 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
758}
759
760
761
762
763
764
765
766
767
768
769
770
771
772void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
773 uint8_t type, uint8_t version,
774 void *tvlv_value, uint16_t tvlv_value_len)
775{
776 struct batadv_tvlv_container *tvlv_old, *tvlv_new;
777
778 if (!tvlv_value)
779 tvlv_value_len = 0;
780
781 tvlv_new = kzalloc(sizeof(*tvlv_new) + tvlv_value_len, GFP_ATOMIC);
782 if (!tvlv_new)
783 return;
784
785 tvlv_new->tvlv_hdr.version = version;
786 tvlv_new->tvlv_hdr.type = type;
787 tvlv_new->tvlv_hdr.len = htons(tvlv_value_len);
788
789 memcpy(tvlv_new + 1, tvlv_value, ntohs(tvlv_new->tvlv_hdr.len));
790 INIT_HLIST_NODE(&tvlv_new->list);
791 atomic_set(&tvlv_new->refcount, 1);
792
793 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
794 tvlv_old = batadv_tvlv_container_get(bat_priv, type, version);
795 batadv_tvlv_container_remove(tvlv_old);
796 hlist_add_head(&tvlv_new->list, &bat_priv->tvlv.container_list);
797 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
798}
799
800
801
802
803
804
805
806
807
808
809
810
811
812static bool batadv_tvlv_realloc_packet_buff(unsigned char **packet_buff,
813 int *packet_buff_len,
814 int min_packet_len,
815 int additional_packet_len)
816{
817 unsigned char *new_buff;
818
819 new_buff = kmalloc(min_packet_len + additional_packet_len, GFP_ATOMIC);
820
821
822 if (new_buff) {
823 memcpy(new_buff, *packet_buff, min_packet_len);
824 kfree(*packet_buff);
825 *packet_buff = new_buff;
826 *packet_buff_len = min_packet_len + additional_packet_len;
827 return true;
828 }
829
830 return false;
831}
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847uint16_t batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
848 unsigned char **packet_buff,
849 int *packet_buff_len,
850 int packet_min_len)
851{
852 struct batadv_tvlv_container *tvlv;
853 struct batadv_tvlv_hdr *tvlv_hdr;
854 uint16_t tvlv_value_len;
855 void *tvlv_value;
856 bool ret;
857
858 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
859 tvlv_value_len = batadv_tvlv_container_list_size(bat_priv);
860
861 ret = batadv_tvlv_realloc_packet_buff(packet_buff, packet_buff_len,
862 packet_min_len, tvlv_value_len);
863
864 if (!ret)
865 goto end;
866
867 if (!tvlv_value_len)
868 goto end;
869
870 tvlv_value = (*packet_buff) + packet_min_len;
871
872 hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
873 tvlv_hdr = tvlv_value;
874 tvlv_hdr->type = tvlv->tvlv_hdr.type;
875 tvlv_hdr->version = tvlv->tvlv_hdr.version;
876 tvlv_hdr->len = tvlv->tvlv_hdr.len;
877 tvlv_value = tvlv_hdr + 1;
878 memcpy(tvlv_value, tvlv + 1, ntohs(tvlv->tvlv_hdr.len));
879 tvlv_value = (uint8_t *)tvlv_value + ntohs(tvlv->tvlv_hdr.len);
880 }
881
882end:
883 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
884 return tvlv_value_len;
885}
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,
903 struct batadv_tvlv_handler *tvlv_handler,
904 bool ogm_source,
905 struct batadv_orig_node *orig_node,
906 uint8_t *src, uint8_t *dst,
907 void *tvlv_value, uint16_t tvlv_value_len)
908{
909 if (!tvlv_handler)
910 return NET_RX_SUCCESS;
911
912 if (ogm_source) {
913 if (!tvlv_handler->ogm_handler)
914 return NET_RX_SUCCESS;
915
916 if (!orig_node)
917 return NET_RX_SUCCESS;
918
919 tvlv_handler->ogm_handler(bat_priv, orig_node,
920 BATADV_NO_FLAGS,
921 tvlv_value, tvlv_value_len);
922 tvlv_handler->flags |= BATADV_TVLV_HANDLER_OGM_CALLED;
923 } else {
924 if (!src)
925 return NET_RX_SUCCESS;
926
927 if (!dst)
928 return NET_RX_SUCCESS;
929
930 if (!tvlv_handler->unicast_handler)
931 return NET_RX_SUCCESS;
932
933 return tvlv_handler->unicast_handler(bat_priv, src,
934 dst, tvlv_value,
935 tvlv_value_len);
936 }
937
938 return NET_RX_SUCCESS;
939}
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
956 bool ogm_source,
957 struct batadv_orig_node *orig_node,
958 uint8_t *src, uint8_t *dst,
959 void *tvlv_value, uint16_t tvlv_value_len)
960{
961 struct batadv_tvlv_handler *tvlv_handler;
962 struct batadv_tvlv_hdr *tvlv_hdr;
963 uint16_t tvlv_value_cont_len;
964 uint8_t cifnotfound = BATADV_TVLV_HANDLER_OGM_CIFNOTFND;
965 int ret = NET_RX_SUCCESS;
966
967 while (tvlv_value_len >= sizeof(*tvlv_hdr)) {
968 tvlv_hdr = tvlv_value;
969 tvlv_value_cont_len = ntohs(tvlv_hdr->len);
970 tvlv_value = tvlv_hdr + 1;
971 tvlv_value_len -= sizeof(*tvlv_hdr);
972
973 if (tvlv_value_cont_len > tvlv_value_len)
974 break;
975
976 tvlv_handler = batadv_tvlv_handler_get(bat_priv,
977 tvlv_hdr->type,
978 tvlv_hdr->version);
979
980 ret |= batadv_tvlv_call_handler(bat_priv, tvlv_handler,
981 ogm_source, orig_node,
982 src, dst, tvlv_value,
983 tvlv_value_cont_len);
984 if (tvlv_handler)
985 batadv_tvlv_handler_free_ref(tvlv_handler);
986 tvlv_value = (uint8_t *)tvlv_value + tvlv_value_cont_len;
987 tvlv_value_len -= tvlv_value_cont_len;
988 }
989
990 if (!ogm_source)
991 return ret;
992
993 rcu_read_lock();
994 hlist_for_each_entry_rcu(tvlv_handler,
995 &bat_priv->tvlv.handler_list, list) {
996 if ((tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) &&
997 !(tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CALLED))
998 tvlv_handler->ogm_handler(bat_priv, orig_node,
999 cifnotfound, NULL, 0);
1000
1001 tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED;
1002 }
1003 rcu_read_unlock();
1004
1005 return NET_RX_SUCCESS;
1006}
1007
1008
1009
1010
1011
1012
1013
1014
1015void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
1016 struct batadv_ogm_packet *batadv_ogm_packet,
1017 struct batadv_orig_node *orig_node)
1018{
1019 void *tvlv_value;
1020 uint16_t tvlv_value_len;
1021
1022 if (!batadv_ogm_packet)
1023 return;
1024
1025 tvlv_value_len = ntohs(batadv_ogm_packet->tvlv_len);
1026 if (!tvlv_value_len)
1027 return;
1028
1029 tvlv_value = batadv_ogm_packet + 1;
1030
1031 batadv_tvlv_containers_process(bat_priv, true, orig_node, NULL, NULL,
1032 tvlv_value, tvlv_value_len);
1033}
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
1050 void (*optr)(struct batadv_priv *bat_priv,
1051 struct batadv_orig_node *orig,
1052 uint8_t flags,
1053 void *tvlv_value,
1054 uint16_t tvlv_value_len),
1055 int (*uptr)(struct batadv_priv *bat_priv,
1056 uint8_t *src, uint8_t *dst,
1057 void *tvlv_value,
1058 uint16_t tvlv_value_len),
1059 uint8_t type, uint8_t version, uint8_t flags)
1060{
1061 struct batadv_tvlv_handler *tvlv_handler;
1062
1063 tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1064 if (tvlv_handler) {
1065 batadv_tvlv_handler_free_ref(tvlv_handler);
1066 return;
1067 }
1068
1069 tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC);
1070 if (!tvlv_handler)
1071 return;
1072
1073 tvlv_handler->ogm_handler = optr;
1074 tvlv_handler->unicast_handler = uptr;
1075 tvlv_handler->type = type;
1076 tvlv_handler->version = version;
1077 tvlv_handler->flags = flags;
1078 atomic_set(&tvlv_handler->refcount, 1);
1079 INIT_HLIST_NODE(&tvlv_handler->list);
1080
1081 spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1082 hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list);
1083 spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1084}
1085
1086
1087
1088
1089
1090
1091
1092
1093void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
1094 uint8_t type, uint8_t version)
1095{
1096 struct batadv_tvlv_handler *tvlv_handler;
1097
1098 tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1099 if (!tvlv_handler)
1100 return;
1101
1102 batadv_tvlv_handler_free_ref(tvlv_handler);
1103 spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1104 hlist_del_rcu(&tvlv_handler->list);
1105 spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1106 batadv_tvlv_handler_free_ref(tvlv_handler);
1107}
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120void batadv_tvlv_unicast_send(struct batadv_priv *bat_priv, uint8_t *src,
1121 uint8_t *dst, uint8_t type, uint8_t version,
1122 void *tvlv_value, uint16_t tvlv_value_len)
1123{
1124 struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
1125 struct batadv_tvlv_hdr *tvlv_hdr;
1126 struct batadv_orig_node *orig_node;
1127 struct sk_buff *skb = NULL;
1128 unsigned char *tvlv_buff;
1129 unsigned int tvlv_len;
1130 ssize_t hdr_len = sizeof(*unicast_tvlv_packet);
1131 bool ret = false;
1132
1133 orig_node = batadv_orig_hash_find(bat_priv, dst);
1134 if (!orig_node)
1135 goto out;
1136
1137 tvlv_len = sizeof(*tvlv_hdr) + tvlv_value_len;
1138
1139 skb = netdev_alloc_skb_ip_align(NULL, ETH_HLEN + hdr_len + tvlv_len);
1140 if (!skb)
1141 goto out;
1142
1143 skb->priority = TC_PRIO_CONTROL;
1144 skb_reserve(skb, ETH_HLEN);
1145 tvlv_buff = skb_put(skb, sizeof(*unicast_tvlv_packet) + tvlv_len);
1146 unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)tvlv_buff;
1147 unicast_tvlv_packet->packet_type = BATADV_UNICAST_TVLV;
1148 unicast_tvlv_packet->version = BATADV_COMPAT_VERSION;
1149 unicast_tvlv_packet->ttl = BATADV_TTL;
1150 unicast_tvlv_packet->reserved = 0;
1151 unicast_tvlv_packet->tvlv_len = htons(tvlv_len);
1152 unicast_tvlv_packet->align = 0;
1153 ether_addr_copy(unicast_tvlv_packet->src, src);
1154 ether_addr_copy(unicast_tvlv_packet->dst, dst);
1155
1156 tvlv_buff = (unsigned char *)(unicast_tvlv_packet + 1);
1157 tvlv_hdr = (struct batadv_tvlv_hdr *)tvlv_buff;
1158 tvlv_hdr->version = version;
1159 tvlv_hdr->type = type;
1160 tvlv_hdr->len = htons(tvlv_value_len);
1161 tvlv_buff += sizeof(*tvlv_hdr);
1162 memcpy(tvlv_buff, tvlv_value, tvlv_value_len);
1163
1164 if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
1165 ret = true;
1166
1167out:
1168 if (skb && !ret)
1169 kfree_skb(skb);
1170 if (orig_node)
1171 batadv_orig_node_free_ref(orig_node);
1172}
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len)
1183{
1184 struct ethhdr *ethhdr = (struct ethhdr *)(skb->data + header_len);
1185 struct vlan_ethhdr *vhdr;
1186 unsigned short vid;
1187
1188 if (ethhdr->h_proto != htons(ETH_P_8021Q))
1189 return BATADV_NO_FLAGS;
1190
1191 if (!pskb_may_pull(skb, header_len + VLAN_ETH_HLEN))
1192 return BATADV_NO_FLAGS;
1193
1194 vhdr = (struct vlan_ethhdr *)(skb->data + header_len);
1195 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
1196 vid |= BATADV_VLAN_HAS_TAG;
1197
1198 return vid;
1199}
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid)
1211{
1212 bool ap_isolation_enabled = false;
1213 struct batadv_softif_vlan *vlan;
1214
1215
1216
1217
1218 vlan = batadv_softif_vlan_get(bat_priv, vid);
1219 if (vlan) {
1220 ap_isolation_enabled = atomic_read(&vlan->ap_isolation);
1221 batadv_softif_vlan_free_ref(vlan);
1222 }
1223
1224 return ap_isolation_enabled;
1225}
1226
1227static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
1228{
1229 struct batadv_algo_ops *bat_algo_ops;
1230 char *algo_name = (char *)val;
1231 size_t name_len = strlen(algo_name);
1232
1233 if (name_len > 0 && algo_name[name_len - 1] == '\n')
1234 algo_name[name_len - 1] = '\0';
1235
1236 bat_algo_ops = batadv_algo_get(algo_name);
1237 if (!bat_algo_ops) {
1238 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
1239 return -EINVAL;
1240 }
1241
1242 return param_set_copystring(algo_name, kp);
1243}
1244
1245static const struct kernel_param_ops batadv_param_ops_ra = {
1246 .set = batadv_param_set_ra,
1247 .get = param_get_string,
1248};
1249
1250static struct kparam_string batadv_param_string_ra = {
1251 .maxlen = sizeof(batadv_routing_algo),
1252 .string = batadv_routing_algo,
1253};
1254
1255module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
1256 0644);
1257module_init(batadv_init);
1258module_exit(batadv_exit);
1259
1260MODULE_LICENSE("GPL");
1261
1262MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
1263MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
1264MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
1265MODULE_VERSION(BATADV_SOURCE_VERSION);
1266