1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/crc32c.h>
21#include <linux/highmem.h>
22#include <linux/if_vlan.h>
23#include <net/ip.h>
24#include <net/ipv6.h>
25#include <net/dsfield.h>
26#include "main.h"
27#include "sysfs.h"
28#include "debugfs.h"
29#include "routing.h"
30#include "send.h"
31#include "originator.h"
32#include "soft-interface.h"
33#include "icmp_socket.h"
34#include "translation-table.h"
35#include "hard-interface.h"
36#include "gateway_client.h"
37#include "bridge_loop_avoidance.h"
38#include "distributed-arp-table.h"
39#include "vis.h"
40#include "hash.h"
41#include "bat_algo.h"
42#include "network-coding.h"
43
44
45
46
47
48struct list_head batadv_hardif_list;
49static int (*batadv_rx_handler[256])(struct sk_buff *,
50 struct batadv_hard_iface *);
51char batadv_routing_algo[20] = "BATMAN_IV";
52static struct hlist_head batadv_algo_list;
53
54unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
55
56struct workqueue_struct *batadv_event_workqueue;
57
58static void batadv_recv_handler_init(void);
59
60static int __init batadv_init(void)
61{
62 INIT_LIST_HEAD(&batadv_hardif_list);
63 INIT_HLIST_HEAD(&batadv_algo_list);
64
65 batadv_recv_handler_init();
66
67 batadv_iv_init();
68 batadv_nc_init();
69
70 batadv_event_workqueue = create_singlethread_workqueue("bat_events");
71
72 if (!batadv_event_workqueue)
73 return -ENOMEM;
74
75 batadv_socket_init();
76 batadv_debugfs_init();
77
78 register_netdevice_notifier(&batadv_hard_if_notifier);
79 rtnl_link_register(&batadv_link_ops);
80
81 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
82 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
83
84 return 0;
85}
86
87static void __exit batadv_exit(void)
88{
89 batadv_debugfs_destroy();
90 rtnl_link_unregister(&batadv_link_ops);
91 unregister_netdevice_notifier(&batadv_hard_if_notifier);
92 batadv_hardif_remove_interfaces();
93
94 flush_workqueue(batadv_event_workqueue);
95 destroy_workqueue(batadv_event_workqueue);
96 batadv_event_workqueue = NULL;
97
98 rcu_barrier();
99}
100
101int batadv_mesh_init(struct net_device *soft_iface)
102{
103 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
104 int ret;
105
106 spin_lock_init(&bat_priv->forw_bat_list_lock);
107 spin_lock_init(&bat_priv->forw_bcast_list_lock);
108 spin_lock_init(&bat_priv->tt.changes_list_lock);
109 spin_lock_init(&bat_priv->tt.req_list_lock);
110 spin_lock_init(&bat_priv->tt.roam_list_lock);
111 spin_lock_init(&bat_priv->tt.last_changeset_lock);
112 spin_lock_init(&bat_priv->gw.list_lock);
113 spin_lock_init(&bat_priv->vis.hash_lock);
114 spin_lock_init(&bat_priv->vis.list_lock);
115
116 INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
117 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
118 INIT_HLIST_HEAD(&bat_priv->gw.list);
119 INIT_LIST_HEAD(&bat_priv->tt.changes_list);
120 INIT_LIST_HEAD(&bat_priv->tt.req_list);
121 INIT_LIST_HEAD(&bat_priv->tt.roam_list);
122
123 ret = batadv_originator_init(bat_priv);
124 if (ret < 0)
125 goto err;
126
127 ret = batadv_tt_init(bat_priv);
128 if (ret < 0)
129 goto err;
130
131 batadv_tt_local_add(soft_iface, soft_iface->dev_addr,
132 BATADV_NULL_IFINDEX);
133
134 ret = batadv_vis_init(bat_priv);
135 if (ret < 0)
136 goto err;
137
138 ret = batadv_bla_init(bat_priv);
139 if (ret < 0)
140 goto err;
141
142 ret = batadv_dat_init(bat_priv);
143 if (ret < 0)
144 goto err;
145
146 ret = batadv_nc_mesh_init(bat_priv);
147 if (ret < 0)
148 goto err;
149
150 atomic_set(&bat_priv->gw.reselect, 0);
151 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
152
153 return 0;
154
155err:
156 batadv_mesh_free(soft_iface);
157 return ret;
158}
159
160void batadv_mesh_free(struct net_device *soft_iface)
161{
162 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
163
164 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
165
166 batadv_purge_outstanding_packets(bat_priv, NULL);
167
168 batadv_vis_quit(bat_priv);
169
170 batadv_gw_node_purge(bat_priv);
171 batadv_nc_mesh_free(bat_priv);
172 batadv_dat_free(bat_priv);
173 batadv_bla_free(bat_priv);
174
175
176
177
178
179 batadv_tt_free(bat_priv);
180
181
182
183
184
185
186 batadv_originator_free(bat_priv);
187
188 free_percpu(bat_priv->bat_counters);
189 bat_priv->bat_counters = NULL;
190
191 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
192}
193
194
195
196
197
198
199
200int batadv_is_my_mac(struct batadv_priv *bat_priv, const uint8_t *addr)
201{
202 const struct batadv_hard_iface *hard_iface;
203
204 rcu_read_lock();
205 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
206 if (hard_iface->if_status != BATADV_IF_ACTIVE)
207 continue;
208
209 if (hard_iface->soft_iface != bat_priv->soft_iface)
210 continue;
211
212 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
213 rcu_read_unlock();
214 return 1;
215 }
216 }
217 rcu_read_unlock();
218 return 0;
219}
220
221
222
223
224
225
226
227
228struct batadv_hard_iface *
229batadv_seq_print_text_primary_if_get(struct seq_file *seq)
230{
231 struct net_device *net_dev = (struct net_device *)seq->private;
232 struct batadv_priv *bat_priv = netdev_priv(net_dev);
233 struct batadv_hard_iface *primary_if;
234
235 primary_if = batadv_primary_if_get_selected(bat_priv);
236
237 if (!primary_if) {
238 seq_printf(seq,
239 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
240 net_dev->name);
241 goto out;
242 }
243
244 if (primary_if->if_status == BATADV_IF_ACTIVE)
245 goto out;
246
247 seq_printf(seq,
248 "BATMAN mesh %s disabled - primary interface not active\n",
249 net_dev->name);
250 batadv_hardif_free_ref(primary_if);
251 primary_if = NULL;
252
253out:
254 return primary_if;
255}
256
257
258
259
260
261
262
263
264
265void batadv_skb_set_priority(struct sk_buff *skb, int offset)
266{
267 struct iphdr ip_hdr_tmp, *ip_hdr;
268 struct ipv6hdr ip6_hdr_tmp, *ip6_hdr;
269 struct ethhdr ethhdr_tmp, *ethhdr;
270 struct vlan_ethhdr *vhdr, vhdr_tmp;
271 u32 prio;
272
273
274 if (skb->priority >= 256 && skb->priority <= 263)
275 return;
276
277 ethhdr = skb_header_pointer(skb, offset, sizeof(*ethhdr), ðhdr_tmp);
278 if (!ethhdr)
279 return;
280
281 switch (ethhdr->h_proto) {
282 case htons(ETH_P_8021Q):
283 vhdr = skb_header_pointer(skb, offset + sizeof(*vhdr),
284 sizeof(*vhdr), &vhdr_tmp);
285 if (!vhdr)
286 return;
287 prio = ntohs(vhdr->h_vlan_TCI) & VLAN_PRIO_MASK;
288 prio = prio >> VLAN_PRIO_SHIFT;
289 break;
290 case htons(ETH_P_IP):
291 ip_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
292 sizeof(*ip_hdr), &ip_hdr_tmp);
293 if (!ip_hdr)
294 return;
295 prio = (ipv4_get_dsfield(ip_hdr) & 0xfc) >> 5;
296 break;
297 case htons(ETH_P_IPV6):
298 ip6_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
299 sizeof(*ip6_hdr), &ip6_hdr_tmp);
300 if (!ip6_hdr)
301 return;
302 prio = (ipv6_get_dsfield(ip6_hdr) & 0xfc) >> 5;
303 break;
304 default:
305 return;
306 }
307
308 skb->priority = prio + 256;
309}
310
311static int batadv_recv_unhandled_packet(struct sk_buff *skb,
312 struct batadv_hard_iface *recv_if)
313{
314 return NET_RX_DROP;
315}
316
317
318
319
320int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
321 struct packet_type *ptype,
322 struct net_device *orig_dev)
323{
324 struct batadv_priv *bat_priv;
325 struct batadv_ogm_packet *batadv_ogm_packet;
326 struct batadv_hard_iface *hard_iface;
327 uint8_t idx;
328 int ret;
329
330 hard_iface = container_of(ptype, struct batadv_hard_iface,
331 batman_adv_ptype);
332 skb = skb_share_check(skb, GFP_ATOMIC);
333
334
335 if (!skb)
336 goto err_out;
337
338
339 if (unlikely(!pskb_may_pull(skb, 2)))
340 goto err_free;
341
342
343 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
344 goto err_free;
345
346 if (!hard_iface->soft_iface)
347 goto err_free;
348
349 bat_priv = netdev_priv(hard_iface->soft_iface);
350
351 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
352 goto err_free;
353
354
355 if (hard_iface->if_status != BATADV_IF_ACTIVE)
356 goto err_free;
357
358 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
359
360 if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
361 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
362 "Drop packet: incompatible batman version (%i)\n",
363 batadv_ogm_packet->header.version);
364 goto err_free;
365 }
366
367
368
369
370 idx = batadv_ogm_packet->header.packet_type;
371 ret = (*batadv_rx_handler[idx])(skb, hard_iface);
372
373 if (ret == NET_RX_DROP)
374 kfree_skb(skb);
375
376
377
378
379
380 return NET_RX_SUCCESS;
381
382err_free:
383 kfree_skb(skb);
384err_out:
385 return NET_RX_DROP;
386}
387
388static void batadv_recv_handler_init(void)
389{
390 int i;
391
392 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
393 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
394
395
396 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
397
398 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
399
400 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
401
402 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_ucast_frag_packet;
403
404 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
405
406 batadv_rx_handler[BATADV_VIS] = batadv_recv_vis_packet;
407
408 batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query;
409
410 batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv;
411}
412
413int
414batadv_recv_handler_register(uint8_t packet_type,
415 int (*recv_handler)(struct sk_buff *,
416 struct batadv_hard_iface *))
417{
418 if (batadv_rx_handler[packet_type] != &batadv_recv_unhandled_packet)
419 return -EBUSY;
420
421 batadv_rx_handler[packet_type] = recv_handler;
422 return 0;
423}
424
425void batadv_recv_handler_unregister(uint8_t packet_type)
426{
427 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
428}
429
430static struct batadv_algo_ops *batadv_algo_get(char *name)
431{
432 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
433
434 hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
435 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
436 continue;
437
438 bat_algo_ops = bat_algo_ops_tmp;
439 break;
440 }
441
442 return bat_algo_ops;
443}
444
445int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
446{
447 struct batadv_algo_ops *bat_algo_ops_tmp;
448 int ret;
449
450 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
451 if (bat_algo_ops_tmp) {
452 pr_info("Trying to register already registered routing algorithm: %s\n",
453 bat_algo_ops->name);
454 ret = -EEXIST;
455 goto out;
456 }
457
458
459 if (!bat_algo_ops->bat_iface_enable ||
460 !bat_algo_ops->bat_iface_disable ||
461 !bat_algo_ops->bat_iface_update_mac ||
462 !bat_algo_ops->bat_primary_iface_set ||
463 !bat_algo_ops->bat_ogm_schedule ||
464 !bat_algo_ops->bat_ogm_emit) {
465 pr_info("Routing algo '%s' does not implement required ops\n",
466 bat_algo_ops->name);
467 ret = -EINVAL;
468 goto out;
469 }
470
471 INIT_HLIST_NODE(&bat_algo_ops->list);
472 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
473 ret = 0;
474
475out:
476 return ret;
477}
478
479int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
480{
481 struct batadv_algo_ops *bat_algo_ops;
482 int ret = -EINVAL;
483
484 bat_algo_ops = batadv_algo_get(name);
485 if (!bat_algo_ops)
486 goto out;
487
488 bat_priv->bat_algo_ops = bat_algo_ops;
489 ret = 0;
490
491out:
492 return ret;
493}
494
495int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
496{
497 struct batadv_algo_ops *bat_algo_ops;
498
499 seq_puts(seq, "Available routing algorithms:\n");
500
501 hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
502 seq_printf(seq, "%s\n", bat_algo_ops->name);
503 }
504
505 return 0;
506}
507
508
509
510
511
512
513
514
515
516
517
518__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
519{
520 u32 crc = 0;
521 unsigned int from;
522 unsigned int to = skb->len;
523 struct skb_seq_state st;
524 const u8 *data;
525 unsigned int len;
526 unsigned int consumed = 0;
527
528 from = (unsigned int)(payload_ptr - skb->data);
529
530 skb_prepare_seq_read(skb, from, to, &st);
531 while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
532 crc = crc32c(crc, data, len);
533 consumed += len;
534 }
535
536 return htonl(crc);
537}
538
539static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
540{
541 struct batadv_algo_ops *bat_algo_ops;
542 char *algo_name = (char *)val;
543 size_t name_len = strlen(algo_name);
544
545 if (name_len > 0 && algo_name[name_len - 1] == '\n')
546 algo_name[name_len - 1] = '\0';
547
548 bat_algo_ops = batadv_algo_get(algo_name);
549 if (!bat_algo_ops) {
550 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
551 return -EINVAL;
552 }
553
554 return param_set_copystring(algo_name, kp);
555}
556
557static const struct kernel_param_ops batadv_param_ops_ra = {
558 .set = batadv_param_set_ra,
559 .get = param_get_string,
560};
561
562static struct kparam_string batadv_param_string_ra = {
563 .maxlen = sizeof(batadv_routing_algo),
564 .string = batadv_routing_algo,
565};
566
567module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
568 0644);
569module_init(batadv_init);
570module_exit(batadv_exit);
571
572MODULE_LICENSE("GPL");
573
574MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
575MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
576MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
577MODULE_VERSION(BATADV_SOURCE_VERSION);
578