1/* Copyright (C) 2007-2014 B.A.T.M.A.N. contributors: 2 * 3 * Marek Lindner, Simon Wunderlich 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of version 2 of the GNU General Public 7 * License as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, see <http://www.gnu.org/licenses/>. 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/* List manipulations on hardif_list have to be rtnl_lock()'ed, 45 * list traversals just rcu-locked 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 /* Free the TT and the originator tables only after having terminated 187 * all the other depending components which may use these structures for 188 * their purposes. 189 */ 190 batadv_tt_free(bat_priv); 191 192 /* Since the originator table clean up routine is accessing the TT 193 * tables as well, it has to be invoked after the TT tables have been 194 * freed and marked as empty. This ensures that no cleanup RCU callbacks 195 * accessing the TT data are scheduled for later execution. 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 * batadv_is_my_mac - check if the given mac address belongs to any of the real 209 * interfaces in the current mesh 210 * @bat_priv: the bat priv with all the soft interface information 211 * @addr: the address to check 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 * batadv_seq_print_text_primary_if_get - called from debugfs table printing 236 * function that requires the primary interface 237 * @seq: debugfs table seq_file struct 238 * 239 * Returns primary interface if found or NULL otherwise. 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 * batadv_max_header_len - calculate maximum encapsulation overhead for a 272 * payload packet 273 * 274 * Return the maximum encapsulation overhead in bytes. 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 * batadv_skb_set_priority - sets skb priority according to packet content 297 * @skb: the packet to be sent 298 * @offset: offset to the packet content 299 * 300 * This function sets a value between 256 and 263 (802.1d priority), which 301 * can be interpreted by the cfg80211 or other drivers. 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 /* already set, do nothing */ 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/* incoming packets with the batman ethertype received on any active hard 356 * interface 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 /* skb was released by skb_share_check() */ 373 if (!skb) 374 goto err_out; 375 376 /* packet should hold at least type and version */ 377 if (unlikely(!pskb_may_pull(skb, 2))) 378 goto err_free; 379 380 /* expect a valid ethernet header here. */ 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 /* discard frames on not active interfaces */ 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 /* reset control block to avoid left overs from previous users */ 406 memset(skb->cb, 0, sizeof(struct batadv_skb_cb)); 407 408 /* all receive handlers return whether they received or reused 409 * the supplied skb. if not, we have to free the skb. 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 /* return NET_RX_SUCCESS in any case as we 418 * most probably dropped the packet for 419 * routing-logical reasons. 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 /* compile time checks for sizes */ 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 /* broadcast packet */ 458 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet; 459 460 /* unicast packets ... */ 461 /* unicast with 4 addresses packet */ 462 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet; 463 /* unicast packet */ 464 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet; 465 /* unicast tvlv packet */ 466 batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv; 467 /* batman icmp packet */ 468 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet; 469 /* Fragmented packets */ 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 /* all algorithms must implement all ops (for now) */ 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 * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in 577 * the header 578 * @skb: skb pointing to fragmented socket buffers 579 * @payload_ptr: Pointer to position inside the head buffer of the skb 580 * marking the start of the data to be CRC'ed 581 * 582 * payload_ptr must always point to an address in the skb head buffer and not to 583 * a fragment. 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 * batadv_tvlv_handler_free_ref - decrement the tvlv handler refcounter and 608 * possibly free it 609 * @tvlv_handler: the tvlv handler to free 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 * batadv_tvlv_handler_get - retrieve tvlv handler from the tvlv handler list 620 * based on the provided type and version (both need to match) 621 * @bat_priv: the bat priv with all the soft interface information 622 * @type: tvlv handler type to look for 623 * @version: tvlv handler version to look for 624 * 625 * Returns tvlv handler if found or NULL otherwise. 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 * batadv_tvlv_container_free_ref - decrement the tvlv container refcounter and 655 * possibly free it 656 * @tvlv: the tvlv container to free 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 * batadv_tvlv_container_get - retrieve tvlv container from the tvlv container 666 * list based on the provided type and version (both need to match) 667 * @bat_priv: the bat priv with all the soft interface information 668 * @type: tvlv container type to look for 669 * @version: tvlv container version to look for 670 * 671 * Has to be called with the appropriate locks being acquired 672 * (tvlv.container_list_lock). 673 * 674 * Returns tvlv container if found or NULL otherwise. 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 * batadv_tvlv_container_list_size - calculate the size of the tvlv container 701 * list entries 702 * @bat_priv: the bat priv with all the soft interface information 703 * 704 * Has to be called with the appropriate locks being acquired 705 * (tvlv.container_list_lock). 706 * 707 * Returns size of all currently registered tvlv containers in bytes. 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 * batadv_tvlv_container_remove - remove tvlv container from the tvlv container 724 * list 725 * @tvlv: the to be removed tvlv container 726 * 727 * Has to be called with the appropriate locks being acquired 728 * (tvlv.container_list_lock). 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 /* first call to decrement the counter, second call to free */ 738 batadv_tvlv_container_free_ref(tvlv); 739 batadv_tvlv_container_free_ref(tvlv); 740} 741 742/** 743 * batadv_tvlv_container_unregister - unregister tvlv container based on the 744 * provided type and version (both need to match) 745 * @bat_priv: the bat priv with all the soft interface information 746 * @type: tvlv container type to unregister 747 * @version: tvlv container type to unregister 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 * batadv_tvlv_container_register - register tvlv type, version and content 762 * to be propagated with each (primary interface) OGM 763 * @bat_priv: the bat priv with all the soft interface information 764 * @type: tvlv container type 765 * @version: tvlv container version 766 * @tvlv_value: tvlv container content 767 * @tvlv_value_len: tvlv container content length 768 * 769 * If a container of the same type and version was already registered the new 770 * content is going to replace the old one. 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 * batadv_tvlv_realloc_packet_buff - reallocate packet buffer to accommodate 802 * requested packet size 803 * @packet_buff: packet buffer 804 * @packet_buff_len: packet buffer size 805 * @min_packet_len: requested packet minimum size 806 * @additional_packet_len: requested additional packet size on top of minimum 807 * size 808 * 809 * Returns true of the packet buffer could be changed to the requested size, 810 * false otherwise. 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 /* keep old buffer if kmalloc should fail */ 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 * batadv_tvlv_container_ogm_append - append tvlv container content to given 835 * OGM packet buffer 836 * @bat_priv: the bat priv with all the soft interface information 837 * @packet_buff: ogm packet buffer 838 * @packet_buff_len: ogm packet buffer size including ogm header and tvlv 839 * content 840 * @packet_min_len: ogm header size to be preserved for the OGM itself 841 * 842 * The ogm packet might be enlarged or shrunk depending on the current size 843 * and the size of the to-be-appended tvlv containers. 844 * 845 * Returns size of all appended tvlv containers in bytes. 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 * batadv_tvlv_call_handler - parse the given tvlv buffer to call the 889 * appropriate handlers 890 * @bat_priv: the bat priv with all the soft interface information 891 * @tvlv_handler: tvlv callback function handling the tvlv content 892 * @ogm_source: flag indicating wether the tvlv is an ogm or a unicast packet 893 * @orig_node: orig node emitting the ogm packet 894 * @src: source mac address of the unicast packet 895 * @dst: destination mac address of the unicast packet 896 * @tvlv_value: tvlv content 897 * @tvlv_value_len: tvlv content length 898 * 899 * Returns success if handler was not found or the return value of the handler 900 * callback. 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 * batadv_tvlv_containers_process - parse the given tvlv buffer to call the 943 * appropriate handlers 944 * @bat_priv: the bat priv with all the soft interface information 945 * @ogm_source: flag indicating wether the tvlv is an ogm or a unicast packet 946 * @orig_node: orig node emitting the ogm packet 947 * @src: source mac address of the unicast packet 948 * @dst: destination mac address of the unicast packet 949 * @tvlv_value: tvlv content 950 * @tvlv_value_len: tvlv content length 951 * 952 * Returns success when processing an OGM or the return value of all called 953 * handler callbacks. 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 * batadv_tvlv_ogm_receive - process an incoming ogm and call the appropriate 1010 * handlers 1011 * @bat_priv: the bat priv with all the soft interface information 1012 * @batadv_ogm_packet: ogm packet containing the tvlv containers 1013 * @orig_node: orig node emitting the ogm packet 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 * batadv_tvlv_handler_register - register tvlv handler based on the provided 1037 * type and version (both need to match) for ogm tvlv payload and/or unicast 1038 * payload 1039 * @bat_priv: the bat priv with all the soft interface information 1040 * @optr: ogm tvlv handler callback function. This function receives the orig 1041 * node, flags and the tvlv content as argument to process. 1042 * @uptr: unicast tvlv handler callback function. This function receives the 1043 * source & destination of the unicast packet as well as the tvlv content 1044 * to process. 1045 * @type: tvlv handler type to be registered 1046 * @version: tvlv handler version to be registered 1047 * @flags: flags to enable or disable TVLV API behavior 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 * batadv_tvlv_handler_unregister - unregister tvlv handler based on the 1088 * provided type and version (both need to match) 1089 * @bat_priv: the bat priv with all the soft interface information 1090 * @type: tvlv handler type to be unregistered 1091 * @version: tvlv handler version to be unregistered 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 * batadv_tvlv_unicast_send - send a unicast packet with tvlv payload to the 1111 * specified host 1112 * @bat_priv: the bat priv with all the soft interface information 1113 * @src: source mac address of the unicast packet 1114 * @dst: destination mac address of the unicast packet 1115 * @type: tvlv type 1116 * @version: tvlv version 1117 * @tvlv_value: tvlv content 1118 * @tvlv_value_len: tvlv content length 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 * batadv_get_vid - extract the VLAN identifier from skb if any 1176 * @skb: the buffer containing the packet 1177 * @header_len: length of the batman header preceding the ethernet header 1178 * 1179 * If the packet embedded in the skb is vlan tagged this function returns the 1180 * VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS is returned. 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 * batadv_vlan_ap_isola_get - return the AP isolation status for the given vlan 1203 * @bat_priv: the bat priv with all the soft interface information 1204 * @vid: the VLAN identifier for which the AP isolation attributed as to be 1205 * looked up 1206 * 1207 * Returns true if AP isolation is on for the VLAN idenfied by vid, false 1208 * otherwise 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 /* if the AP isolation is requested on a VLAN, then check for its 1216 * setting in the proper VLAN private data structure 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