~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/batman-adv/main.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.14 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.72 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.143 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.192 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.192 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp