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