net/batman-adv/main.c

   1 /* Copyright (C) 2007-2016  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/if_ether.h>
  27 #include <linux/if_vlan.h>
  28 #include <linux/init.h>
  29 #include <linux/ip.h>
  30 #include <linux/ipv6.h>
  31 #include <linux/kernel.h>
  32 #include <linux/kref.h>
  33 #include <linux/list.h>
  34 #include <linux/lockdep.h>
  35 #include <linux/module.h>
  36 #include <linux/moduleparam.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/pkt_sched.h>
  39 #include <linux/rculist.h>
  40 #include <linux/rcupdate.h>
  41 #include <linux/seq_file.h>
  42 #include <linux/skbuff.h>
  43 #include <linux/slab.h>
  44 #include <linux/spinlock.h>
  45 #include <linux/stddef.h>
  46 #include <linux/string.h>
  47 #include <linux/workqueue.h>
  48 #include <net/dsfield.h>
  49 #include <net/rtnetlink.h>
  50
  51 #include "bat_algo.h"
  52 #include "bridge_loop_avoidance.h"
  53 #include "debugfs.h"
  54 #include "distributed-arp-table.h"
  55 #include "gateway_client.h"
  56 #include "gateway_common.h"
  57 #include "hard-interface.h"
  58 #include "icmp_socket.h"
  59 #include "multicast.h"
  60 #include "network-coding.h"
  61 #include "originator.h"
  62 #include "packet.h"
  63 #include "routing.h"
  64 #include "send.h"
  65 #include "soft-interface.h"
  66 #include "translation-table.h"
  67
  68 /* List manipulations on hardif_list have to be rtnl_lock()'ed,
  69  * list traversals just rcu-locked
  70  */
  71 struct list_head batadv_hardif_list;
  72 static int (*batadv_rx_handler[256])(struct sk_buff *,
  73                                      struct batadv_hard_iface *);
  74 char batadv_routing_algo[20] = "BATMAN_IV";
  75 static struct hlist_head batadv_algo_list;
  76
  77 unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  78
  79 struct workqueue_struct *batadv_event_workqueue;
  80
  81 static void batadv_recv_handler_init(void);
  82
  83 static int __init batadv_init(void)
  84 {
  85         INIT_LIST_HEAD(&batadv_hardif_list);
  86         INIT_HLIST_HEAD(&batadv_algo_list);
  87
  88         batadv_recv_handler_init();
  89
  90         batadv_v_init();
  91         batadv_iv_init();
  92         batadv_nc_init();
  93
  94         batadv_event_workqueue = create_singlethread_workqueue("bat_events");
  95
  96         if (!batadv_event_workqueue)
  97                 return -ENOMEM;
  98
  99         batadv_socket_init();
 100         batadv_debugfs_init();
 101
 102         register_netdevice_notifier(&batadv_hard_if_notifier);
 103         rtnl_link_register(&batadv_link_ops);
 104
 105         pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
 106                 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
 107
 108         return 0;
 109 }
 110
 111 static void __exit batadv_exit(void)
 112 {
 113         batadv_debugfs_destroy();
 114         rtnl_link_unregister(&batadv_link_ops);
 115         unregister_netdevice_notifier(&batadv_hard_if_notifier);
 116         batadv_hardif_remove_interfaces();
 117
 118         flush_workqueue(batadv_event_workqueue);
 119         destroy_workqueue(batadv_event_workqueue);
 120         batadv_event_workqueue = NULL;
 121
 122         rcu_barrier();
 123 }
 124
 125 int batadv_mesh_init(struct net_device *soft_iface)
 126 {
 127         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 128         int ret;
 129
 130         spin_lock_init(&bat_priv->forw_bat_list_lock);
 131         spin_lock_init(&bat_priv->forw_bcast_list_lock);
 132         spin_lock_init(&bat_priv->tt.changes_list_lock);
 133         spin_lock_init(&bat_priv->tt.req_list_lock);
 134         spin_lock_init(&bat_priv->tt.roam_list_lock);
 135         spin_lock_init(&bat_priv->tt.last_changeset_lock);
 136         spin_lock_init(&bat_priv->tt.commit_lock);
 137         spin_lock_init(&bat_priv->gw.list_lock);
 138 #ifdef CONFIG_BATMAN_ADV_MCAST
 139         spin_lock_init(&bat_priv->mcast.want_lists_lock);
 140 #endif
 141         spin_lock_init(&bat_priv->tvlv.container_list_lock);
 142         spin_lock_init(&bat_priv->tvlv.handler_list_lock);
 143         spin_lock_init(&bat_priv->softif_vlan_list_lock);
 144
 145         INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
 146         INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
 147         INIT_HLIST_HEAD(&bat_priv->gw.list);
 148 #ifdef CONFIG_BATMAN_ADV_MCAST
 149         INIT_HLIST_HEAD(&bat_priv->mcast.want_all_unsnoopables_list);
 150         INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv4_list);
 151         INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv6_list);
 152 #endif
 153         INIT_LIST_HEAD(&bat_priv->tt.changes_list);
 154         INIT_HLIST_HEAD(&bat_priv->tt.req_list);
 155         INIT_LIST_HEAD(&bat_priv->tt.roam_list);
 156 #ifdef CONFIG_BATMAN_ADV_MCAST
 157         INIT_HLIST_HEAD(&bat_priv->mcast.mla_list);
 158 #endif
 159         INIT_HLIST_HEAD(&bat_priv->tvlv.container_list);
 160         INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list);
 161         INIT_HLIST_HEAD(&bat_priv->softif_vlan_list);
 162
 163         ret = batadv_v_mesh_init(bat_priv);
 164         if (ret < 0)
 165                 goto err;
 166
 167         ret = batadv_originator_init(bat_priv);
 168         if (ret < 0)
 169                 goto err;
 170
 171         ret = batadv_tt_init(bat_priv);
 172         if (ret < 0)
 173                 goto err;
 174
 175         ret = batadv_bla_init(bat_priv);
 176         if (ret < 0)
 177                 goto err;
 178
 179         ret = batadv_dat_init(bat_priv);
 180         if (ret < 0)
 181                 goto err;
 182
 183         ret = batadv_nc_mesh_init(bat_priv);
 184         if (ret < 0)
 185                 goto err;
 186
 187         batadv_gw_init(bat_priv);
 188         batadv_mcast_init(bat_priv);
 189
 190         atomic_set(&bat_priv->gw.reselect, 0);
 191         atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
 192
 193         return 0;
 194
 195 err:
 196         batadv_mesh_free(soft_iface);
 197         return ret;
 198 }
 199
 200 void batadv_mesh_free(struct net_device *soft_iface)
 201 {
 202         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 203
 204         atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
 205
 206         batadv_purge_outstanding_packets(bat_priv, NULL);
 207
 208         batadv_gw_node_free(bat_priv);
 209
 210         batadv_v_mesh_free(bat_priv);
 211         batadv_nc_mesh_free(bat_priv);
 212         batadv_dat_free(bat_priv);
 213         batadv_bla_free(bat_priv);
 214
 215         batadv_mcast_free(bat_priv);
 216
 217         /* Free the TT and the originator tables only after having terminated
 218          * all the other depending components which may use these structures for
 219          * their purposes.
 220          */
 221         batadv_tt_free(bat_priv);
 222
 223         /* Since the originator table clean up routine is accessing the TT
 224          * tables as well, it has to be invoked after the TT tables have been
 225          * freed and marked as empty. This ensures that no cleanup RCU callbacks
 226          * accessing the TT data are scheduled for later execution.
 227          */
 228         batadv_originator_free(bat_priv);
 229
 230         batadv_gw_free(bat_priv);
 231
 232         free_percpu(bat_priv->bat_counters);
 233         bat_priv->bat_counters = NULL;
 234
 235         atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
 236 }
 237
 238 /**
 239  * batadv_is_my_mac - check if the given mac address belongs to any of the real
 240  * interfaces in the current mesh
 241  * @bat_priv: the bat priv with all the soft interface information
 242  * @addr: the address to check
 243  *
 244  * Return: 'true' if the mac address was found, false otherwise.
 245  */
 246 bool batadv_is_my_mac(struct batadv_priv *bat_priv, const u8 *addr)
 247 {
 248         const struct batadv_hard_iface *hard_iface;
 249         bool is_my_mac = false;
 250
 251         rcu_read_lock();
 252         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
 253                 if (hard_iface->if_status != BATADV_IF_ACTIVE)
 254                         continue;
 255
 256                 if (hard_iface->soft_iface != bat_priv->soft_iface)
 257                         continue;
 258
 259                 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
 260                         is_my_mac = true;
 261                         break;
 262                 }
 263         }
 264         rcu_read_unlock();
 265         return is_my_mac;
 266 }
 267
 268 /**
 269  * batadv_seq_print_text_primary_if_get - called from debugfs table printing
 270  *  function that requires the primary interface
 271  * @seq: debugfs table seq_file struct
 272  *
 273  * Return: primary interface if found or NULL otherwise.
 274  */
 275 struct batadv_hard_iface *
 276 batadv_seq_print_text_primary_if_get(struct seq_file *seq)
 277 {
 278         struct net_device *net_dev = (struct net_device *)seq->private;
 279         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 280         struct batadv_hard_iface *primary_if;
 281
 282         primary_if = batadv_primary_if_get_selected(bat_priv);
 283
 284         if (!primary_if) {
 285                 seq_printf(seq,
 286                            "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
 287                            net_dev->name);
 288                 goto out;
 289         }
 290
 291         if (primary_if->if_status == BATADV_IF_ACTIVE)
 292                 goto out;
 293
 294         seq_printf(seq,
 295                    "BATMAN mesh %s disabled - primary interface not active\n",
 296                    net_dev->name);
 297         batadv_hardif_put(primary_if);
 298         primary_if = NULL;
 299
 300 out:
 301         return primary_if;
 302 }
 303
 304 /**
 305  * batadv_max_header_len - calculate maximum encapsulation overhead for a
 306  *  payload packet
 307  *
 308  * Return: the maximum encapsulation overhead in bytes.
 309  */
 310 int batadv_max_header_len(void)
 311 {
 312         int header_len = 0;
 313
 314         header_len = max_t(int, header_len,
 315                            sizeof(struct batadv_unicast_packet));
 316         header_len = max_t(int, header_len,
 317                            sizeof(struct batadv_unicast_4addr_packet));
 318         header_len = max_t(int, header_len,
 319                            sizeof(struct batadv_bcast_packet));
 320
 321 #ifdef CONFIG_BATMAN_ADV_NC
 322         header_len = max_t(int, header_len,
 323                            sizeof(struct batadv_coded_packet));
 324 #endif
 325
 326         return header_len + ETH_HLEN;
 327 }
 328
 329 /**
 330  * batadv_skb_set_priority - sets skb priority according to packet content
 331  * @skb: the packet to be sent
 332  * @offset: offset to the packet content
 333  *
 334  * This function sets a value between 256 and 263 (802.1d priority), which
 335  * can be interpreted by the cfg80211 or other drivers.
 336  */
 337 void batadv_skb_set_priority(struct sk_buff *skb, int offset)
 338 {
 339         struct iphdr ip_hdr_tmp, *ip_hdr;
 340         struct ipv6hdr ip6_hdr_tmp, *ip6_hdr;
 341         struct ethhdr ethhdr_tmp, *ethhdr;
 342         struct vlan_ethhdr *vhdr, vhdr_tmp;
 343         u32 prio;
 344
 345         /* already set, do nothing */
 346         if (skb->priority >= 256 && skb->priority <= 263)
 347                 return;
 348
 349         ethhdr = skb_header_pointer(skb, offset, sizeof(*ethhdr), &ethhdr_tmp);
 350         if (!ethhdr)
 351                 return;
 352
 353         switch (ethhdr->h_proto) {
 354         case htons(ETH_P_8021Q):
 355                 vhdr = skb_header_pointer(skb, offset + sizeof(*vhdr),
 356                                           sizeof(*vhdr), &vhdr_tmp);
 357                 if (!vhdr)
 358                         return;
 359                 prio = ntohs(vhdr->h_vlan_TCI) & VLAN_PRIO_MASK;
 360                 prio = prio >> VLAN_PRIO_SHIFT;
 361                 break;
 362         case htons(ETH_P_IP):
 363                 ip_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
 364                                             sizeof(*ip_hdr), &ip_hdr_tmp);
 365                 if (!ip_hdr)
 366                         return;
 367                 prio = (ipv4_get_dsfield(ip_hdr) & 0xfc) >> 5;
 368                 break;
 369         case htons(ETH_P_IPV6):
 370                 ip6_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
 371                                              sizeof(*ip6_hdr), &ip6_hdr_tmp);
 372                 if (!ip6_hdr)
 373                         return;
 374                 prio = (ipv6_get_dsfield(ip6_hdr) & 0xfc) >> 5;
 375                 break;
 376         default:
 377                 return;
 378         }
 379
 380         skb->priority = prio + 256;
 381 }
 382
 383 static int batadv_recv_unhandled_packet(struct sk_buff *skb,
 384                                         struct batadv_hard_iface *recv_if)
 385 {
 386         return NET_RX_DROP;
 387 }
 388
 389 /* incoming packets with the batman ethertype received on any active hard
 390  * interface
 391  */
 392 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
 393                            struct packet_type *ptype,
 394                            struct net_device *orig_dev)
 395 {
 396         struct batadv_priv *bat_priv;
 397         struct batadv_ogm_packet *batadv_ogm_packet;
 398         struct batadv_hard_iface *hard_iface;
 399         u8 idx;
 400         int ret;
 401
 402         hard_iface = container_of(ptype, struct batadv_hard_iface,
 403                                   batman_adv_ptype);
 404         skb = skb_share_check(skb, GFP_ATOMIC);
 405
 406         /* skb was released by skb_share_check() */
 407         if (!skb)
 408                 goto err_out;
 409
 410         /* packet should hold at least type and version */
 411         if (unlikely(!pskb_may_pull(skb, 2)))
 412                 goto err_free;
 413
 414         /* expect a valid ethernet header here. */
 415         if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
 416                 goto err_free;
 417
 418         if (!hard_iface->soft_iface)
 419                 goto err_free;
 420
 421         bat_priv = netdev_priv(hard_iface->soft_iface);
 422
 423         if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 424                 goto err_free;
 425
 426         /* discard frames on not active interfaces */
 427         if (hard_iface->if_status != BATADV_IF_ACTIVE)
 428                 goto err_free;
 429
 430         batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
 431
 432         if (batadv_ogm_packet->version != BATADV_COMPAT_VERSION) {
 433                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 434                            "Drop packet: incompatible batman version (%i)\n",
 435                            batadv_ogm_packet->version);
 436                 goto err_free;
 437         }
 438
 439         /* reset control block to avoid left overs from previous users */
 440         memset(skb->cb, 0, sizeof(struct batadv_skb_cb));
 441
 442         /* all receive handlers return whether they received or reused
 443          * the supplied skb. if not, we have to free the skb.
 444          */
 445         idx = batadv_ogm_packet->packet_type;
 446         ret = (*batadv_rx_handler[idx])(skb, hard_iface);
 447
 448         if (ret == NET_RX_DROP)
 449                 kfree_skb(skb);
 450
 451         /* return NET_RX_SUCCESS in any case as we
 452          * most probably dropped the packet for
 453          * routing-logical reasons.
 454          */
 455         return NET_RX_SUCCESS;
 456
 457 err_free:
 458         kfree_skb(skb);
 459 err_out:
 460         return NET_RX_DROP;
 461 }
 462
 463 static void batadv_recv_handler_init(void)
 464 {
 465         int i;
 466
 467         for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
 468                 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
 469
 470         for (i = BATADV_UNICAST_MIN; i <= BATADV_UNICAST_MAX; i++)
 471                 batadv_rx_handler[i] = batadv_recv_unhandled_unicast_packet;
 472
 473         /* compile time checks for sizes */
 474         BUILD_BUG_ON(sizeof(struct batadv_bla_claim_dst) != 6);
 475         BUILD_BUG_ON(sizeof(struct batadv_ogm_packet) != 24);
 476         BUILD_BUG_ON(sizeof(struct batadv_icmp_header) != 20);
 477         BUILD_BUG_ON(sizeof(struct batadv_icmp_packet) != 20);
 478         BUILD_BUG_ON(sizeof(struct batadv_icmp_packet_rr) != 116);
 479         BUILD_BUG_ON(sizeof(struct batadv_unicast_packet) != 10);
 480         BUILD_BUG_ON(sizeof(struct batadv_unicast_4addr_packet) != 18);
 481         BUILD_BUG_ON(sizeof(struct batadv_frag_packet) != 20);
 482         BUILD_BUG_ON(sizeof(struct batadv_bcast_packet) != 14);
 483         BUILD_BUG_ON(sizeof(struct batadv_coded_packet) != 46);
 484         BUILD_BUG_ON(sizeof(struct batadv_unicast_tvlv_packet) != 20);
 485         BUILD_BUG_ON(sizeof(struct batadv_tvlv_hdr) != 4);
 486         BUILD_BUG_ON(sizeof(struct batadv_tvlv_gateway_data) != 8);
 487         BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_vlan_data) != 8);
 488         BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_change) != 12);
 489         BUILD_BUG_ON(sizeof(struct batadv_tvlv_roam_adv) != 8);
 490
 491         /* broadcast packet */
 492         batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
 493
 494         /* unicast packets ... */
 495         /* unicast with 4 addresses packet */
 496         batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
 497         /* unicast packet */
 498         batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
 499         /* unicast tvlv packet */
 500         batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv;
 501         /* batman icmp packet */
 502         batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
 503         /* Fragmented packets */
 504         batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_frag_packet;
 505 }
 506
 507 int
 508 batadv_recv_handler_register(u8 packet_type,
 509                              int (*recv_handler)(struct sk_buff *,
 510                                                  struct batadv_hard_iface *))
 511 {
 512         int (*curr)(struct sk_buff *,
 513                     struct batadv_hard_iface *);
 514         curr = batadv_rx_handler[packet_type];
 515
 516         if ((curr != batadv_recv_unhandled_packet) &&
 517             (curr != batadv_recv_unhandled_unicast_packet))
 518                 return -EBUSY;
 519
 520         batadv_rx_handler[packet_type] = recv_handler;
 521         return 0;
 522 }
 523
 524 void batadv_recv_handler_unregister(u8 packet_type)
 525 {
 526         batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
 527 }
 528
 529 static struct batadv_algo_ops *batadv_algo_get(char *name)
 530 {
 531         struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
 532
 533         hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
 534                 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
 535                         continue;
 536
 537                 bat_algo_ops = bat_algo_ops_tmp;
 538                 break;
 539         }
 540
 541         return bat_algo_ops;
 542 }
 543
 544 int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
 545 {
 546         struct batadv_algo_ops *bat_algo_ops_tmp;
 547
 548         bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
 549         if (bat_algo_ops_tmp) {
 550                 pr_info("Trying to register already registered routing algorithm: %s\n",
 551                         bat_algo_ops->name);
 552                 return -EEXIST;
 553         }
 554
 555         /* all algorithms must implement all ops (for now) */
 556         if (!bat_algo_ops->bat_iface_enable ||
 557             !bat_algo_ops->bat_iface_disable ||
 558             !bat_algo_ops->bat_iface_update_mac ||
 559             !bat_algo_ops->bat_primary_iface_set ||
 560             !bat_algo_ops->bat_ogm_schedule ||
 561             !bat_algo_ops->bat_ogm_emit ||
 562             !bat_algo_ops->bat_neigh_cmp ||
 563             !bat_algo_ops->bat_neigh_is_similar_or_better) {
 564                 pr_info("Routing algo '%s' does not implement required ops\n",
 565                         bat_algo_ops->name);
 566                 return -EINVAL;
 567         }
 568
 569         INIT_HLIST_NODE(&bat_algo_ops->list);
 570         hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
 571
 572         return 0;
 573 }
 574
 575 int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
 576 {
 577         struct batadv_algo_ops *bat_algo_ops;
 578
 579         bat_algo_ops = batadv_algo_get(name);
 580         if (!bat_algo_ops)
 581                 return -EINVAL;
 582
 583         bat_priv->bat_algo_ops = bat_algo_ops;
 584
 585         return 0;
 586 }
 587
 588 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
 589 {
 590         struct batadv_algo_ops *bat_algo_ops;
 591
 592         seq_puts(seq, "Available routing algorithms:\n");
 593
 594         hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
 595                 seq_printf(seq, " * %s\n", bat_algo_ops->name);
 596         }
 597
 598         return 0;
 599 }
 600
 601 /**
 602  * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in
 603  *  the header
 604  * @skb: skb pointing to fragmented socket buffers
 605  * @payload_ptr: Pointer to position inside the head buffer of the skb
 606  *  marking the start of the data to be CRC'ed
 607  *
 608  * payload_ptr must always point to an address in the skb head buffer and not to
 609  * a fragment.
 610  *
 611  * Return: big endian crc32c of the checksummed data
 612  */
 613 __be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
 614 {
 615         u32 crc = 0;
 616         unsigned int from;
 617         unsigned int to = skb->len;
 618         struct skb_seq_state st;
 619         const u8 *data;
 620         unsigned int len;
 621         unsigned int consumed = 0;
 622
 623         from = (unsigned int)(payload_ptr - skb->data);
 624
 625         skb_prepare_seq_read(skb, from, to, &st);
 626         while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
 627                 crc = crc32c(crc, data, len);
 628                 consumed += len;
 629         }
 630
 631         return htonl(crc);
 632 }
 633
 634 /**
 635  * batadv_tvlv_handler_release - release tvlv handler from lists and queue for
 636  *  free after rcu grace period
 637  * @ref: kref pointer of the tvlv
 638  */
 639 static void batadv_tvlv_handler_release(struct kref *ref)
 640 {
 641         struct batadv_tvlv_handler *tvlv_handler;
 642
 643         tvlv_handler = container_of(ref, struct batadv_tvlv_handler, refcount);
 644         kfree_rcu(tvlv_handler, rcu);
 645 }
 646
 647 /**
 648  * batadv_tvlv_handler_put - decrement the tvlv container refcounter and
 649  *  possibly release it
 650  * @tvlv_handler: the tvlv handler to free
 651  */
 652 static void batadv_tvlv_handler_put(struct batadv_tvlv_handler *tvlv_handler)
 653 {
 654         kref_put(&tvlv_handler->refcount, batadv_tvlv_handler_release);
 655 }
 656
 657 /**
 658  * batadv_tvlv_handler_get - retrieve tvlv handler from the tvlv handler list
 659  *  based on the provided type and version (both need to match)
 660  * @bat_priv: the bat priv with all the soft interface information
 661  * @type: tvlv handler type to look for
 662  * @version: tvlv handler version to look for
 663  *
 664  * Return: tvlv handler if found or NULL otherwise.
 665  */
 666 static struct batadv_tvlv_handler
 667 *batadv_tvlv_handler_get(struct batadv_priv *bat_priv, u8 type, u8 version)
 668 {
 669         struct batadv_tvlv_handler *tvlv_handler_tmp, *tvlv_handler = NULL;
 670
 671         rcu_read_lock();
 672         hlist_for_each_entry_rcu(tvlv_handler_tmp,
 673                                  &bat_priv->tvlv.handler_list, list) {
 674                 if (tvlv_handler_tmp->type != type)
 675                         continue;
 676
 677                 if (tvlv_handler_tmp->version != version)
 678                         continue;
 679
 680                 if (!kref_get_unless_zero(&tvlv_handler_tmp->refcount))
 681                         continue;
 682
 683                 tvlv_handler = tvlv_handler_tmp;
 684                 break;
 685         }
 686         rcu_read_unlock();
 687
 688         return tvlv_handler;
 689 }
 690
 691 /**
 692  * batadv_tvlv_container_release - release tvlv from lists and free
 693  * @ref: kref pointer of the tvlv
 694  */
 695 static void batadv_tvlv_container_release(struct kref *ref)
 696 {
 697         struct batadv_tvlv_container *tvlv;
 698
 699         tvlv = container_of(ref, struct batadv_tvlv_container, refcount);
 700         kfree(tvlv);
 701 }
 702
 703 /**
 704  * batadv_tvlv_container_put - decrement the tvlv container refcounter and
 705  *  possibly release it
 706  * @tvlv: the tvlv container to free
 707  */
 708 static void batadv_tvlv_container_put(struct batadv_tvlv_container *tvlv)
 709 {
 710         kref_put(&tvlv->refcount, batadv_tvlv_container_release);
 711 }
 712
 713 /**
 714  * batadv_tvlv_container_get - retrieve tvlv container from the tvlv container
 715  *  list based on the provided type and version (both need to match)
 716  * @bat_priv: the bat priv with all the soft interface information
 717  * @type: tvlv container type to look for
 718  * @version: tvlv container version to look for
 719  *
 720  * Has to be called with the appropriate locks being acquired
 721  * (tvlv.container_list_lock).
 722  *
 723  * Return: tvlv container if found or NULL otherwise.
 724  */
 725 static struct batadv_tvlv_container
 726 *batadv_tvlv_container_get(struct batadv_priv *bat_priv, u8 type, u8 version)
 727 {
 728         struct batadv_tvlv_container *tvlv_tmp, *tvlv = NULL;
 729
 730         lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
 731
 732         hlist_for_each_entry(tvlv_tmp, &bat_priv->tvlv.container_list, list) {
 733                 if (tvlv_tmp->tvlv_hdr.type != type)
 734                         continue;
 735
 736                 if (tvlv_tmp->tvlv_hdr.version != version)
 737                         continue;
 738
 739                 if (!kref_get_unless_zero(&tvlv_tmp->refcount))
 740                         continue;
 741
 742                 tvlv = tvlv_tmp;
 743                 break;
 744         }
 745
 746         return tvlv;
 747 }
 748
 749 /**
 750  * batadv_tvlv_container_list_size - calculate the size of the tvlv container
 751  *  list entries
 752  * @bat_priv: the bat priv with all the soft interface information
 753  *
 754  * Has to be called with the appropriate locks being acquired
 755  * (tvlv.container_list_lock).
 756  *
 757  * Return: size of all currently registered tvlv containers in bytes.
 758  */
 759 static u16 batadv_tvlv_container_list_size(struct batadv_priv *bat_priv)
 760 {
 761         struct batadv_tvlv_container *tvlv;
 762         u16 tvlv_len = 0;
 763
 764         lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
 765
 766         hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
 767                 tvlv_len += sizeof(struct batadv_tvlv_hdr);
 768                 tvlv_len += ntohs(tvlv->tvlv_hdr.len);
 769         }
 770
 771         return tvlv_len;
 772 }
 773
 774 /**
 775  * batadv_tvlv_container_remove - remove tvlv container from the tvlv container
 776  *  list
 777  * @bat_priv: the bat priv with all the soft interface information
 778  * @tvlv: the to be removed tvlv container
 779  *
 780  * Has to be called with the appropriate locks being acquired
 781  * (tvlv.container_list_lock).
 782  */
 783 static void batadv_tvlv_container_remove(struct batadv_priv *bat_priv,
 784                                          struct batadv_tvlv_container *tvlv)
 785 {
 786         lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
 787
 788         if (!tvlv)
 789                 return;
 790
 791         hlist_del(&tvlv->list);
 792
 793         /* first call to decrement the counter, second call to free */
 794         batadv_tvlv_container_put(tvlv);
 795         batadv_tvlv_container_put(tvlv);
 796 }
 797
 798 /**
 799  * batadv_tvlv_container_unregister - unregister tvlv container based on the
 800  *  provided type and version (both need to match)
 801  * @bat_priv: the bat priv with all the soft interface information
 802  * @type: tvlv container type to unregister
 803  * @version: tvlv container type to unregister
 804  */
 805 void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
 806                                       u8 type, u8 version)
 807 {
 808         struct batadv_tvlv_container *tvlv;
 809
 810         spin_lock_bh(&bat_priv->tvlv.container_list_lock);
 811         tvlv = batadv_tvlv_container_get(bat_priv, type, version);
 812         batadv_tvlv_container_remove(bat_priv, tvlv);
 813         spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
 814 }
 815
 816 /**
 817  * batadv_tvlv_container_register - register tvlv type, version and content
 818  *  to be propagated with each (primary interface) OGM
 819  * @bat_priv: the bat priv with all the soft interface information
 820  * @type: tvlv container type
 821  * @version: tvlv container version
 822  * @tvlv_value: tvlv container content
 823  * @tvlv_value_len: tvlv container content length
 824  *
 825  * If a container of the same type and version was already registered the new
 826  * content is going to replace the old one.
 827  */
 828 void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
 829                                     u8 type, u8 version,
 830                                     void *tvlv_value, u16 tvlv_value_len)
 831 {
 832         struct batadv_tvlv_container *tvlv_old, *tvlv_new;
 833
 834         if (!tvlv_value)
 835                 tvlv_value_len = 0;
 836
 837         tvlv_new = kzalloc(sizeof(*tvlv_new) + tvlv_value_len, GFP_ATOMIC);
 838         if (!tvlv_new)
 839                 return;
 840
 841         tvlv_new->tvlv_hdr.version = version;
 842         tvlv_new->tvlv_hdr.type = type;
 843         tvlv_new->tvlv_hdr.len = htons(tvlv_value_len);
 844
 845         memcpy(tvlv_new + 1, tvlv_value, ntohs(tvlv_new->tvlv_hdr.len));
 846         INIT_HLIST_NODE(&tvlv_new->list);
 847         kref_init(&tvlv_new->refcount);
 848
 849         spin_lock_bh(&bat_priv->tvlv.container_list_lock);
 850         tvlv_old = batadv_tvlv_container_get(bat_priv, type, version);
 851         batadv_tvlv_container_remove(bat_priv, tvlv_old);
 852         hlist_add_head(&tvlv_new->list, &bat_priv->tvlv.container_list);
 853         spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
 854 }
 855
 856 /**
 857  * batadv_tvlv_realloc_packet_buff - reallocate packet buffer to accommodate
 858  *  requested packet size
 859  * @packet_buff: packet buffer
 860  * @packet_buff_len: packet buffer size
 861  * @min_packet_len: requested packet minimum size
 862  * @additional_packet_len: requested additional packet size on top of minimum
 863  *  size
 864  *
 865  * Return: true of the packet buffer could be changed to the requested size,
 866  * false otherwise.
 867  */
 868 static bool batadv_tvlv_realloc_packet_buff(unsigned char **packet_buff,
 869                                             int *packet_buff_len,
 870                                             int min_packet_len,
 871                                             int additional_packet_len)
 872 {
 873         unsigned char *new_buff;
 874
 875         new_buff = kmalloc(min_packet_len + additional_packet_len, GFP_ATOMIC);
 876
 877         /* keep old buffer if kmalloc should fail */
 878         if (!new_buff)
 879                 return false;
 880
 881         memcpy(new_buff, *packet_buff, min_packet_len);
 882         kfree(*packet_buff);
 883         *packet_buff = new_buff;
 884         *packet_buff_len = min_packet_len + additional_packet_len;
 885
 886         return true;
 887 }
 888
 889 /**
 890  * batadv_tvlv_container_ogm_append - append tvlv container content to given
 891  *  OGM packet buffer
 892  * @bat_priv: the bat priv with all the soft interface information
 893  * @packet_buff: ogm packet buffer
 894  * @packet_buff_len: ogm packet buffer size including ogm header and tvlv
 895  *  content
 896  * @packet_min_len: ogm header size to be preserved for the OGM itself
 897  *
 898  * The ogm packet might be enlarged or shrunk depending on the current size
 899  * and the size of the to-be-appended tvlv containers.
 900  *
 901  * Return: size of all appended tvlv containers in bytes.
 902  */
 903 u16 batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
 904                                      unsigned char **packet_buff,
 905                                      int *packet_buff_len, int packet_min_len)
 906 {
 907         struct batadv_tvlv_container *tvlv;
 908         struct batadv_tvlv_hdr *tvlv_hdr;
 909         u16 tvlv_value_len;
 910         void *tvlv_value;
 911         bool ret;
 912
 913         spin_lock_bh(&bat_priv->tvlv.container_list_lock);
 914         tvlv_value_len = batadv_tvlv_container_list_size(bat_priv);
 915
 916         ret = batadv_tvlv_realloc_packet_buff(packet_buff, packet_buff_len,
 917                                               packet_min_len, tvlv_value_len);
 918
 919         if (!ret)
 920                 goto end;
 921
 922         if (!tvlv_value_len)
 923                 goto end;
 924
 925         tvlv_value = (*packet_buff) + packet_min_len;
 926
 927         hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
 928                 tvlv_hdr = tvlv_value;
 929                 tvlv_hdr->type = tvlv->tvlv_hdr.type;
 930                 tvlv_hdr->version = tvlv->tvlv_hdr.version;
 931                 tvlv_hdr->len = tvlv->tvlv_hdr.len;
 932                 tvlv_value = tvlv_hdr + 1;
 933                 memcpy(tvlv_value, tvlv + 1, ntohs(tvlv->tvlv_hdr.len));
 934                 tvlv_value = (u8 *)tvlv_value + ntohs(tvlv->tvlv_hdr.len);
 935         }
 936
 937 end:
 938         spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
 939         return tvlv_value_len;
 940 }
 941
 942 /**
 943  * batadv_tvlv_call_handler - parse the given tvlv buffer to call the
 944  *  appropriate handlers
 945  * @bat_priv: the bat priv with all the soft interface information
 946  * @tvlv_handler: tvlv callback function handling the tvlv content
 947  * @ogm_source: flag indicating whether the tvlv is an ogm or a unicast packet
 948  * @orig_node: orig node emitting the ogm packet
 949  * @src: source mac address of the unicast packet
 950  * @dst: destination mac address of the unicast packet
 951  * @tvlv_value: tvlv content
 952  * @tvlv_value_len: tvlv content length
 953  *
 954  * Return: success if handler was not found or the return value of the handler
 955  * callback.
 956  */
 957 static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,
 958                                     struct batadv_tvlv_handler *tvlv_handler,
 959                                     bool ogm_source,
 960                                     struct batadv_orig_node *orig_node,
 961                                     u8 *src, u8 *dst,
 962                                     void *tvlv_value, u16 tvlv_value_len)
 963 {
 964         if (!tvlv_handler)
 965                 return NET_RX_SUCCESS;
 966
 967         if (ogm_source) {
 968                 if (!tvlv_handler->ogm_handler)
 969                         return NET_RX_SUCCESS;
 970
 971                 if (!orig_node)
 972                         return NET_RX_SUCCESS;
 973
 974                 tvlv_handler->ogm_handler(bat_priv, orig_node,
 975                                           BATADV_NO_FLAGS,
 976                                           tvlv_value, tvlv_value_len);
 977                 tvlv_handler->flags |= BATADV_TVLV_HANDLER_OGM_CALLED;
 978         } else {
 979                 if (!src)
 980                         return NET_RX_SUCCESS;
 981
 982                 if (!dst)
 983                         return NET_RX_SUCCESS;
 984
 985                 if (!tvlv_handler->unicast_handler)
 986                         return NET_RX_SUCCESS;
 987
 988                 return tvlv_handler->unicast_handler(bat_priv, src,
 989                                                      dst, tvlv_value,
 990                                                      tvlv_value_len);
 991         }
 992
 993         return NET_RX_SUCCESS;
 994 }
 995
 996 /**
 997  * batadv_tvlv_containers_process - parse the given tvlv buffer to call the
 998  *  appropriate handlers
 999  * @bat_priv: the bat priv with all the soft interface information
1000  * @ogm_source: flag indicating whether the tvlv is an ogm or a unicast packet
1001  * @orig_node: orig node emitting the ogm packet
1002  * @src: source mac address of the unicast packet
1003  * @dst: destination mac address of the unicast packet
1004  * @tvlv_value: tvlv content
1005  * @tvlv_value_len: tvlv content length
1006  *
1007  * Return: success when processing an OGM or the return value of all called
1008  * handler callbacks.
1009  */
1010 int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
1011                                    bool ogm_source,
1012                                    struct batadv_orig_node *orig_node,
1013                                    u8 *src, u8 *dst,
1014                                    void *tvlv_value, u16 tvlv_value_len)
1015 {
1016         struct batadv_tvlv_handler *tvlv_handler;
1017         struct batadv_tvlv_hdr *tvlv_hdr;
1018         u16 tvlv_value_cont_len;
1019         u8 cifnotfound = BATADV_TVLV_HANDLER_OGM_CIFNOTFND;
1020         int ret = NET_RX_SUCCESS;
1021
1022         while (tvlv_value_len >= sizeof(*tvlv_hdr)) {
1023                 tvlv_hdr = tvlv_value;
1024                 tvlv_value_cont_len = ntohs(tvlv_hdr->len);
1025                 tvlv_value = tvlv_hdr + 1;
1026                 tvlv_value_len -= sizeof(*tvlv_hdr);
1027
1028                 if (tvlv_value_cont_len > tvlv_value_len)
1029                         break;
1030
1031                 tvlv_handler = batadv_tvlv_handler_get(bat_priv,
1032                                                        tvlv_hdr->type,
1033                                                        tvlv_hdr->version);
1034
1035                 ret |= batadv_tvlv_call_handler(bat_priv, tvlv_handler,
1036                                                 ogm_source, orig_node,
1037                                                 src, dst, tvlv_value,
1038                                                 tvlv_value_cont_len);
1039                 if (tvlv_handler)
1040                         batadv_tvlv_handler_put(tvlv_handler);
1041                 tvlv_value = (u8 *)tvlv_value + tvlv_value_cont_len;
1042                 tvlv_value_len -= tvlv_value_cont_len;
1043         }
1044
1045         if (!ogm_source)
1046                 return ret;
1047
1048         rcu_read_lock();
1049         hlist_for_each_entry_rcu(tvlv_handler,
1050                                  &bat_priv->tvlv.handler_list, list) {
1051                 if ((tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) &&
1052                     !(tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CALLED))
1053                         tvlv_handler->ogm_handler(bat_priv, orig_node,
1054                                                   cifnotfound, NULL, 0);
1055
1056                 tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED;
1057         }
1058         rcu_read_unlock();
1059
1060         return NET_RX_SUCCESS;
1061 }
1062
1063 /**
1064  * batadv_tvlv_ogm_receive - process an incoming ogm and call the appropriate
1065  *  handlers
1066  * @bat_priv: the bat priv with all the soft interface information
1067  * @batadv_ogm_packet: ogm packet containing the tvlv containers
1068  * @orig_node: orig node emitting the ogm packet
1069  */
1070 void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
1071                              struct batadv_ogm_packet *batadv_ogm_packet,
1072                              struct batadv_orig_node *orig_node)
1073 {
1074         void *tvlv_value;
1075         u16 tvlv_value_len;
1076
1077         if (!batadv_ogm_packet)
1078                 return;
1079
1080         tvlv_value_len = ntohs(batadv_ogm_packet->tvlv_len);
1081         if (!tvlv_value_len)
1082                 return;
1083
1084         tvlv_value = batadv_ogm_packet + 1;
1085
1086         batadv_tvlv_containers_process(bat_priv, true, orig_node, NULL, NULL,
1087                                        tvlv_value, tvlv_value_len);
1088 }
1089
1090 /**
1091  * batadv_tvlv_handler_register - register tvlv handler based on the provided
1092  *  type and version (both need to match) for ogm tvlv payload and/or unicast
1093  *  payload
1094  * @bat_priv: the bat priv with all the soft interface information
1095  * @optr: ogm tvlv handler callback function. This function receives the orig
1096  *  node, flags and the tvlv content as argument to process.
1097  * @uptr: unicast tvlv handler callback function. This function receives the
1098  *  source & destination of the unicast packet as well as the tvlv content
1099  *  to process.
1100  * @type: tvlv handler type to be registered
1101  * @version: tvlv handler version to be registered
1102  * @flags: flags to enable or disable TVLV API behavior
1103  */
1104 void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
1105                                   void (*optr)(struct batadv_priv *bat_priv,
1106                                                struct batadv_orig_node *orig,
1107                                                u8 flags,
1108                                                void *tvlv_value,
1109                                                u16 tvlv_value_len),
1110                                   int (*uptr)(struct batadv_priv *bat_priv,
1111                                               u8 *src, u8 *dst,
1112                                               void *tvlv_value,
1113                                               u16 tvlv_value_len),
1114                                   u8 type, u8 version, u8 flags)
1115 {
1116         struct batadv_tvlv_handler *tvlv_handler;
1117
1118         tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1119         if (tvlv_handler) {
1120                 batadv_tvlv_handler_put(tvlv_handler);
1121                 return;
1122         }
1123
1124         tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC);
1125         if (!tvlv_handler)
1126                 return;
1127
1128         tvlv_handler->ogm_handler = optr;
1129         tvlv_handler->unicast_handler = uptr;
1130         tvlv_handler->type = type;
1131         tvlv_handler->version = version;
1132         tvlv_handler->flags = flags;
1133         kref_init(&tvlv_handler->refcount);
1134         INIT_HLIST_NODE(&tvlv_handler->list);
1135
1136         spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1137         hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list);
1138         spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1139 }
1140
1141 /**
1142  * batadv_tvlv_handler_unregister - unregister tvlv handler based on the
1143  *  provided type and version (both need to match)
1144  * @bat_priv: the bat priv with all the soft interface information
1145  * @type: tvlv handler type to be unregistered
1146  * @version: tvlv handler version to be unregistered
1147  */
1148 void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
1149                                     u8 type, u8 version)
1150 {
1151         struct batadv_tvlv_handler *tvlv_handler;
1152
1153         tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1154         if (!tvlv_handler)
1155                 return;
1156
1157         batadv_tvlv_handler_put(tvlv_handler);
1158         spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1159         hlist_del_rcu(&tvlv_handler->list);
1160         spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1161         batadv_tvlv_handler_put(tvlv_handler);
1162 }
1163
1164 /**
1165  * batadv_tvlv_unicast_send - send a unicast packet with tvlv payload to the
1166  *  specified host
1167  * @bat_priv: the bat priv with all the soft interface information
1168  * @src: source mac address of the unicast packet
1169  * @dst: destination mac address of the unicast packet
1170  * @type: tvlv type
1171  * @version: tvlv version
1172  * @tvlv_value: tvlv content
1173  * @tvlv_value_len: tvlv content length
1174  */
1175 void batadv_tvlv_unicast_send(struct batadv_priv *bat_priv, u8 *src,
1176                               u8 *dst, u8 type, u8 version,
1177                               void *tvlv_value, u16 tvlv_value_len)
1178 {
1179         struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
1180         struct batadv_tvlv_hdr *tvlv_hdr;
1181         struct batadv_orig_node *orig_node;
1182         struct sk_buff *skb;
1183         unsigned char *tvlv_buff;
1184         unsigned int tvlv_len;
1185         ssize_t hdr_len = sizeof(*unicast_tvlv_packet);
1186
1187         orig_node = batadv_orig_hash_find(bat_priv, dst);
1188         if (!orig_node)
1189                 return;
1190
1191         tvlv_len = sizeof(*tvlv_hdr) + tvlv_value_len;
1192
1193         skb = netdev_alloc_skb_ip_align(NULL, ETH_HLEN + hdr_len + tvlv_len);
1194         if (!skb)
1195                 goto out;
1196
1197         skb->priority = TC_PRIO_CONTROL;
1198         skb_reserve(skb, ETH_HLEN);
1199         tvlv_buff = skb_put(skb, sizeof(*unicast_tvlv_packet) + tvlv_len);
1200         unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)tvlv_buff;
1201         unicast_tvlv_packet->packet_type = BATADV_UNICAST_TVLV;
1202         unicast_tvlv_packet->version = BATADV_COMPAT_VERSION;
1203         unicast_tvlv_packet->ttl = BATADV_TTL;
1204         unicast_tvlv_packet->reserved = 0;
1205         unicast_tvlv_packet->tvlv_len = htons(tvlv_len);
1206         unicast_tvlv_packet->align = 0;
1207         ether_addr_copy(unicast_tvlv_packet->src, src);
1208         ether_addr_copy(unicast_tvlv_packet->dst, dst);
1209
1210         tvlv_buff = (unsigned char *)(unicast_tvlv_packet + 1);
1211         tvlv_hdr = (struct batadv_tvlv_hdr *)tvlv_buff;
1212         tvlv_hdr->version = version;
1213         tvlv_hdr->type = type;
1214         tvlv_hdr->len = htons(tvlv_value_len);
1215         tvlv_buff += sizeof(*tvlv_hdr);
1216         memcpy(tvlv_buff, tvlv_value, tvlv_value_len);
1217
1218         if (batadv_send_skb_to_orig(skb, orig_node, NULL) == NET_XMIT_DROP)
1219                 kfree_skb(skb);
1220 out:
1221         batadv_orig_node_put(orig_node);
1222 }
1223
1224 /**
1225  * batadv_get_vid - extract the VLAN identifier from skb if any
1226  * @skb: the buffer containing the packet
1227  * @header_len: length of the batman header preceding the ethernet header
1228  *
1229  * Return: VID with the BATADV_VLAN_HAS_TAG flag when the packet embedded in the
1230  * skb is vlan tagged. Otherwise BATADV_NO_FLAGS.
1231  */
1232 unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len)
1233 {
1234         struct ethhdr *ethhdr = (struct ethhdr *)(skb->data + header_len);
1235         struct vlan_ethhdr *vhdr;
1236         unsigned short vid;
1237
1238         if (ethhdr->h_proto != htons(ETH_P_8021Q))
1239                 return BATADV_NO_FLAGS;
1240
1241         if (!pskb_may_pull(skb, header_len + VLAN_ETH_HLEN))
1242                 return BATADV_NO_FLAGS;
1243
1244         vhdr = (struct vlan_ethhdr *)(skb->data + header_len);
1245         vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
1246         vid |= BATADV_VLAN_HAS_TAG;
1247
1248         return vid;
1249 }
1250
1251 /**
1252  * batadv_vlan_ap_isola_get - return the AP isolation status for the given vlan
1253  * @bat_priv: the bat priv with all the soft interface information
1254  * @vid: the VLAN identifier for which the AP isolation attributed as to be
1255  *  looked up
1256  *
1257  * Return: true if AP isolation is on for the VLAN idenfied by vid, false
1258  * otherwise
1259  */
1260 bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid)
1261 {
1262         bool ap_isolation_enabled = false;
1263         struct batadv_softif_vlan *vlan;
1264
1265         /* if the AP isolation is requested on a VLAN, then check for its
1266          * setting in the proper VLAN private data structure
1267          */
1268         vlan = batadv_softif_vlan_get(bat_priv, vid);
1269         if (vlan) {
1270                 ap_isolation_enabled = atomic_read(&vlan->ap_isolation);
1271                 batadv_softif_vlan_put(vlan);
1272         }
1273
1274         return ap_isolation_enabled;
1275 }
1276
1277 static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
1278 {
1279         struct batadv_algo_ops *bat_algo_ops;
1280         char *algo_name = (char *)val;
1281         size_t name_len = strlen(algo_name);
1282
1283         if (name_len > 0 && algo_name[name_len - 1] == '\n')
1284                 algo_name[name_len - 1] = '\0';
1285
1286         bat_algo_ops = batadv_algo_get(algo_name);
1287         if (!bat_algo_ops) {
1288                 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
1289                 return -EINVAL;
1290         }
1291
1292         return param_set_copystring(algo_name, kp);
1293 }
1294
1295 static const struct kernel_param_ops batadv_param_ops_ra = {
1296         .set = batadv_param_set_ra,
1297         .get = param_get_string,
1298 };
1299
1300 static struct kparam_string batadv_param_string_ra = {
1301         .maxlen = sizeof(batadv_routing_algo),
1302         .string = batadv_routing_algo,
1303 };
1304
1305 module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
1306                 0644);
1307 module_init(batadv_init);
1308 module_exit(batadv_exit);
1309
1310 MODULE_LICENSE("GPL");
1311
1312 MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
1313 MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
1314 MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
1315 MODULE_VERSION(BATADV_SOURCE_VERSION);