blob: 5f2974bd1227f32301dc607039d3271add649281 [file] [log] [blame]
Sven Eckelmann0046b042016-01-01 00:01:03 +01001/* Copyright (C) 2007-2016 B.A.T.M.A.N. contributors:
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00002 *
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
Antonio Quartulliebf38fb2013-11-03 20:40:48 +010015 * along with this program; if not, see <http://www.gnu.org/licenses/>.
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000016 */
17
18#include "main.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020019
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>
Sven Eckelmannf7157dd2016-01-16 10:29:48 +010032#include <linux/kref.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020033#include <linux/list.h>
Sven Eckelmann2c72d652015-06-21 14:45:14 +020034#include <linux/lockdep.h>
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020035#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"
Sven Eckelmannb706b132012-06-10 23:58:51 +020053#include "debugfs.h"
Sven Eckelmann1e2c2a42015-04-17 19:40:28 +020054#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"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000063#include "routing.h"
64#include "send.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000065#include "soft-interface.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000066#include "translation-table.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000067
Sven Eckelmannc3caf512011-05-03 11:51:38 +020068/* List manipulations on hardif_list have to be rtnl_lock()'ed,
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +020069 * list traversals just rcu-locked
70 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020071struct list_head batadv_hardif_list;
Sven Eckelmannee11ad62012-05-16 20:23:19 +020072static int (*batadv_rx_handler[256])(struct sk_buff *,
Sven Eckelmann56303d32012-06-05 22:31:31 +020073 struct batadv_hard_iface *);
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020074char batadv_routing_algo[20] = "BATMAN_IV";
Sven Eckelmannee11ad62012-05-16 20:23:19 +020075static struct hlist_head batadv_algo_list;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000076
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020077unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000078
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020079struct workqueue_struct *batadv_event_workqueue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000080
Sven Eckelmannee11ad62012-05-16 20:23:19 +020081static void batadv_recv_handler_init(void);
Marek Lindnerffa995e2012-03-01 15:35:17 +080082
Sven Eckelmannee11ad62012-05-16 20:23:19 +020083static int __init batadv_init(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000084{
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020085 INIT_LIST_HEAD(&batadv_hardif_list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +020086 INIT_HLIST_HEAD(&batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +080087
Sven Eckelmannee11ad62012-05-16 20:23:19 +020088 batadv_recv_handler_init();
Marek Lindnerffa995e2012-03-01 15:35:17 +080089
Linus Luessingd6f94d92016-01-16 16:40:09 +080090 batadv_v_init();
Sven Eckelmann81c524f2012-05-12 02:09:22 +020091 batadv_iv_init();
Matthias Schiffer6c519ba2013-09-27 18:03:39 +020092 batadv_nc_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000093
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020094 batadv_event_workqueue = create_singlethread_workqueue("bat_events");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000095
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020096 if (!batadv_event_workqueue)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000097 return -ENOMEM;
98
Sven Eckelmann9039dc72012-05-12 02:09:33 +020099 batadv_socket_init();
Sven Eckelmann40a072d2012-05-12 02:09:23 +0200100 batadv_debugfs_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000101
Sven Eckelmann95638772012-05-12 02:09:31 +0200102 register_netdevice_notifier(&batadv_hard_if_notifier);
Sven Eckelmanna4ac28c2013-02-11 17:10:26 +0800103 rtnl_link_register(&batadv_link_ops);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000104
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100105 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200106 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000107
108 return 0;
109}
110
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200111static void __exit batadv_exit(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000112{
Sven Eckelmann40a072d2012-05-12 02:09:23 +0200113 batadv_debugfs_destroy();
Sven Eckelmanna4ac28c2013-02-11 17:10:26 +0800114 rtnl_link_unregister(&batadv_link_ops);
Sven Eckelmann95638772012-05-12 02:09:31 +0200115 unregister_netdevice_notifier(&batadv_hard_if_notifier);
116 batadv_hardif_remove_interfaces();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000117
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200118 flush_workqueue(batadv_event_workqueue);
119 destroy_workqueue(batadv_event_workqueue);
120 batadv_event_workqueue = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000121
122 rcu_barrier();
123}
124
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200125int batadv_mesh_init(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000126{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200127 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200128 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000129
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000130 spin_lock_init(&bat_priv->forw_bat_list_lock);
131 spin_lock_init(&bat_priv->forw_bcast_list_lock);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200132 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);
Antonio Quartullia70a9aa2013-07-30 22:16:24 +0200136 spin_lock_init(&bat_priv->tt.commit_lock);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200137 spin_lock_init(&bat_priv->gw.list_lock);
Linus Lüssingab498862014-02-15 17:47:53 +0100138#ifdef CONFIG_BATMAN_ADV_MCAST
139 spin_lock_init(&bat_priv->mcast.want_lists_lock);
140#endif
Marek Lindneref261572013-04-23 21:39:57 +0800141 spin_lock_init(&bat_priv->tvlv.container_list_lock);
142 spin_lock_init(&bat_priv->tvlv.handler_list_lock);
Antonio Quartulli5d2c05b2013-07-02 11:04:34 +0200143 spin_lock_init(&bat_priv->softif_vlan_list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000144
145 INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
146 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200147 INIT_HLIST_HEAD(&bat_priv->gw.list);
Linus Lüssingab498862014-02-15 17:47:53 +0100148#ifdef CONFIG_BATMAN_ADV_MCAST
149 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_unsnoopables_list);
Linus Lüssing4c8755d2014-02-15 17:47:54 +0100150 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv4_list);
151 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv6_list);
Linus Lüssingab498862014-02-15 17:47:53 +0100152#endif
Sven Eckelmann807736f2012-07-15 22:26:51 +0200153 INIT_LIST_HEAD(&bat_priv->tt.changes_list);
Marek Lindner7c26a532015-06-28 22:16:06 +0800154 INIT_HLIST_HEAD(&bat_priv->tt.req_list);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200155 INIT_LIST_HEAD(&bat_priv->tt.roam_list);
Linus Lüssingc5caf4e2014-02-15 17:47:49 +0100156#ifdef CONFIG_BATMAN_ADV_MCAST
157 INIT_HLIST_HEAD(&bat_priv->mcast.mla_list);
158#endif
Marek Lindneref261572013-04-23 21:39:57 +0800159 INIT_HLIST_HEAD(&bat_priv->tvlv.container_list);
160 INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list);
Antonio Quartulli5d2c05b2013-07-02 11:04:34 +0200161 INIT_HLIST_HEAD(&bat_priv->softif_vlan_list);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000162
Antonio Quartulli0da00352016-01-16 16:40:12 +0800163 ret = batadv_v_mesh_init(bat_priv);
164 if (ret < 0)
165 goto err;
166
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200167 ret = batadv_originator_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200168 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000169 goto err;
170
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200171 ret = batadv_tt_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200172 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000173 goto err;
174
Sven Eckelmann08adf152012-05-12 13:38:47 +0200175 ret = batadv_bla_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200176 if (ret < 0)
Simon Wunderlich23721382012-01-22 20:00:19 +0100177 goto err;
178
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200179 ret = batadv_dat_init(bat_priv);
180 if (ret < 0)
181 goto err;
182
Matthias Schiffer6c519ba2013-09-27 18:03:39 +0200183 ret = batadv_nc_mesh_init(bat_priv);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100184 if (ret < 0)
185 goto err;
186
Marek Lindner414254e2013-04-23 21:39:58 +0800187 batadv_gw_init(bat_priv);
Linus Lüssing60432d72014-02-15 17:47:51 +0100188 batadv_mcast_init(bat_priv);
Marek Lindner414254e2013-04-23 21:39:58 +0800189
Sven Eckelmann807736f2012-07-15 22:26:51 +0200190 atomic_set(&bat_priv->gw.reselect, 0);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200191 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200192
193 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000194
195err:
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200196 batadv_mesh_free(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200197 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000198}
199
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200200void batadv_mesh_free(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000201{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200202 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000203
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200204 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000205
Sven Eckelmann9455e342012-05-12 02:09:37 +0200206 batadv_purge_outstanding_packets(bat_priv, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000207
Simon Wunderlichbd3524c2015-08-03 19:13:58 +0200208 batadv_gw_node_free(bat_priv);
Antonio Quartulli0da00352016-01-16 16:40:12 +0800209
210 batadv_v_mesh_free(bat_priv);
Matthias Schiffer6c519ba2013-09-27 18:03:39 +0200211 batadv_nc_mesh_free(bat_priv);
Antonio Quartullia4361862013-05-07 01:06:18 +0200212 batadv_dat_free(bat_priv);
Sven Eckelmann08adf152012-05-12 13:38:47 +0200213 batadv_bla_free(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +0100214
Linus Lüssingc5caf4e2014-02-15 17:47:49 +0100215 batadv_mcast_free(bat_priv);
216
Antonio Quartullia4361862013-05-07 01:06:18 +0200217 /* 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);
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200229
Marek Lindner414254e2013-04-23 21:39:58 +0800230 batadv_gw_free(bat_priv);
231
Martin Hundebøllf8214862012-04-20 17:02:45 +0200232 free_percpu(bat_priv->bat_counters);
Martin Hundebøllf69ae772013-04-17 21:13:16 +0200233 bat_priv->bat_counters = NULL;
Martin Hundebøllf8214862012-04-20 17:02:45 +0200234
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200235 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000236}
237
David S. Miller6e0895c2013-04-22 20:32:51 -0400238/**
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
Markus Pargmanne8ad3b12014-12-26 12:41:38 +0100243 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200244 * Return: 'true' if the mac address was found, false otherwise.
David S. Miller6e0895c2013-04-22 20:32:51 -0400245 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200246bool batadv_is_my_mac(struct batadv_priv *bat_priv, const u8 *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000247{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200248 const struct batadv_hard_iface *hard_iface;
Markus Pargmanne8ad3b12014-12-26 12:41:38 +0100249 bool is_my_mac = false;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000250
251 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200252 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200253 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000254 continue;
255
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200256 if (hard_iface->soft_iface != bat_priv->soft_iface)
257 continue;
258
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200259 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
Markus Pargmanne8ad3b12014-12-26 12:41:38 +0100260 is_my_mac = true;
261 break;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000262 }
263 }
264 rcu_read_unlock();
Markus Pargmanne8ad3b12014-12-26 12:41:38 +0100265 return is_my_mac;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000266}
267
Marek Lindner30da63a2012-08-03 17:15:46 +0200268/**
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 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200273 * Return: primary interface if found or NULL otherwise.
Marek Lindner30da63a2012-08-03 17:15:46 +0200274 */
275struct batadv_hard_iface *
276batadv_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);
Sven Eckelmann82047ad2016-01-17 11:01:10 +0100297 batadv_hardif_put(primary_if);
Marek Lindner30da63a2012-08-03 17:15:46 +0200298 primary_if = NULL;
299
300out:
301 return primary_if;
302}
303
Simon Wunderlichc54f38c92013-07-29 17:56:44 +0200304/**
Marek Lindner411d6ed2013-05-08 13:31:59 +0800305 * batadv_max_header_len - calculate maximum encapsulation overhead for a
306 * payload packet
307 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200308 * Return: the maximum encapsulation overhead in bytes.
Marek Lindner411d6ed2013-05-08 13:31:59 +0800309 */
310int 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
Marek Lindner1df0cbd2014-01-15 20:31:18 +0800326 return header_len + ETH_HLEN;
Marek Lindner411d6ed2013-05-08 13:31:59 +0800327}
328
329/**
Simon Wunderlichc54f38c92013-07-29 17:56:44 +0200330 * 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 */
337void 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
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200383static int batadv_recv_unhandled_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200384 struct batadv_hard_iface *recv_if)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800385{
386 return NET_RX_DROP;
387}
388
389/* incoming packets with the batman ethertype received on any active hard
390 * interface
391 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200392int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
393 struct packet_type *ptype,
394 struct net_device *orig_dev)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800395{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200396 struct batadv_priv *bat_priv;
Sven Eckelmann96412692012-06-05 22:31:30 +0200397 struct batadv_ogm_packet *batadv_ogm_packet;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200398 struct batadv_hard_iface *hard_iface;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200399 u8 idx;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800400 int ret;
401
Sven Eckelmann56303d32012-06-05 22:31:31 +0200402 hard_iface = container_of(ptype, struct batadv_hard_iface,
403 batman_adv_ptype);
Sven Eckelmann4fe56e62016-03-05 16:09:17 +0100404
405 /* Prevent processing a packet received on an interface which is getting
406 * shut down otherwise the packet may trigger de-reference errors
407 * further down in the receive path.
408 */
409 if (!kref_get_unless_zero(&hard_iface->refcount))
410 goto err_out;
411
Marek Lindnerffa995e2012-03-01 15:35:17 +0800412 skb = skb_share_check(skb, GFP_ATOMIC);
413
414 /* skb was released by skb_share_check() */
415 if (!skb)
Sven Eckelmann4fe56e62016-03-05 16:09:17 +0100416 goto err_put;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800417
418 /* packet should hold at least type and version */
419 if (unlikely(!pskb_may_pull(skb, 2)))
420 goto err_free;
421
422 /* expect a valid ethernet header here. */
423 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
424 goto err_free;
425
426 if (!hard_iface->soft_iface)
427 goto err_free;
428
429 bat_priv = netdev_priv(hard_iface->soft_iface);
430
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200431 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800432 goto err_free;
433
434 /* discard frames on not active interfaces */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200435 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800436 goto err_free;
437
Sven Eckelmann96412692012-06-05 22:31:30 +0200438 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800439
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100440 if (batadv_ogm_packet->version != BATADV_COMPAT_VERSION) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200441 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200442 "Drop packet: incompatible batman version (%i)\n",
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100443 batadv_ogm_packet->version);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800444 goto err_free;
445 }
446
Martin Hundebølle0d96772014-09-17 08:56:19 +0200447 /* reset control block to avoid left overs from previous users */
448 memset(skb->cb, 0, sizeof(struct batadv_skb_cb));
449
Marek Lindnerffa995e2012-03-01 15:35:17 +0800450 /* all receive handlers return whether they received or reused
451 * the supplied skb. if not, we have to free the skb.
452 */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100453 idx = batadv_ogm_packet->packet_type;
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200454 ret = (*batadv_rx_handler[idx])(skb, hard_iface);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800455
456 if (ret == NET_RX_DROP)
457 kfree_skb(skb);
458
Sven Eckelmann4fe56e62016-03-05 16:09:17 +0100459 batadv_hardif_put(hard_iface);
460
Marek Lindnerffa995e2012-03-01 15:35:17 +0800461 /* return NET_RX_SUCCESS in any case as we
462 * most probably dropped the packet for
463 * routing-logical reasons.
464 */
465 return NET_RX_SUCCESS;
466
467err_free:
468 kfree_skb(skb);
Sven Eckelmann4fe56e62016-03-05 16:09:17 +0100469err_put:
470 batadv_hardif_put(hard_iface);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800471err_out:
472 return NET_RX_DROP;
473}
474
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200475static void batadv_recv_handler_init(void)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800476{
477 int i;
478
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200479 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
480 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800481
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200482 for (i = BATADV_UNICAST_MIN; i <= BATADV_UNICAST_MAX; i++)
483 batadv_rx_handler[i] = batadv_recv_unhandled_unicast_packet;
484
Simon Wunderlich031ace82013-12-17 19:12:12 +0100485 /* compile time checks for sizes */
486 BUILD_BUG_ON(sizeof(struct batadv_bla_claim_dst) != 6);
487 BUILD_BUG_ON(sizeof(struct batadv_ogm_packet) != 24);
488 BUILD_BUG_ON(sizeof(struct batadv_icmp_header) != 20);
489 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet) != 20);
490 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet_rr) != 116);
491 BUILD_BUG_ON(sizeof(struct batadv_unicast_packet) != 10);
492 BUILD_BUG_ON(sizeof(struct batadv_unicast_4addr_packet) != 18);
493 BUILD_BUG_ON(sizeof(struct batadv_frag_packet) != 20);
494 BUILD_BUG_ON(sizeof(struct batadv_bcast_packet) != 14);
495 BUILD_BUG_ON(sizeof(struct batadv_coded_packet) != 46);
496 BUILD_BUG_ON(sizeof(struct batadv_unicast_tvlv_packet) != 20);
497 BUILD_BUG_ON(sizeof(struct batadv_tvlv_hdr) != 4);
498 BUILD_BUG_ON(sizeof(struct batadv_tvlv_gateway_data) != 8);
499 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_vlan_data) != 8);
500 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_change) != 12);
501 BUILD_BUG_ON(sizeof(struct batadv_tvlv_roam_adv) != 8);
Simon Wunderlich80067c82013-04-25 10:37:22 +0200502
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200503 /* broadcast packet */
504 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
505
506 /* unicast packets ... */
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200507 /* unicast with 4 addresses packet */
508 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800509 /* unicast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200510 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
Marek Lindneref261572013-04-23 21:39:57 +0800511 /* unicast tvlv packet */
512 batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv;
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200513 /* batman icmp packet */
514 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200515 /* Fragmented packets */
516 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_frag_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800517}
518
Sven Eckelmann56303d32012-06-05 22:31:31 +0200519int
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200520batadv_recv_handler_register(u8 packet_type,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200521 int (*recv_handler)(struct sk_buff *,
522 struct batadv_hard_iface *))
Marek Lindnerffa995e2012-03-01 15:35:17 +0800523{
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200524 int (*curr)(struct sk_buff *,
525 struct batadv_hard_iface *);
526 curr = batadv_rx_handler[packet_type];
527
528 if ((curr != batadv_recv_unhandled_packet) &&
529 (curr != batadv_recv_unhandled_unicast_packet))
Marek Lindnerffa995e2012-03-01 15:35:17 +0800530 return -EBUSY;
531
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200532 batadv_rx_handler[packet_type] = recv_handler;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800533 return 0;
534}
535
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200536void batadv_recv_handler_unregister(u8 packet_type)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800537{
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200538 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800539}
540
Sven Eckelmann56303d32012-06-05 22:31:31 +0200541static struct batadv_algo_ops *batadv_algo_get(char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800542{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200543 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
Marek Lindner1c280472011-11-28 17:40:17 +0800544
Sasha Levinb67bfe02013-02-27 17:06:00 -0800545 hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800546 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
547 continue;
548
549 bat_algo_ops = bat_algo_ops_tmp;
550 break;
551 }
552
553 return bat_algo_ops;
554}
555
Sven Eckelmann56303d32012-06-05 22:31:31 +0200556int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
Marek Lindner1c280472011-11-28 17:40:17 +0800557{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200558 struct batadv_algo_ops *bat_algo_ops_tmp;
Marek Lindner1c280472011-11-28 17:40:17 +0800559
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200560 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
Marek Lindner1c280472011-11-28 17:40:17 +0800561 if (bat_algo_ops_tmp) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100562 pr_info("Trying to register already registered routing algorithm: %s\n",
563 bat_algo_ops->name);
Markus Pargmann9fb6c652014-12-26 12:41:40 +0100564 return -EEXIST;
Marek Lindner1c280472011-11-28 17:40:17 +0800565 }
566
Marek Lindner01c42242011-11-28 21:31:55 +0800567 /* all algorithms must implement all ops (for now) */
Marek Lindnerc2aca022012-02-07 17:20:45 +0800568 if (!bat_algo_ops->bat_iface_enable ||
Marek Lindner00a50072012-02-07 17:20:47 +0800569 !bat_algo_ops->bat_iface_disable ||
Marek Lindnerc3229392012-03-11 06:17:50 +0800570 !bat_algo_ops->bat_iface_update_mac ||
Marek Lindnercd8b78e2012-02-07 17:20:49 +0800571 !bat_algo_ops->bat_primary_iface_set ||
Marek Lindner01c42242011-11-28 21:31:55 +0800572 !bat_algo_ops->bat_ogm_schedule ||
Antonio Quartullia3285a82013-09-02 12:15:04 +0200573 !bat_algo_ops->bat_ogm_emit ||
Antonio Quartullic43c9812013-09-02 12:15:05 +0200574 !bat_algo_ops->bat_neigh_cmp ||
Simon Wunderlich18165f62015-08-08 02:01:50 +0200575 !bat_algo_ops->bat_neigh_is_similar_or_better) {
Marek Lindner01c42242011-11-28 21:31:55 +0800576 pr_info("Routing algo '%s' does not implement required ops\n",
577 bat_algo_ops->name);
Markus Pargmann9fb6c652014-12-26 12:41:40 +0100578 return -EINVAL;
Marek Lindner01c42242011-11-28 21:31:55 +0800579 }
580
Marek Lindner1c280472011-11-28 17:40:17 +0800581 INIT_HLIST_NODE(&bat_algo_ops->list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200582 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +0800583
Markus Pargmann9fb6c652014-12-26 12:41:40 +0100584 return 0;
Marek Lindner1c280472011-11-28 17:40:17 +0800585}
586
Sven Eckelmann56303d32012-06-05 22:31:31 +0200587int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800588{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200589 struct batadv_algo_ops *bat_algo_ops;
Marek Lindner1c280472011-11-28 17:40:17 +0800590
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200591 bat_algo_ops = batadv_algo_get(name);
Marek Lindner1c280472011-11-28 17:40:17 +0800592 if (!bat_algo_ops)
Markus Pargmannf372d092014-12-26 12:41:41 +0100593 return -EINVAL;
Marek Lindner1c280472011-11-28 17:40:17 +0800594
595 bat_priv->bat_algo_ops = bat_algo_ops;
Marek Lindner1c280472011-11-28 17:40:17 +0800596
Markus Pargmannf372d092014-12-26 12:41:41 +0100597 return 0;
Marek Lindner1c280472011-11-28 17:40:17 +0800598}
599
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200600int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
Marek Lindner1c280472011-11-28 17:40:17 +0800601{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200602 struct batadv_algo_ops *bat_algo_ops;
Marek Lindner1c280472011-11-28 17:40:17 +0800603
Antonio Quartulli0c814652013-03-21 09:23:29 +0100604 seq_puts(seq, "Available routing algorithms:\n");
Marek Lindner1c280472011-11-28 17:40:17 +0800605
Sasha Levinb67bfe02013-02-27 17:06:00 -0800606 hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
Marek Lindner854d2a62015-07-17 22:25:59 +0800607 seq_printf(seq, " * %s\n", bat_algo_ops->name);
Marek Lindner1c280472011-11-28 17:40:17 +0800608 }
609
610 return 0;
611}
612
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200613/**
614 * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in
615 * the header
616 * @skb: skb pointing to fragmented socket buffers
617 * @payload_ptr: Pointer to position inside the head buffer of the skb
618 * marking the start of the data to be CRC'ed
619 *
620 * payload_ptr must always point to an address in the skb head buffer and not to
621 * a fragment.
Sven Eckelmann7afcbbe2015-10-31 12:29:29 +0100622 *
623 * Return: big endian crc32c of the checksummed data
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200624 */
625__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
626{
627 u32 crc = 0;
628 unsigned int from;
629 unsigned int to = skb->len;
630 struct skb_seq_state st;
631 const u8 *data;
632 unsigned int len;
633 unsigned int consumed = 0;
634
635 from = (unsigned int)(payload_ptr - skb->data);
636
637 skb_prepare_seq_read(skb, from, to, &st);
638 while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
639 crc = crc32c(crc, data, len);
640 consumed += len;
641 }
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200642
643 return htonl(crc);
644}
645
Marek Lindneref261572013-04-23 21:39:57 +0800646/**
Sven Eckelmann32836f52016-01-16 10:29:49 +0100647 * batadv_tvlv_handler_release - release tvlv handler from lists and queue for
648 * free after rcu grace period
649 * @ref: kref pointer of the tvlv
650 */
651static void batadv_tvlv_handler_release(struct kref *ref)
652{
653 struct batadv_tvlv_handler *tvlv_handler;
654
655 tvlv_handler = container_of(ref, struct batadv_tvlv_handler, refcount);
656 kfree_rcu(tvlv_handler, rcu);
657}
658
659/**
Sven Eckelmannba610042016-01-17 11:01:19 +0100660 * batadv_tvlv_handler_put - decrement the tvlv container refcounter and
Sven Eckelmann32836f52016-01-16 10:29:49 +0100661 * possibly release it
Marek Lindneref261572013-04-23 21:39:57 +0800662 * @tvlv_handler: the tvlv handler to free
663 */
Sven Eckelmannba610042016-01-17 11:01:19 +0100664static void batadv_tvlv_handler_put(struct batadv_tvlv_handler *tvlv_handler)
Marek Lindneref261572013-04-23 21:39:57 +0800665{
Sven Eckelmann32836f52016-01-16 10:29:49 +0100666 kref_put(&tvlv_handler->refcount, batadv_tvlv_handler_release);
Marek Lindneref261572013-04-23 21:39:57 +0800667}
668
669/**
670 * batadv_tvlv_handler_get - retrieve tvlv handler from the tvlv handler list
671 * based on the provided type and version (both need to match)
672 * @bat_priv: the bat priv with all the soft interface information
673 * @type: tvlv handler type to look for
674 * @version: tvlv handler version to look for
675 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200676 * Return: tvlv handler if found or NULL otherwise.
Marek Lindneref261572013-04-23 21:39:57 +0800677 */
Sven Eckelmann6fc77a52016-03-05 15:56:01 +0100678static struct batadv_tvlv_handler *
679batadv_tvlv_handler_get(struct batadv_priv *bat_priv, u8 type, u8 version)
Marek Lindneref261572013-04-23 21:39:57 +0800680{
681 struct batadv_tvlv_handler *tvlv_handler_tmp, *tvlv_handler = NULL;
682
683 rcu_read_lock();
684 hlist_for_each_entry_rcu(tvlv_handler_tmp,
685 &bat_priv->tvlv.handler_list, list) {
686 if (tvlv_handler_tmp->type != type)
687 continue;
688
689 if (tvlv_handler_tmp->version != version)
690 continue;
691
Sven Eckelmann32836f52016-01-16 10:29:49 +0100692 if (!kref_get_unless_zero(&tvlv_handler_tmp->refcount))
Marek Lindneref261572013-04-23 21:39:57 +0800693 continue;
694
695 tvlv_handler = tvlv_handler_tmp;
696 break;
697 }
698 rcu_read_unlock();
699
700 return tvlv_handler;
701}
702
703/**
Sven Eckelmannf7157dd2016-01-16 10:29:48 +0100704 * batadv_tvlv_container_release - release tvlv from lists and free
705 * @ref: kref pointer of the tvlv
706 */
707static void batadv_tvlv_container_release(struct kref *ref)
708{
709 struct batadv_tvlv_container *tvlv;
710
711 tvlv = container_of(ref, struct batadv_tvlv_container, refcount);
712 kfree(tvlv);
713}
714
715/**
Sven Eckelmann4a131472016-01-17 11:01:20 +0100716 * batadv_tvlv_container_put - decrement the tvlv container refcounter and
Sven Eckelmannf7157dd2016-01-16 10:29:48 +0100717 * possibly release it
Martin Hundebølla0e28772014-07-15 09:41:08 +0200718 * @tvlv: the tvlv container to free
Marek Lindneref261572013-04-23 21:39:57 +0800719 */
Sven Eckelmann4a131472016-01-17 11:01:20 +0100720static void batadv_tvlv_container_put(struct batadv_tvlv_container *tvlv)
Marek Lindneref261572013-04-23 21:39:57 +0800721{
Sven Eckelmannf7157dd2016-01-16 10:29:48 +0100722 kref_put(&tvlv->refcount, batadv_tvlv_container_release);
Marek Lindneref261572013-04-23 21:39:57 +0800723}
724
725/**
726 * batadv_tvlv_container_get - retrieve tvlv container from the tvlv container
727 * list based on the provided type and version (both need to match)
728 * @bat_priv: the bat priv with all the soft interface information
729 * @type: tvlv container type to look for
730 * @version: tvlv container version to look for
731 *
732 * Has to be called with the appropriate locks being acquired
733 * (tvlv.container_list_lock).
734 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200735 * Return: tvlv container if found or NULL otherwise.
Marek Lindneref261572013-04-23 21:39:57 +0800736 */
Sven Eckelmann6fc77a52016-03-05 15:56:01 +0100737static struct batadv_tvlv_container *
738batadv_tvlv_container_get(struct batadv_priv *bat_priv, u8 type, u8 version)
Marek Lindneref261572013-04-23 21:39:57 +0800739{
740 struct batadv_tvlv_container *tvlv_tmp, *tvlv = NULL;
741
Sven Eckelmanndded0692015-12-20 09:04:03 +0100742 lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
743
Marek Lindneref261572013-04-23 21:39:57 +0800744 hlist_for_each_entry(tvlv_tmp, &bat_priv->tvlv.container_list, list) {
745 if (tvlv_tmp->tvlv_hdr.type != type)
746 continue;
747
748 if (tvlv_tmp->tvlv_hdr.version != version)
749 continue;
750
Sven Eckelmannc9dad802016-03-05 16:09:20 +0100751 kref_get(&tvlv_tmp->refcount);
Marek Lindneref261572013-04-23 21:39:57 +0800752 tvlv = tvlv_tmp;
753 break;
754 }
755
756 return tvlv;
757}
758
759/**
760 * batadv_tvlv_container_list_size - calculate the size of the tvlv container
761 * list entries
762 * @bat_priv: the bat priv with all the soft interface information
763 *
764 * Has to be called with the appropriate locks being acquired
765 * (tvlv.container_list_lock).
766 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200767 * Return: size of all currently registered tvlv containers in bytes.
Marek Lindneref261572013-04-23 21:39:57 +0800768 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200769static u16 batadv_tvlv_container_list_size(struct batadv_priv *bat_priv)
Marek Lindneref261572013-04-23 21:39:57 +0800770{
771 struct batadv_tvlv_container *tvlv;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200772 u16 tvlv_len = 0;
Marek Lindneref261572013-04-23 21:39:57 +0800773
Sven Eckelmanndded0692015-12-20 09:04:03 +0100774 lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
775
Marek Lindneref261572013-04-23 21:39:57 +0800776 hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
777 tvlv_len += sizeof(struct batadv_tvlv_hdr);
778 tvlv_len += ntohs(tvlv->tvlv_hdr.len);
779 }
780
781 return tvlv_len;
782}
783
784/**
785 * batadv_tvlv_container_remove - remove tvlv container from the tvlv container
786 * list
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200787 * @bat_priv: the bat priv with all the soft interface information
Marek Lindneref261572013-04-23 21:39:57 +0800788 * @tvlv: the to be removed tvlv container
789 *
790 * Has to be called with the appropriate locks being acquired
791 * (tvlv.container_list_lock).
792 */
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200793static void batadv_tvlv_container_remove(struct batadv_priv *bat_priv,
794 struct batadv_tvlv_container *tvlv)
Marek Lindneref261572013-04-23 21:39:57 +0800795{
Sven Eckelmann008a3742015-11-03 19:20:34 +0100796 lockdep_assert_held(&bat_priv->tvlv.container_list_lock);
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200797
Marek Lindneref261572013-04-23 21:39:57 +0800798 if (!tvlv)
799 return;
800
801 hlist_del(&tvlv->list);
802
803 /* first call to decrement the counter, second call to free */
Sven Eckelmann4a131472016-01-17 11:01:20 +0100804 batadv_tvlv_container_put(tvlv);
805 batadv_tvlv_container_put(tvlv);
Marek Lindneref261572013-04-23 21:39:57 +0800806}
807
808/**
809 * batadv_tvlv_container_unregister - unregister tvlv container based on the
810 * provided type and version (both need to match)
811 * @bat_priv: the bat priv with all the soft interface information
812 * @type: tvlv container type to unregister
813 * @version: tvlv container type to unregister
814 */
815void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200816 u8 type, u8 version)
Marek Lindneref261572013-04-23 21:39:57 +0800817{
818 struct batadv_tvlv_container *tvlv;
819
820 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
821 tvlv = batadv_tvlv_container_get(bat_priv, type, version);
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200822 batadv_tvlv_container_remove(bat_priv, tvlv);
Marek Lindneref261572013-04-23 21:39:57 +0800823 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
824}
825
826/**
827 * batadv_tvlv_container_register - register tvlv type, version and content
828 * to be propagated with each (primary interface) OGM
829 * @bat_priv: the bat priv with all the soft interface information
830 * @type: tvlv container type
831 * @version: tvlv container version
832 * @tvlv_value: tvlv container content
833 * @tvlv_value_len: tvlv container content length
834 *
835 * If a container of the same type and version was already registered the new
836 * content is going to replace the old one.
837 */
838void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200839 u8 type, u8 version,
840 void *tvlv_value, u16 tvlv_value_len)
Marek Lindneref261572013-04-23 21:39:57 +0800841{
842 struct batadv_tvlv_container *tvlv_old, *tvlv_new;
843
844 if (!tvlv_value)
845 tvlv_value_len = 0;
846
847 tvlv_new = kzalloc(sizeof(*tvlv_new) + tvlv_value_len, GFP_ATOMIC);
848 if (!tvlv_new)
849 return;
850
851 tvlv_new->tvlv_hdr.version = version;
852 tvlv_new->tvlv_hdr.type = type;
853 tvlv_new->tvlv_hdr.len = htons(tvlv_value_len);
854
855 memcpy(tvlv_new + 1, tvlv_value, ntohs(tvlv_new->tvlv_hdr.len));
856 INIT_HLIST_NODE(&tvlv_new->list);
Sven Eckelmannf7157dd2016-01-16 10:29:48 +0100857 kref_init(&tvlv_new->refcount);
Marek Lindneref261572013-04-23 21:39:57 +0800858
859 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
860 tvlv_old = batadv_tvlv_container_get(bat_priv, type, version);
Sven Eckelmann2c72d652015-06-21 14:45:14 +0200861 batadv_tvlv_container_remove(bat_priv, tvlv_old);
Marek Lindneref261572013-04-23 21:39:57 +0800862 hlist_add_head(&tvlv_new->list, &bat_priv->tvlv.container_list);
863 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
864}
865
866/**
Antonio Quartulli3f687852014-11-02 11:29:56 +0100867 * batadv_tvlv_realloc_packet_buff - reallocate packet buffer to accommodate
Marek Lindneref261572013-04-23 21:39:57 +0800868 * requested packet size
869 * @packet_buff: packet buffer
870 * @packet_buff_len: packet buffer size
Martin Hundebølla0e28772014-07-15 09:41:08 +0200871 * @min_packet_len: requested packet minimum size
Marek Lindneref261572013-04-23 21:39:57 +0800872 * @additional_packet_len: requested additional packet size on top of minimum
873 * size
874 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200875 * Return: true of the packet buffer could be changed to the requested size,
Marek Lindneref261572013-04-23 21:39:57 +0800876 * false otherwise.
877 */
878static bool batadv_tvlv_realloc_packet_buff(unsigned char **packet_buff,
879 int *packet_buff_len,
880 int min_packet_len,
881 int additional_packet_len)
882{
883 unsigned char *new_buff;
884
885 new_buff = kmalloc(min_packet_len + additional_packet_len, GFP_ATOMIC);
886
887 /* keep old buffer if kmalloc should fail */
Markus Pargmann16b9ce82014-12-26 12:41:23 +0100888 if (!new_buff)
889 return false;
Marek Lindneref261572013-04-23 21:39:57 +0800890
Markus Pargmann16b9ce82014-12-26 12:41:23 +0100891 memcpy(new_buff, *packet_buff, min_packet_len);
892 kfree(*packet_buff);
893 *packet_buff = new_buff;
894 *packet_buff_len = min_packet_len + additional_packet_len;
895
896 return true;
Marek Lindneref261572013-04-23 21:39:57 +0800897}
898
899/**
900 * batadv_tvlv_container_ogm_append - append tvlv container content to given
901 * OGM packet buffer
902 * @bat_priv: the bat priv with all the soft interface information
903 * @packet_buff: ogm packet buffer
904 * @packet_buff_len: ogm packet buffer size including ogm header and tvlv
905 * content
906 * @packet_min_len: ogm header size to be preserved for the OGM itself
907 *
908 * The ogm packet might be enlarged or shrunk depending on the current size
909 * and the size of the to-be-appended tvlv containers.
910 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200911 * Return: size of all appended tvlv containers in bytes.
Marek Lindneref261572013-04-23 21:39:57 +0800912 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200913u16 batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
914 unsigned char **packet_buff,
915 int *packet_buff_len, int packet_min_len)
Marek Lindneref261572013-04-23 21:39:57 +0800916{
917 struct batadv_tvlv_container *tvlv;
918 struct batadv_tvlv_hdr *tvlv_hdr;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200919 u16 tvlv_value_len;
Marek Lindneref261572013-04-23 21:39:57 +0800920 void *tvlv_value;
921 bool ret;
922
923 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
924 tvlv_value_len = batadv_tvlv_container_list_size(bat_priv);
925
926 ret = batadv_tvlv_realloc_packet_buff(packet_buff, packet_buff_len,
927 packet_min_len, tvlv_value_len);
928
929 if (!ret)
930 goto end;
931
932 if (!tvlv_value_len)
933 goto end;
934
935 tvlv_value = (*packet_buff) + packet_min_len;
936
937 hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
938 tvlv_hdr = tvlv_value;
939 tvlv_hdr->type = tvlv->tvlv_hdr.type;
940 tvlv_hdr->version = tvlv->tvlv_hdr.version;
941 tvlv_hdr->len = tvlv->tvlv_hdr.len;
942 tvlv_value = tvlv_hdr + 1;
943 memcpy(tvlv_value, tvlv + 1, ntohs(tvlv->tvlv_hdr.len));
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200944 tvlv_value = (u8 *)tvlv_value + ntohs(tvlv->tvlv_hdr.len);
Marek Lindneref261572013-04-23 21:39:57 +0800945 }
946
947end:
948 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
949 return tvlv_value_len;
950}
951
952/**
953 * batadv_tvlv_call_handler - parse the given tvlv buffer to call the
954 * appropriate handlers
955 * @bat_priv: the bat priv with all the soft interface information
956 * @tvlv_handler: tvlv callback function handling the tvlv content
Sven Eckelmannc05a57f2015-08-26 10:31:51 +0200957 * @ogm_source: flag indicating whether the tvlv is an ogm or a unicast packet
Marek Lindneref261572013-04-23 21:39:57 +0800958 * @orig_node: orig node emitting the ogm packet
959 * @src: source mac address of the unicast packet
960 * @dst: destination mac address of the unicast packet
961 * @tvlv_value: tvlv content
962 * @tvlv_value_len: tvlv content length
963 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +0200964 * Return: success if handler was not found or the return value of the handler
Marek Lindneref261572013-04-23 21:39:57 +0800965 * callback.
966 */
967static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,
968 struct batadv_tvlv_handler *tvlv_handler,
969 bool ogm_source,
970 struct batadv_orig_node *orig_node,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +0200971 u8 *src, u8 *dst,
972 void *tvlv_value, u16 tvlv_value_len)
Marek Lindneref261572013-04-23 21:39:57 +0800973{
974 if (!tvlv_handler)
975 return NET_RX_SUCCESS;
976
977 if (ogm_source) {
978 if (!tvlv_handler->ogm_handler)
979 return NET_RX_SUCCESS;
980
981 if (!orig_node)
982 return NET_RX_SUCCESS;
983
984 tvlv_handler->ogm_handler(bat_priv, orig_node,
985 BATADV_NO_FLAGS,
986 tvlv_value, tvlv_value_len);
987 tvlv_handler->flags |= BATADV_TVLV_HANDLER_OGM_CALLED;
988 } else {
989 if (!src)
990 return NET_RX_SUCCESS;
991
992 if (!dst)
993 return NET_RX_SUCCESS;
994
995 if (!tvlv_handler->unicast_handler)
996 return NET_RX_SUCCESS;
997
998 return tvlv_handler->unicast_handler(bat_priv, src,
999 dst, tvlv_value,
1000 tvlv_value_len);
1001 }
1002
1003 return NET_RX_SUCCESS;
1004}
1005
1006/**
1007 * batadv_tvlv_containers_process - parse the given tvlv buffer to call the
1008 * appropriate handlers
1009 * @bat_priv: the bat priv with all the soft interface information
Sven Eckelmannc05a57f2015-08-26 10:31:51 +02001010 * @ogm_source: flag indicating whether the tvlv is an ogm or a unicast packet
Marek Lindneref261572013-04-23 21:39:57 +08001011 * @orig_node: orig node emitting the ogm packet
1012 * @src: source mac address of the unicast packet
1013 * @dst: destination mac address of the unicast packet
1014 * @tvlv_value: tvlv content
1015 * @tvlv_value_len: tvlv content length
1016 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001017 * Return: success when processing an OGM or the return value of all called
Marek Lindneref261572013-04-23 21:39:57 +08001018 * handler callbacks.
1019 */
1020int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
1021 bool ogm_source,
1022 struct batadv_orig_node *orig_node,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001023 u8 *src, u8 *dst,
1024 void *tvlv_value, u16 tvlv_value_len)
Marek Lindneref261572013-04-23 21:39:57 +08001025{
1026 struct batadv_tvlv_handler *tvlv_handler;
1027 struct batadv_tvlv_hdr *tvlv_hdr;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001028 u16 tvlv_value_cont_len;
1029 u8 cifnotfound = BATADV_TVLV_HANDLER_OGM_CIFNOTFND;
Marek Lindneref261572013-04-23 21:39:57 +08001030 int ret = NET_RX_SUCCESS;
1031
1032 while (tvlv_value_len >= sizeof(*tvlv_hdr)) {
1033 tvlv_hdr = tvlv_value;
1034 tvlv_value_cont_len = ntohs(tvlv_hdr->len);
1035 tvlv_value = tvlv_hdr + 1;
1036 tvlv_value_len -= sizeof(*tvlv_hdr);
1037
1038 if (tvlv_value_cont_len > tvlv_value_len)
1039 break;
1040
1041 tvlv_handler = batadv_tvlv_handler_get(bat_priv,
1042 tvlv_hdr->type,
1043 tvlv_hdr->version);
1044
1045 ret |= batadv_tvlv_call_handler(bat_priv, tvlv_handler,
1046 ogm_source, orig_node,
1047 src, dst, tvlv_value,
1048 tvlv_value_cont_len);
1049 if (tvlv_handler)
Sven Eckelmannba610042016-01-17 11:01:19 +01001050 batadv_tvlv_handler_put(tvlv_handler);
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001051 tvlv_value = (u8 *)tvlv_value + tvlv_value_cont_len;
Marek Lindneref261572013-04-23 21:39:57 +08001052 tvlv_value_len -= tvlv_value_cont_len;
1053 }
1054
1055 if (!ogm_source)
1056 return ret;
1057
1058 rcu_read_lock();
1059 hlist_for_each_entry_rcu(tvlv_handler,
1060 &bat_priv->tvlv.handler_list, list) {
1061 if ((tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) &&
1062 !(tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CALLED))
1063 tvlv_handler->ogm_handler(bat_priv, orig_node,
1064 cifnotfound, NULL, 0);
1065
1066 tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED;
1067 }
1068 rcu_read_unlock();
1069
1070 return NET_RX_SUCCESS;
1071}
1072
1073/**
1074 * batadv_tvlv_ogm_receive - process an incoming ogm and call the appropriate
1075 * handlers
1076 * @bat_priv: the bat priv with all the soft interface information
1077 * @batadv_ogm_packet: ogm packet containing the tvlv containers
1078 * @orig_node: orig node emitting the ogm packet
1079 */
1080void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
1081 struct batadv_ogm_packet *batadv_ogm_packet,
1082 struct batadv_orig_node *orig_node)
1083{
1084 void *tvlv_value;
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001085 u16 tvlv_value_len;
Marek Lindneref261572013-04-23 21:39:57 +08001086
1087 if (!batadv_ogm_packet)
1088 return;
1089
1090 tvlv_value_len = ntohs(batadv_ogm_packet->tvlv_len);
1091 if (!tvlv_value_len)
1092 return;
1093
1094 tvlv_value = batadv_ogm_packet + 1;
1095
1096 batadv_tvlv_containers_process(bat_priv, true, orig_node, NULL, NULL,
1097 tvlv_value, tvlv_value_len);
1098}
1099
1100/**
1101 * batadv_tvlv_handler_register - register tvlv handler based on the provided
1102 * type and version (both need to match) for ogm tvlv payload and/or unicast
1103 * payload
1104 * @bat_priv: the bat priv with all the soft interface information
1105 * @optr: ogm tvlv handler callback function. This function receives the orig
1106 * node, flags and the tvlv content as argument to process.
1107 * @uptr: unicast tvlv handler callback function. This function receives the
1108 * source & destination of the unicast packet as well as the tvlv content
1109 * to process.
1110 * @type: tvlv handler type to be registered
1111 * @version: tvlv handler version to be registered
1112 * @flags: flags to enable or disable TVLV API behavior
1113 */
1114void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
1115 void (*optr)(struct batadv_priv *bat_priv,
1116 struct batadv_orig_node *orig,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001117 u8 flags,
Marek Lindneref261572013-04-23 21:39:57 +08001118 void *tvlv_value,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001119 u16 tvlv_value_len),
Marek Lindneref261572013-04-23 21:39:57 +08001120 int (*uptr)(struct batadv_priv *bat_priv,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001121 u8 *src, u8 *dst,
Marek Lindneref261572013-04-23 21:39:57 +08001122 void *tvlv_value,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001123 u16 tvlv_value_len),
1124 u8 type, u8 version, u8 flags)
Marek Lindneref261572013-04-23 21:39:57 +08001125{
1126 struct batadv_tvlv_handler *tvlv_handler;
1127
1128 tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1129 if (tvlv_handler) {
Sven Eckelmannba610042016-01-17 11:01:19 +01001130 batadv_tvlv_handler_put(tvlv_handler);
Marek Lindneref261572013-04-23 21:39:57 +08001131 return;
1132 }
1133
1134 tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC);
1135 if (!tvlv_handler)
1136 return;
1137
1138 tvlv_handler->ogm_handler = optr;
1139 tvlv_handler->unicast_handler = uptr;
1140 tvlv_handler->type = type;
1141 tvlv_handler->version = version;
1142 tvlv_handler->flags = flags;
Sven Eckelmann32836f52016-01-16 10:29:49 +01001143 kref_init(&tvlv_handler->refcount);
Marek Lindneref261572013-04-23 21:39:57 +08001144 INIT_HLIST_NODE(&tvlv_handler->list);
1145
1146 spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1147 hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list);
1148 spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1149}
1150
1151/**
1152 * batadv_tvlv_handler_unregister - unregister tvlv handler based on the
1153 * provided type and version (both need to match)
1154 * @bat_priv: the bat priv with all the soft interface information
1155 * @type: tvlv handler type to be unregistered
1156 * @version: tvlv handler version to be unregistered
1157 */
1158void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001159 u8 type, u8 version)
Marek Lindneref261572013-04-23 21:39:57 +08001160{
1161 struct batadv_tvlv_handler *tvlv_handler;
1162
1163 tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1164 if (!tvlv_handler)
1165 return;
1166
Sven Eckelmannba610042016-01-17 11:01:19 +01001167 batadv_tvlv_handler_put(tvlv_handler);
Marek Lindneref261572013-04-23 21:39:57 +08001168 spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1169 hlist_del_rcu(&tvlv_handler->list);
1170 spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
Sven Eckelmannba610042016-01-17 11:01:19 +01001171 batadv_tvlv_handler_put(tvlv_handler);
Marek Lindneref261572013-04-23 21:39:57 +08001172}
1173
1174/**
1175 * batadv_tvlv_unicast_send - send a unicast packet with tvlv payload to the
1176 * specified host
1177 * @bat_priv: the bat priv with all the soft interface information
1178 * @src: source mac address of the unicast packet
1179 * @dst: destination mac address of the unicast packet
1180 * @type: tvlv type
1181 * @version: tvlv version
1182 * @tvlv_value: tvlv content
1183 * @tvlv_value_len: tvlv content length
1184 */
Sven Eckelmann6b5e9712015-05-26 18:34:26 +02001185void batadv_tvlv_unicast_send(struct batadv_priv *bat_priv, u8 *src,
1186 u8 *dst, u8 type, u8 version,
1187 void *tvlv_value, u16 tvlv_value_len)
Marek Lindneref261572013-04-23 21:39:57 +08001188{
1189 struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
1190 struct batadv_tvlv_hdr *tvlv_hdr;
1191 struct batadv_orig_node *orig_node;
Markus Elfring8bbb7cb2015-11-15 09:00:42 +01001192 struct sk_buff *skb;
Marek Lindneref261572013-04-23 21:39:57 +08001193 unsigned char *tvlv_buff;
1194 unsigned int tvlv_len;
1195 ssize_t hdr_len = sizeof(*unicast_tvlv_packet);
Marek Lindneref261572013-04-23 21:39:57 +08001196
1197 orig_node = batadv_orig_hash_find(bat_priv, dst);
1198 if (!orig_node)
Markus Elfring8bbb7cb2015-11-15 09:00:42 +01001199 return;
Marek Lindneref261572013-04-23 21:39:57 +08001200
1201 tvlv_len = sizeof(*tvlv_hdr) + tvlv_value_len;
1202
1203 skb = netdev_alloc_skb_ip_align(NULL, ETH_HLEN + hdr_len + tvlv_len);
1204 if (!skb)
1205 goto out;
1206
1207 skb->priority = TC_PRIO_CONTROL;
1208 skb_reserve(skb, ETH_HLEN);
1209 tvlv_buff = skb_put(skb, sizeof(*unicast_tvlv_packet) + tvlv_len);
1210 unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)tvlv_buff;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001211 unicast_tvlv_packet->packet_type = BATADV_UNICAST_TVLV;
1212 unicast_tvlv_packet->version = BATADV_COMPAT_VERSION;
1213 unicast_tvlv_packet->ttl = BATADV_TTL;
Marek Lindneref261572013-04-23 21:39:57 +08001214 unicast_tvlv_packet->reserved = 0;
1215 unicast_tvlv_packet->tvlv_len = htons(tvlv_len);
1216 unicast_tvlv_packet->align = 0;
Antonio Quartulli8fdd0152014-01-22 00:42:11 +01001217 ether_addr_copy(unicast_tvlv_packet->src, src);
1218 ether_addr_copy(unicast_tvlv_packet->dst, dst);
Marek Lindneref261572013-04-23 21:39:57 +08001219
1220 tvlv_buff = (unsigned char *)(unicast_tvlv_packet + 1);
1221 tvlv_hdr = (struct batadv_tvlv_hdr *)tvlv_buff;
1222 tvlv_hdr->version = version;
1223 tvlv_hdr->type = type;
1224 tvlv_hdr->len = htons(tvlv_value_len);
1225 tvlv_buff += sizeof(*tvlv_hdr);
1226 memcpy(tvlv_buff, tvlv_value, tvlv_value_len);
1227
Markus Elfring8bbb7cb2015-11-15 09:00:42 +01001228 if (batadv_send_skb_to_orig(skb, orig_node, NULL) == NET_XMIT_DROP)
Marek Lindneref261572013-04-23 21:39:57 +08001229 kfree_skb(skb);
Markus Elfring8bbb7cb2015-11-15 09:00:42 +01001230out:
Sven Eckelmann5d967312016-01-17 11:01:09 +01001231 batadv_orig_node_put(orig_node);
Marek Lindneref261572013-04-23 21:39:57 +08001232}
1233
Antonio Quartullic018ad32013-06-04 12:11:39 +02001234/**
1235 * batadv_get_vid - extract the VLAN identifier from skb if any
1236 * @skb: the buffer containing the packet
1237 * @header_len: length of the batman header preceding the ethernet header
1238 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001239 * Return: VID with the BATADV_VLAN_HAS_TAG flag when the packet embedded in the
1240 * skb is vlan tagged. Otherwise BATADV_NO_FLAGS.
Antonio Quartullic018ad32013-06-04 12:11:39 +02001241 */
1242unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len)
1243{
1244 struct ethhdr *ethhdr = (struct ethhdr *)(skb->data + header_len);
1245 struct vlan_ethhdr *vhdr;
1246 unsigned short vid;
1247
1248 if (ethhdr->h_proto != htons(ETH_P_8021Q))
1249 return BATADV_NO_FLAGS;
1250
1251 if (!pskb_may_pull(skb, header_len + VLAN_ETH_HLEN))
1252 return BATADV_NO_FLAGS;
1253
1254 vhdr = (struct vlan_ethhdr *)(skb->data + header_len);
1255 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
1256 vid |= BATADV_VLAN_HAS_TAG;
1257
1258 return vid;
1259}
1260
Antonio Quartullieceb22a2013-11-16 12:03:51 +01001261/**
1262 * batadv_vlan_ap_isola_get - return the AP isolation status for the given vlan
1263 * @bat_priv: the bat priv with all the soft interface information
1264 * @vid: the VLAN identifier for which the AP isolation attributed as to be
1265 * looked up
1266 *
Sven Eckelmann62fe7102015-09-15 19:00:48 +02001267 * Return: true if AP isolation is on for the VLAN idenfied by vid, false
Antonio Quartullieceb22a2013-11-16 12:03:51 +01001268 * otherwise
1269 */
1270bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid)
1271{
1272 bool ap_isolation_enabled = false;
1273 struct batadv_softif_vlan *vlan;
1274
1275 /* if the AP isolation is requested on a VLAN, then check for its
1276 * setting in the proper VLAN private data structure
1277 */
1278 vlan = batadv_softif_vlan_get(bat_priv, vid);
1279 if (vlan) {
1280 ap_isolation_enabled = atomic_read(&vlan->ap_isolation);
Sven Eckelmann9c3bf082016-01-17 11:01:21 +01001281 batadv_softif_vlan_put(vlan);
Antonio Quartullieceb22a2013-11-16 12:03:51 +01001282 }
1283
1284 return ap_isolation_enabled;
1285}
1286
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001287static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
Marek Lindnerd419be12011-12-10 19:45:53 +08001288{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001289 struct batadv_algo_ops *bat_algo_ops;
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001290 char *algo_name = (char *)val;
1291 size_t name_len = strlen(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +08001292
Marek Lindner293c9c12013-04-27 16:22:28 +08001293 if (name_len > 0 && algo_name[name_len - 1] == '\n')
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001294 algo_name[name_len - 1] = '\0';
1295
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001296 bat_algo_ops = batadv_algo_get(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +08001297 if (!bat_algo_ops) {
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001298 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +08001299 return -EINVAL;
1300 }
1301
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001302 return param_set_copystring(algo_name, kp);
Marek Lindnerd419be12011-12-10 19:45:53 +08001303}
1304
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001305static const struct kernel_param_ops batadv_param_ops_ra = {
1306 .set = batadv_param_set_ra,
Marek Lindnerd419be12011-12-10 19:45:53 +08001307 .get = param_get_string,
1308};
1309
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001310static struct kparam_string batadv_param_string_ra = {
Sven Eckelmann3193e8f2012-05-12 02:09:42 +02001311 .maxlen = sizeof(batadv_routing_algo),
1312 .string = batadv_routing_algo,
Marek Lindnerd419be12011-12-10 19:45:53 +08001313};
1314
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001315module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
1316 0644);
1317module_init(batadv_init);
1318module_exit(batadv_exit);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001319
1320MODULE_LICENSE("GPL");
1321
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001322MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
1323MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
1324MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
1325MODULE_VERSION(BATADV_SOURCE_VERSION);