1 /* Copyright (C) 2007-2017 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 "main.h" 19 20 #include <linux/atomic.h> 21 #include <linux/bug.h> 22 #include <linux/byteorder/generic.h> 23 #include <linux/crc32c.h> 24 #include <linux/errno.h> 25 #include <linux/fs.h> 26 #include <linux/genetlink.h> 27 #include <linux/if_ether.h> 28 #include <linux/if_vlan.h> 29 #include <linux/init.h> 30 #include <linux/ip.h> 31 #include <linux/ipv6.h> 32 #include <linux/kernel.h> 33 #include <linux/kref.h> 34 #include <linux/list.h> 35 #include <linux/module.h> 36 #include <linux/netdevice.h> 37 #include <linux/printk.h> 38 #include <linux/rculist.h> 39 #include <linux/rcupdate.h> 40 #include <linux/seq_file.h> 41 #include <linux/skbuff.h> 42 #include <linux/spinlock.h> 43 #include <linux/stddef.h> 44 #include <linux/string.h> 45 #include <linux/workqueue.h> 46 #include <net/dsfield.h> 47 #include <net/rtnetlink.h> 48 #include <uapi/linux/batman_adv.h> 49 50 #include "bat_algo.h" 51 #include "bat_iv_ogm.h" 52 #include "bat_v.h" 53 #include "bridge_loop_avoidance.h" 54 #include "debugfs.h" 55 #include "distributed-arp-table.h" 56 #include "gateway_client.h" 57 #include "gateway_common.h" 58 #include "hard-interface.h" 59 #include "icmp_socket.h" 60 #include "log.h" 61 #include "multicast.h" 62 #include "netlink.h" 63 #include "network-coding.h" 64 #include "originator.h" 65 #include "packet.h" 66 #include "routing.h" 67 #include "send.h" 68 #include "soft-interface.h" 69 #include "tp_meter.h" 70 #include "translation-table.h" 71 72 /* List manipulations on hardif_list have to be rtnl_lock()'ed, 73 * list traversals just rcu-locked 74 */ 75 struct list_head batadv_hardif_list; 76 static int (*batadv_rx_handler[256])(struct sk_buff *skb, 77 struct batadv_hard_iface *recv_if); 78 79 unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 80 81 struct workqueue_struct *batadv_event_workqueue; 82 83 static void batadv_recv_handler_init(void); 84 85 static int __init batadv_init(void) 86 { 87 int ret; 88 89 ret = batadv_tt_cache_init(); 90 if (ret < 0) 91 return ret; 92 93 INIT_LIST_HEAD(&batadv_hardif_list); 94 batadv_algo_init(); 95 96 batadv_recv_handler_init(); 97 98 batadv_v_init(); 99 batadv_iv_init(); 100 batadv_nc_init(); 101 batadv_tp_meter_init(); 102 103 batadv_event_workqueue = create_singlethread_workqueue("bat_events"); 104 if (!batadv_event_workqueue) 105 goto err_create_wq; 106 107 batadv_socket_init(); 108 batadv_debugfs_init(); 109 110 register_netdevice_notifier(&batadv_hard_if_notifier); 111 rtnl_link_register(&batadv_link_ops); 112 batadv_netlink_register(); 113 114 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n", 115 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION); 116 117 return 0; 118 119 err_create_wq: 120 batadv_tt_cache_destroy(); 121 122 return -ENOMEM; 123 } 124 125 static void __exit batadv_exit(void) 126 { 127 batadv_debugfs_destroy(); 128 batadv_netlink_unregister(); 129 rtnl_link_unregister(&batadv_link_ops); 130 unregister_netdevice_notifier(&batadv_hard_if_notifier); 131 batadv_hardif_remove_interfaces(); 132 133 flush_workqueue(batadv_event_workqueue); 134 destroy_workqueue(batadv_event_workqueue); 135 batadv_event_workqueue = NULL; 136 137 rcu_barrier(); 138 139 batadv_tt_cache_destroy(); 140 } 141 142 int batadv_mesh_init(struct net_device *soft_iface) 143 { 144 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 145 int ret; 146 147 spin_lock_init(&bat_priv->forw_bat_list_lock); 148 spin_lock_init(&bat_priv->forw_bcast_list_lock); 149 spin_lock_init(&bat_priv->tt.changes_list_lock); 150 spin_lock_init(&bat_priv->tt.req_list_lock); 151 spin_lock_init(&bat_priv->tt.roam_list_lock); 152 spin_lock_init(&bat_priv->tt.last_changeset_lock); 153 spin_lock_init(&bat_priv->tt.commit_lock); 154 spin_lock_init(&bat_priv->gw.list_lock); 155 #ifdef CONFIG_BATMAN_ADV_MCAST 156 spin_lock_init(&bat_priv->mcast.want_lists_lock); 157 #endif 158 spin_lock_init(&bat_priv->tvlv.container_list_lock); 159 spin_lock_init(&bat_priv->tvlv.handler_list_lock); 160 spin_lock_init(&bat_priv->softif_vlan_list_lock); 161 spin_lock_init(&bat_priv->tp_list_lock); 162 163 INIT_HLIST_HEAD(&bat_priv->forw_bat_list); 164 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list); 165 INIT_HLIST_HEAD(&bat_priv->gw.gateway_list); 166 #ifdef CONFIG_BATMAN_ADV_MCAST 167 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_unsnoopables_list); 168 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv4_list); 169 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv6_list); 170 #endif 171 INIT_LIST_HEAD(&bat_priv->tt.changes_list); 172 INIT_HLIST_HEAD(&bat_priv->tt.req_list); 173 INIT_LIST_HEAD(&bat_priv->tt.roam_list); 174 #ifdef CONFIG_BATMAN_ADV_MCAST 175 INIT_HLIST_HEAD(&bat_priv->mcast.mla_list); 176 #endif 177 INIT_HLIST_HEAD(&bat_priv->tvlv.container_list); 178 INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list); 179 INIT_HLIST_HEAD(&bat_priv->softif_vlan_list); 180 INIT_HLIST_HEAD(&bat_priv->tp_list); 181 182 ret = batadv_v_mesh_init(bat_priv); 183 if (ret < 0) 184 goto err; 185 186 ret = batadv_originator_init(bat_priv); 187 if (ret < 0) 188 goto err; 189 190 ret = batadv_tt_init(bat_priv); 191 if (ret < 0) 192 goto err; 193 194 ret = batadv_bla_init(bat_priv); 195 if (ret < 0) 196 goto err; 197 198 ret = batadv_dat_init(bat_priv); 199 if (ret < 0) 200 goto err; 201 202 ret = batadv_nc_mesh_init(bat_priv); 203 if (ret < 0) 204 goto err; 205 206 batadv_gw_init(bat_priv); 207 batadv_mcast_init(bat_priv); 208 209 atomic_set(&bat_priv->gw.reselect, 0); 210 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE); 211 212 return 0; 213 214 err: 215 batadv_mesh_free(soft_iface); 216 return ret; 217 } 218 219 void batadv_mesh_free(struct net_device *soft_iface) 220 { 221 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 222 223 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING); 224 225 batadv_purge_outstanding_packets(bat_priv, NULL); 226 227 batadv_gw_node_free(bat_priv); 228 229 batadv_v_mesh_free(bat_priv); 230 batadv_nc_mesh_free(bat_priv); 231 batadv_dat_free(bat_priv); 232 batadv_bla_free(bat_priv); 233 234 batadv_mcast_free(bat_priv); 235 236 /* Free the TT and the originator tables only after having terminated 237 * all the other depending components which may use these structures for 238 * their purposes. 239 */ 240 batadv_tt_free(bat_priv); 241 242 /* Since the originator table clean up routine is accessing the TT 243 * tables as well, it has to be invoked after the TT tables have been 244 * freed and marked as empty. This ensures that no cleanup RCU callbacks 245 * accessing the TT data are scheduled for later execution. 246 */ 247 batadv_originator_free(bat_priv); 248 249 batadv_gw_free(bat_priv); 250 251 free_percpu(bat_priv->bat_counters); 252 bat_priv->bat_counters = NULL; 253 254 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE); 255 } 256 257 /** 258 * batadv_is_my_mac - check if the given mac address belongs to any of the real 259 * interfaces in the current mesh 260 * @bat_priv: the bat priv with all the soft interface information 261 * @addr: the address to check 262 * 263 * Return: 'true' if the mac address was found, false otherwise. 264 */ 265 bool batadv_is_my_mac(struct batadv_priv *bat_priv, const u8 *addr) 266 { 267 const struct batadv_hard_iface *hard_iface; 268 bool is_my_mac = false; 269 270 rcu_read_lock(); 271 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 272 if (hard_iface->if_status != BATADV_IF_ACTIVE) 273 continue; 274 275 if (hard_iface->soft_iface != bat_priv->soft_iface) 276 continue; 277 278 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) { 279 is_my_mac = true; 280 break; 281 } 282 } 283 rcu_read_unlock(); 284 return is_my_mac; 285 } 286 287 #ifdef CONFIG_BATMAN_ADV_DEBUGFS 288 /** 289 * batadv_seq_print_text_primary_if_get - called from debugfs table printing 290 * function that requires the primary interface 291 * @seq: debugfs table seq_file struct 292 * 293 * Return: primary interface if found or NULL otherwise. 294 */ 295 struct batadv_hard_iface * 296 batadv_seq_print_text_primary_if_get(struct seq_file *seq) 297 { 298 struct net_device *net_dev = (struct net_device *)seq->private; 299 struct batadv_priv *bat_priv = netdev_priv(net_dev); 300 struct batadv_hard_iface *primary_if; 301 302 primary_if = batadv_primary_if_get_selected(bat_priv); 303 304 if (!primary_if) { 305 seq_printf(seq, 306 "BATMAN mesh %s disabled - please specify interfaces to enable it\n", 307 net_dev->name); 308 goto out; 309 } 310 311 if (primary_if->if_status == BATADV_IF_ACTIVE) 312 goto out; 313 314 seq_printf(seq, 315 "BATMAN mesh %s disabled - primary interface not active\n", 316 net_dev->name); 317 batadv_hardif_put(primary_if); 318 primary_if = NULL; 319 320 out: 321 return primary_if; 322 } 323 #endif 324 325 /** 326 * batadv_max_header_len - calculate maximum encapsulation overhead for a 327 * payload packet 328 * 329 * Return: the maximum encapsulation overhead in bytes. 330 */ 331 int batadv_max_header_len(void) 332 { 333 int header_len = 0; 334 335 header_len = max_t(int, header_len, 336 sizeof(struct batadv_unicast_packet)); 337 header_len = max_t(int, header_len, 338 sizeof(struct batadv_unicast_4addr_packet)); 339 header_len = max_t(int, header_len, 340 sizeof(struct batadv_bcast_packet)); 341 342 #ifdef CONFIG_BATMAN_ADV_NC 343 header_len = max_t(int, header_len, 344 sizeof(struct batadv_coded_packet)); 345 #endif 346 347 return header_len + ETH_HLEN; 348 } 349 350 /** 351 * batadv_skb_set_priority - sets skb priority according to packet content 352 * @skb: the packet to be sent 353 * @offset: offset to the packet content 354 * 355 * This function sets a value between 256 and 263 (802.1d priority), which 356 * can be interpreted by the cfg80211 or other drivers. 357 */ 358 void batadv_skb_set_priority(struct sk_buff *skb, int offset) 359 { 360 struct iphdr ip_hdr_tmp, *ip_hdr; 361 struct ipv6hdr ip6_hdr_tmp, *ip6_hdr; 362 struct ethhdr ethhdr_tmp, *ethhdr; 363 struct vlan_ethhdr *vhdr, vhdr_tmp; 364 u32 prio; 365 366 /* already set, do nothing */ 367 if (skb->priority >= 256 && skb->priority <= 263) 368 return; 369 370 ethhdr = skb_header_pointer(skb, offset, sizeof(*ethhdr), ðhdr_tmp); 371 if (!ethhdr) 372 return; 373 374 switch (ethhdr->h_proto) { 375 case htons(ETH_P_8021Q): 376 vhdr = skb_header_pointer(skb, offset + sizeof(*vhdr), 377 sizeof(*vhdr), &vhdr_tmp); 378 if (!vhdr) 379 return; 380 prio = ntohs(vhdr->h_vlan_TCI) & VLAN_PRIO_MASK; 381 prio = prio >> VLAN_PRIO_SHIFT; 382 break; 383 case htons(ETH_P_IP): 384 ip_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr), 385 sizeof(*ip_hdr), &ip_hdr_tmp); 386 if (!ip_hdr) 387 return; 388 prio = (ipv4_get_dsfield(ip_hdr) & 0xfc) >> 5; 389 break; 390 case htons(ETH_P_IPV6): 391 ip6_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr), 392 sizeof(*ip6_hdr), &ip6_hdr_tmp); 393 if (!ip6_hdr) 394 return; 395 prio = (ipv6_get_dsfield(ip6_hdr) & 0xfc) >> 5; 396 break; 397 default: 398 return; 399 } 400 401 skb->priority = prio + 256; 402 } 403 404 static int batadv_recv_unhandled_packet(struct sk_buff *skb, 405 struct batadv_hard_iface *recv_if) 406 { 407 kfree_skb(skb); 408 409 return NET_RX_DROP; 410 } 411 412 /* incoming packets with the batman ethertype received on any active hard 413 * interface 414 */ 415 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, 416 struct packet_type *ptype, 417 struct net_device *orig_dev) 418 { 419 struct batadv_priv *bat_priv; 420 struct batadv_ogm_packet *batadv_ogm_packet; 421 struct batadv_hard_iface *hard_iface; 422 u8 idx; 423 424 hard_iface = container_of(ptype, struct batadv_hard_iface, 425 batman_adv_ptype); 426 427 /* Prevent processing a packet received on an interface which is getting 428 * shut down otherwise the packet may trigger de-reference errors 429 * further down in the receive path. 430 */ 431 if (!kref_get_unless_zero(&hard_iface->refcount)) 432 goto err_out; 433 434 skb = skb_share_check(skb, GFP_ATOMIC); 435 436 /* skb was released by skb_share_check() */ 437 if (!skb) 438 goto err_put; 439 440 /* packet should hold at least type and version */ 441 if (unlikely(!pskb_may_pull(skb, 2))) 442 goto err_free; 443 444 /* expect a valid ethernet header here. */ 445 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb))) 446 goto err_free; 447 448 if (!hard_iface->soft_iface) 449 goto err_free; 450 451 bat_priv = netdev_priv(hard_iface->soft_iface); 452 453 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) 454 goto err_free; 455 456 /* discard frames on not active interfaces */ 457 if (hard_iface->if_status != BATADV_IF_ACTIVE) 458 goto err_free; 459 460 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data; 461 462 if (batadv_ogm_packet->version != BATADV_COMPAT_VERSION) { 463 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 464 "Drop packet: incompatible batman version (%i)\n", 465 batadv_ogm_packet->version); 466 goto err_free; 467 } 468 469 /* reset control block to avoid left overs from previous users */ 470 memset(skb->cb, 0, sizeof(struct batadv_skb_cb)); 471 472 idx = batadv_ogm_packet->packet_type; 473 (*batadv_rx_handler[idx])(skb, hard_iface); 474 475 batadv_hardif_put(hard_iface); 476 477 /* return NET_RX_SUCCESS in any case as we 478 * most probably dropped the packet for 479 * routing-logical reasons. 480 */ 481 return NET_RX_SUCCESS; 482 483 err_free: 484 kfree_skb(skb); 485 err_put: 486 batadv_hardif_put(hard_iface); 487 err_out: 488 return NET_RX_DROP; 489 } 490 491 static void batadv_recv_handler_init(void) 492 { 493 int i; 494 495 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++) 496 batadv_rx_handler[i] = batadv_recv_unhandled_packet; 497 498 for (i = BATADV_UNICAST_MIN; i <= BATADV_UNICAST_MAX; i++) 499 batadv_rx_handler[i] = batadv_recv_unhandled_unicast_packet; 500 501 /* compile time checks for sizes */ 502 BUILD_BUG_ON(sizeof(struct batadv_bla_claim_dst) != 6); 503 BUILD_BUG_ON(sizeof(struct batadv_ogm_packet) != 24); 504 BUILD_BUG_ON(sizeof(struct batadv_icmp_header) != 20); 505 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet) != 20); 506 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet_rr) != 116); 507 BUILD_BUG_ON(sizeof(struct batadv_unicast_packet) != 10); 508 BUILD_BUG_ON(sizeof(struct batadv_unicast_4addr_packet) != 18); 509 BUILD_BUG_ON(sizeof(struct batadv_frag_packet) != 20); 510 BUILD_BUG_ON(sizeof(struct batadv_bcast_packet) != 14); 511 BUILD_BUG_ON(sizeof(struct batadv_coded_packet) != 46); 512 BUILD_BUG_ON(sizeof(struct batadv_unicast_tvlv_packet) != 20); 513 BUILD_BUG_ON(sizeof(struct batadv_tvlv_hdr) != 4); 514 BUILD_BUG_ON(sizeof(struct batadv_tvlv_gateway_data) != 8); 515 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_vlan_data) != 8); 516 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_change) != 12); 517 BUILD_BUG_ON(sizeof(struct batadv_tvlv_roam_adv) != 8); 518 519 i = FIELD_SIZEOF(struct sk_buff, cb); 520 BUILD_BUG_ON(sizeof(struct batadv_skb_cb) > i); 521 522 /* broadcast packet */ 523 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet; 524 525 /* unicast packets ... */ 526 /* unicast with 4 addresses packet */ 527 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet; 528 /* unicast packet */ 529 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet; 530 /* unicast tvlv packet */ 531 batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv; 532 /* batman icmp packet */ 533 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet; 534 /* Fragmented packets */ 535 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_frag_packet; 536 } 537 538 int 539 batadv_recv_handler_register(u8 packet_type, 540 int (*recv_handler)(struct sk_buff *, 541 struct batadv_hard_iface *)) 542 { 543 int (*curr)(struct sk_buff *skb, 544 struct batadv_hard_iface *recv_if); 545 curr = batadv_rx_handler[packet_type]; 546 547 if (curr != batadv_recv_unhandled_packet && 548 curr != batadv_recv_unhandled_unicast_packet) 549 return -EBUSY; 550 551 batadv_rx_handler[packet_type] = recv_handler; 552 return 0; 553 } 554 555 void batadv_recv_handler_unregister(u8 packet_type) 556 { 557 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet; 558 } 559 560 /** 561 * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in 562 * the header 563 * @skb: skb pointing to fragmented socket buffers 564 * @payload_ptr: Pointer to position inside the head buffer of the skb 565 * marking the start of the data to be CRC'ed 566 * 567 * payload_ptr must always point to an address in the skb head buffer and not to 568 * a fragment. 569 * 570 * Return: big endian crc32c of the checksummed data 571 */ 572 __be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr) 573 { 574 u32 crc = 0; 575 unsigned int from; 576 unsigned int to = skb->len; 577 struct skb_seq_state st; 578 const u8 *data; 579 unsigned int len; 580 unsigned int consumed = 0; 581 582 from = (unsigned int)(payload_ptr - skb->data); 583 584 skb_prepare_seq_read(skb, from, to, &st); 585 while ((len = skb_seq_read(consumed, &data, &st)) != 0) { 586 crc = crc32c(crc, data, len); 587 consumed += len; 588 } 589 590 return htonl(crc); 591 } 592 593 /** 594 * batadv_get_vid - extract the VLAN identifier from skb if any 595 * @skb: the buffer containing the packet 596 * @header_len: length of the batman header preceding the ethernet header 597 * 598 * Return: VID with the BATADV_VLAN_HAS_TAG flag when the packet embedded in the 599 * skb is vlan tagged. Otherwise BATADV_NO_FLAGS. 600 */ 601 unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len) 602 { 603 struct ethhdr *ethhdr = (struct ethhdr *)(skb->data + header_len); 604 struct vlan_ethhdr *vhdr; 605 unsigned short vid; 606 607 if (ethhdr->h_proto != htons(ETH_P_8021Q)) 608 return BATADV_NO_FLAGS; 609 610 if (!pskb_may_pull(skb, header_len + VLAN_ETH_HLEN)) 611 return BATADV_NO_FLAGS; 612 613 vhdr = (struct vlan_ethhdr *)(skb->data + header_len); 614 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK; 615 vid |= BATADV_VLAN_HAS_TAG; 616 617 return vid; 618 } 619 620 /** 621 * batadv_vlan_ap_isola_get - return the AP isolation status for the given vlan 622 * @bat_priv: the bat priv with all the soft interface information 623 * @vid: the VLAN identifier for which the AP isolation attributed as to be 624 * looked up 625 * 626 * Return: true if AP isolation is on for the VLAN idenfied by vid, false 627 * otherwise 628 */ 629 bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid) 630 { 631 bool ap_isolation_enabled = false; 632 struct batadv_softif_vlan *vlan; 633 634 /* if the AP isolation is requested on a VLAN, then check for its 635 * setting in the proper VLAN private data structure 636 */ 637 vlan = batadv_softif_vlan_get(bat_priv, vid); 638 if (vlan) { 639 ap_isolation_enabled = atomic_read(&vlan->ap_isolation); 640 batadv_softif_vlan_put(vlan); 641 } 642 643 return ap_isolation_enabled; 644 } 645 646 module_init(batadv_init); 647 module_exit(batadv_exit); 648 649 MODULE_LICENSE("GPL"); 650 651 MODULE_AUTHOR(BATADV_DRIVER_AUTHOR); 652 MODULE_DESCRIPTION(BATADV_DRIVER_DESC); 653 MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE); 654 MODULE_VERSION(BATADV_SOURCE_VERSION); 655 MODULE_ALIAS_RTNL_LINK("batadv"); 656 MODULE_ALIAS_GENL_FAMILY(BATADV_NL_NAME); 657