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