blob: 66ae135b9f273abdea581f2fc8eaa5ecb74254f0 [file] [log] [blame]
Simon Wunderliche19f9752014-01-04 18:04:25 +01001/* Copyright (C) 2007-2014 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
Sven Eckelmann95a066d2012-10-17 21:10:39 +020018#include <linux/crc32c.h>
19#include <linux/highmem.h>
Simon Wunderlichc54f38c2013-07-29 17:56:44 +020020#include <linux/if_vlan.h>
21#include <net/ip.h>
22#include <net/ipv6.h>
23#include <net/dsfield.h>
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000024#include "main.h"
Sven Eckelmannb706b132012-06-10 23:58:51 +020025#include "sysfs.h"
26#include "debugfs.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000027#include "routing.h"
28#include "send.h"
29#include "originator.h"
30#include "soft-interface.h"
31#include "icmp_socket.h"
32#include "translation-table.h"
33#include "hard-interface.h"
34#include "gateway_client.h"
Simon Wunderlich23721382012-01-22 20:00:19 +010035#include "bridge_loop_avoidance.h"
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +020036#include "distributed-arp-table.h"
Marek Lindner414254e2013-04-23 21:39:58 +080037#include "gateway_common.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000038#include "hash.h"
Marek Lindner1c280472011-11-28 17:40:17 +080039#include "bat_algo.h"
Martin Hundebølld353d8d2013-01-25 11:12:38 +010040#include "network-coding.h"
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +020041#include "fragmentation.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000042
Sven Eckelmannc3caf512011-05-03 11:51:38 +020043
44/* List manipulations on hardif_list have to be rtnl_lock()'ed,
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +020045 * list traversals just rcu-locked
46 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020047struct list_head batadv_hardif_list;
Sven Eckelmannee11ad62012-05-16 20:23:19 +020048static int (*batadv_rx_handler[256])(struct sk_buff *,
Sven Eckelmann56303d32012-06-05 22:31:31 +020049 struct batadv_hard_iface *);
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020050char batadv_routing_algo[20] = "BATMAN_IV";
Sven Eckelmannee11ad62012-05-16 20:23:19 +020051static struct hlist_head batadv_algo_list;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000052
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020053unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000054
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020055struct workqueue_struct *batadv_event_workqueue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000056
Sven Eckelmannee11ad62012-05-16 20:23:19 +020057static void batadv_recv_handler_init(void);
Marek Lindnerffa995e2012-03-01 15:35:17 +080058
Sven Eckelmannee11ad62012-05-16 20:23:19 +020059static int __init batadv_init(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000060{
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020061 INIT_LIST_HEAD(&batadv_hardif_list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +020062 INIT_HLIST_HEAD(&batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +080063
Sven Eckelmannee11ad62012-05-16 20:23:19 +020064 batadv_recv_handler_init();
Marek Lindnerffa995e2012-03-01 15:35:17 +080065
Sven Eckelmann81c524f2012-05-12 02:09:22 +020066 batadv_iv_init();
Matthias Schiffer6c519ba2013-09-27 18:03:39 +020067 batadv_nc_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000068
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020069 batadv_event_workqueue = create_singlethread_workqueue("bat_events");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000070
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020071 if (!batadv_event_workqueue)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000072 return -ENOMEM;
73
Sven Eckelmann9039dc72012-05-12 02:09:33 +020074 batadv_socket_init();
Sven Eckelmann40a072d2012-05-12 02:09:23 +020075 batadv_debugfs_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000076
Sven Eckelmann95638772012-05-12 02:09:31 +020077 register_netdevice_notifier(&batadv_hard_if_notifier);
Sven Eckelmanna4ac28c2013-02-11 17:10:26 +080078 rtnl_link_register(&batadv_link_ops);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000079
Sven Eckelmann86ceb362012-03-07 09:07:45 +010080 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
Sven Eckelmann42d0b042012-06-03 22:19:17 +020081 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000082
83 return 0;
84}
85
Sven Eckelmannee11ad62012-05-16 20:23:19 +020086static void __exit batadv_exit(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000087{
Sven Eckelmann40a072d2012-05-12 02:09:23 +020088 batadv_debugfs_destroy();
Sven Eckelmanna4ac28c2013-02-11 17:10:26 +080089 rtnl_link_unregister(&batadv_link_ops);
Sven Eckelmann95638772012-05-12 02:09:31 +020090 unregister_netdevice_notifier(&batadv_hard_if_notifier);
91 batadv_hardif_remove_interfaces();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000092
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020093 flush_workqueue(batadv_event_workqueue);
94 destroy_workqueue(batadv_event_workqueue);
95 batadv_event_workqueue = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000096
97 rcu_barrier();
98}
99
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200100int batadv_mesh_init(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000101{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200102 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200103 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000104
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000105 spin_lock_init(&bat_priv->forw_bat_list_lock);
106 spin_lock_init(&bat_priv->forw_bcast_list_lock);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200107 spin_lock_init(&bat_priv->tt.changes_list_lock);
108 spin_lock_init(&bat_priv->tt.req_list_lock);
109 spin_lock_init(&bat_priv->tt.roam_list_lock);
110 spin_lock_init(&bat_priv->tt.last_changeset_lock);
Antonio Quartullia70a9aa2013-07-30 22:16:24 +0200111 spin_lock_init(&bat_priv->tt.commit_lock);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200112 spin_lock_init(&bat_priv->gw.list_lock);
Marek Lindneref261572013-04-23 21:39:57 +0800113 spin_lock_init(&bat_priv->tvlv.container_list_lock);
114 spin_lock_init(&bat_priv->tvlv.handler_list_lock);
Antonio Quartulli5d2c05b2013-07-02 11:04:34 +0200115 spin_lock_init(&bat_priv->softif_vlan_list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000116
117 INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
118 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200119 INIT_HLIST_HEAD(&bat_priv->gw.list);
120 INIT_LIST_HEAD(&bat_priv->tt.changes_list);
121 INIT_LIST_HEAD(&bat_priv->tt.req_list);
122 INIT_LIST_HEAD(&bat_priv->tt.roam_list);
Marek Lindneref261572013-04-23 21:39:57 +0800123 INIT_HLIST_HEAD(&bat_priv->tvlv.container_list);
124 INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list);
Antonio Quartulli5d2c05b2013-07-02 11:04:34 +0200125 INIT_HLIST_HEAD(&bat_priv->softif_vlan_list);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000126
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200127 ret = batadv_originator_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200128 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000129 goto err;
130
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200131 ret = batadv_tt_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200132 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000133 goto err;
134
Sven Eckelmann08adf152012-05-12 13:38:47 +0200135 ret = batadv_bla_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200136 if (ret < 0)
Simon Wunderlich23721382012-01-22 20:00:19 +0100137 goto err;
138
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200139 ret = batadv_dat_init(bat_priv);
140 if (ret < 0)
141 goto err;
142
Matthias Schiffer6c519ba2013-09-27 18:03:39 +0200143 ret = batadv_nc_mesh_init(bat_priv);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100144 if (ret < 0)
145 goto err;
146
Marek Lindner414254e2013-04-23 21:39:58 +0800147 batadv_gw_init(bat_priv);
148
Sven Eckelmann807736f2012-07-15 22:26:51 +0200149 atomic_set(&bat_priv->gw.reselect, 0);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200150 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200151
152 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000153
154err:
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200155 batadv_mesh_free(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200156 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000157}
158
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200159void batadv_mesh_free(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000160{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200161 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000162
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200163 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000164
Sven Eckelmann9455e342012-05-12 02:09:37 +0200165 batadv_purge_outstanding_packets(bat_priv, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000166
Sven Eckelmann7cf06bc2012-05-12 02:09:29 +0200167 batadv_gw_node_purge(bat_priv);
Matthias Schiffer6c519ba2013-09-27 18:03:39 +0200168 batadv_nc_mesh_free(bat_priv);
Antonio Quartullia4361862013-05-07 01:06:18 +0200169 batadv_dat_free(bat_priv);
Sven Eckelmann08adf152012-05-12 13:38:47 +0200170 batadv_bla_free(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +0100171
Antonio Quartullia4361862013-05-07 01:06:18 +0200172 /* Free the TT and the originator tables only after having terminated
173 * all the other depending components which may use these structures for
174 * their purposes.
175 */
176 batadv_tt_free(bat_priv);
177
178 /* Since the originator table clean up routine is accessing the TT
179 * tables as well, it has to be invoked after the TT tables have been
180 * freed and marked as empty. This ensures that no cleanup RCU callbacks
181 * accessing the TT data are scheduled for later execution.
182 */
183 batadv_originator_free(bat_priv);
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200184
Marek Lindner414254e2013-04-23 21:39:58 +0800185 batadv_gw_free(bat_priv);
186
Martin Hundebøllf8214862012-04-20 17:02:45 +0200187 free_percpu(bat_priv->bat_counters);
Martin Hundebøllf69ae772013-04-17 21:13:16 +0200188 bat_priv->bat_counters = NULL;
Martin Hundebøllf8214862012-04-20 17:02:45 +0200189
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200190 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000191}
192
David S. Miller6e0895c2013-04-22 20:32:51 -0400193/**
194 * batadv_is_my_mac - check if the given mac address belongs to any of the real
195 * interfaces in the current mesh
196 * @bat_priv: the bat priv with all the soft interface information
197 * @addr: the address to check
198 */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200199int batadv_is_my_mac(struct batadv_priv *bat_priv, const uint8_t *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000200{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200201 const struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000202
203 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200204 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200205 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000206 continue;
207
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200208 if (hard_iface->soft_iface != bat_priv->soft_iface)
209 continue;
210
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200211 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000212 rcu_read_unlock();
213 return 1;
214 }
215 }
216 rcu_read_unlock();
217 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000218}
219
Marek Lindner30da63a2012-08-03 17:15:46 +0200220/**
221 * batadv_seq_print_text_primary_if_get - called from debugfs table printing
222 * function that requires the primary interface
223 * @seq: debugfs table seq_file struct
224 *
225 * Returns primary interface if found or NULL otherwise.
226 */
227struct batadv_hard_iface *
228batadv_seq_print_text_primary_if_get(struct seq_file *seq)
229{
230 struct net_device *net_dev = (struct net_device *)seq->private;
231 struct batadv_priv *bat_priv = netdev_priv(net_dev);
232 struct batadv_hard_iface *primary_if;
233
234 primary_if = batadv_primary_if_get_selected(bat_priv);
235
236 if (!primary_if) {
237 seq_printf(seq,
238 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
239 net_dev->name);
240 goto out;
241 }
242
243 if (primary_if->if_status == BATADV_IF_ACTIVE)
244 goto out;
245
246 seq_printf(seq,
247 "BATMAN mesh %s disabled - primary interface not active\n",
248 net_dev->name);
249 batadv_hardif_free_ref(primary_if);
250 primary_if = NULL;
251
252out:
253 return primary_if;
254}
255
Simon Wunderlichc54f38c2013-07-29 17:56:44 +0200256/**
Marek Lindner411d6ed2013-05-08 13:31:59 +0800257 * batadv_max_header_len - calculate maximum encapsulation overhead for a
258 * payload packet
259 *
260 * Return the maximum encapsulation overhead in bytes.
261 */
262int batadv_max_header_len(void)
263{
264 int header_len = 0;
265
266 header_len = max_t(int, header_len,
267 sizeof(struct batadv_unicast_packet));
268 header_len = max_t(int, header_len,
269 sizeof(struct batadv_unicast_4addr_packet));
270 header_len = max_t(int, header_len,
271 sizeof(struct batadv_bcast_packet));
272
273#ifdef CONFIG_BATMAN_ADV_NC
274 header_len = max_t(int, header_len,
275 sizeof(struct batadv_coded_packet));
276#endif
277
Marek Lindner1df0cbd2014-01-15 20:31:18 +0800278 return header_len + ETH_HLEN;
Marek Lindner411d6ed2013-05-08 13:31:59 +0800279}
280
281/**
Simon Wunderlichc54f38c2013-07-29 17:56:44 +0200282 * batadv_skb_set_priority - sets skb priority according to packet content
283 * @skb: the packet to be sent
284 * @offset: offset to the packet content
285 *
286 * This function sets a value between 256 and 263 (802.1d priority), which
287 * can be interpreted by the cfg80211 or other drivers.
288 */
289void batadv_skb_set_priority(struct sk_buff *skb, int offset)
290{
291 struct iphdr ip_hdr_tmp, *ip_hdr;
292 struct ipv6hdr ip6_hdr_tmp, *ip6_hdr;
293 struct ethhdr ethhdr_tmp, *ethhdr;
294 struct vlan_ethhdr *vhdr, vhdr_tmp;
295 u32 prio;
296
297 /* already set, do nothing */
298 if (skb->priority >= 256 && skb->priority <= 263)
299 return;
300
301 ethhdr = skb_header_pointer(skb, offset, sizeof(*ethhdr), &ethhdr_tmp);
302 if (!ethhdr)
303 return;
304
305 switch (ethhdr->h_proto) {
306 case htons(ETH_P_8021Q):
307 vhdr = skb_header_pointer(skb, offset + sizeof(*vhdr),
308 sizeof(*vhdr), &vhdr_tmp);
309 if (!vhdr)
310 return;
311 prio = ntohs(vhdr->h_vlan_TCI) & VLAN_PRIO_MASK;
312 prio = prio >> VLAN_PRIO_SHIFT;
313 break;
314 case htons(ETH_P_IP):
315 ip_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
316 sizeof(*ip_hdr), &ip_hdr_tmp);
317 if (!ip_hdr)
318 return;
319 prio = (ipv4_get_dsfield(ip_hdr) & 0xfc) >> 5;
320 break;
321 case htons(ETH_P_IPV6):
322 ip6_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr),
323 sizeof(*ip6_hdr), &ip6_hdr_tmp);
324 if (!ip6_hdr)
325 return;
326 prio = (ipv6_get_dsfield(ip6_hdr) & 0xfc) >> 5;
327 break;
328 default:
329 return;
330 }
331
332 skb->priority = prio + 256;
333}
334
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200335static int batadv_recv_unhandled_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200336 struct batadv_hard_iface *recv_if)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800337{
338 return NET_RX_DROP;
339}
340
341/* incoming packets with the batman ethertype received on any active hard
342 * interface
343 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200344int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
345 struct packet_type *ptype,
346 struct net_device *orig_dev)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800347{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200348 struct batadv_priv *bat_priv;
Sven Eckelmann96412692012-06-05 22:31:30 +0200349 struct batadv_ogm_packet *batadv_ogm_packet;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200350 struct batadv_hard_iface *hard_iface;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800351 uint8_t idx;
352 int ret;
353
Sven Eckelmann56303d32012-06-05 22:31:31 +0200354 hard_iface = container_of(ptype, struct batadv_hard_iface,
355 batman_adv_ptype);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800356 skb = skb_share_check(skb, GFP_ATOMIC);
357
358 /* skb was released by skb_share_check() */
359 if (!skb)
360 goto err_out;
361
362 /* packet should hold at least type and version */
363 if (unlikely(!pskb_may_pull(skb, 2)))
364 goto err_free;
365
366 /* expect a valid ethernet header here. */
367 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
368 goto err_free;
369
370 if (!hard_iface->soft_iface)
371 goto err_free;
372
373 bat_priv = netdev_priv(hard_iface->soft_iface);
374
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200375 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800376 goto err_free;
377
378 /* discard frames on not active interfaces */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200379 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800380 goto err_free;
381
Sven Eckelmann96412692012-06-05 22:31:30 +0200382 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800383
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100384 if (batadv_ogm_packet->version != BATADV_COMPAT_VERSION) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200385 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200386 "Drop packet: incompatible batman version (%i)\n",
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100387 batadv_ogm_packet->version);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800388 goto err_free;
389 }
390
391 /* all receive handlers return whether they received or reused
392 * the supplied skb. if not, we have to free the skb.
393 */
Simon Wunderlicha40d9b02013-12-02 20:38:31 +0100394 idx = batadv_ogm_packet->packet_type;
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200395 ret = (*batadv_rx_handler[idx])(skb, hard_iface);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800396
397 if (ret == NET_RX_DROP)
398 kfree_skb(skb);
399
400 /* return NET_RX_SUCCESS in any case as we
401 * most probably dropped the packet for
402 * routing-logical reasons.
403 */
404 return NET_RX_SUCCESS;
405
406err_free:
407 kfree_skb(skb);
408err_out:
409 return NET_RX_DROP;
410}
411
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200412static void batadv_recv_handler_init(void)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800413{
414 int i;
415
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200416 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
417 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800418
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200419 for (i = BATADV_UNICAST_MIN; i <= BATADV_UNICAST_MAX; i++)
420 batadv_rx_handler[i] = batadv_recv_unhandled_unicast_packet;
421
Simon Wunderlich031ace82013-12-17 19:12:12 +0100422 /* compile time checks for sizes */
423 BUILD_BUG_ON(sizeof(struct batadv_bla_claim_dst) != 6);
424 BUILD_BUG_ON(sizeof(struct batadv_ogm_packet) != 24);
425 BUILD_BUG_ON(sizeof(struct batadv_icmp_header) != 20);
426 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet) != 20);
427 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet_rr) != 116);
428 BUILD_BUG_ON(sizeof(struct batadv_unicast_packet) != 10);
429 BUILD_BUG_ON(sizeof(struct batadv_unicast_4addr_packet) != 18);
430 BUILD_BUG_ON(sizeof(struct batadv_frag_packet) != 20);
431 BUILD_BUG_ON(sizeof(struct batadv_bcast_packet) != 14);
432 BUILD_BUG_ON(sizeof(struct batadv_coded_packet) != 46);
433 BUILD_BUG_ON(sizeof(struct batadv_unicast_tvlv_packet) != 20);
434 BUILD_BUG_ON(sizeof(struct batadv_tvlv_hdr) != 4);
435 BUILD_BUG_ON(sizeof(struct batadv_tvlv_gateway_data) != 8);
436 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_vlan_data) != 8);
437 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_change) != 12);
438 BUILD_BUG_ON(sizeof(struct batadv_tvlv_roam_adv) != 8);
Simon Wunderlich80067c82013-04-25 10:37:22 +0200439
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200440 /* broadcast packet */
441 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
442
443 /* unicast packets ... */
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200444 /* unicast with 4 addresses packet */
445 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800446 /* unicast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200447 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
Marek Lindneref261572013-04-23 21:39:57 +0800448 /* unicast tvlv packet */
449 batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv;
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200450 /* batman icmp packet */
451 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
Martin Hundebøll610bfc6bc2013-05-23 16:53:02 +0200452 /* Fragmented packets */
453 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_frag_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800454}
455
Sven Eckelmann56303d32012-06-05 22:31:31 +0200456int
457batadv_recv_handler_register(uint8_t packet_type,
458 int (*recv_handler)(struct sk_buff *,
459 struct batadv_hard_iface *))
Marek Lindnerffa995e2012-03-01 15:35:17 +0800460{
Simon Wunderlicha1f1ac52013-04-25 10:37:23 +0200461 int (*curr)(struct sk_buff *,
462 struct batadv_hard_iface *);
463 curr = batadv_rx_handler[packet_type];
464
465 if ((curr != batadv_recv_unhandled_packet) &&
466 (curr != batadv_recv_unhandled_unicast_packet))
Marek Lindnerffa995e2012-03-01 15:35:17 +0800467 return -EBUSY;
468
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200469 batadv_rx_handler[packet_type] = recv_handler;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800470 return 0;
471}
472
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200473void batadv_recv_handler_unregister(uint8_t packet_type)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800474{
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200475 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800476}
477
Sven Eckelmann56303d32012-06-05 22:31:31 +0200478static struct batadv_algo_ops *batadv_algo_get(char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800479{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200480 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
Marek Lindner1c280472011-11-28 17:40:17 +0800481
Sasha Levinb67bfe02013-02-27 17:06:00 -0800482 hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800483 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
484 continue;
485
486 bat_algo_ops = bat_algo_ops_tmp;
487 break;
488 }
489
490 return bat_algo_ops;
491}
492
Sven Eckelmann56303d32012-06-05 22:31:31 +0200493int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
Marek Lindner1c280472011-11-28 17:40:17 +0800494{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200495 struct batadv_algo_ops *bat_algo_ops_tmp;
Sven Eckelmann5346c352012-05-05 13:27:28 +0200496 int ret;
Marek Lindner1c280472011-11-28 17:40:17 +0800497
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200498 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
Marek Lindner1c280472011-11-28 17:40:17 +0800499 if (bat_algo_ops_tmp) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100500 pr_info("Trying to register already registered routing algorithm: %s\n",
501 bat_algo_ops->name);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200502 ret = -EEXIST;
Marek Lindner1c280472011-11-28 17:40:17 +0800503 goto out;
504 }
505
Marek Lindner01c42242011-11-28 21:31:55 +0800506 /* all algorithms must implement all ops (for now) */
Marek Lindnerc2aca022012-02-07 17:20:45 +0800507 if (!bat_algo_ops->bat_iface_enable ||
Marek Lindner00a50072012-02-07 17:20:47 +0800508 !bat_algo_ops->bat_iface_disable ||
Marek Lindnerc3229392012-03-11 06:17:50 +0800509 !bat_algo_ops->bat_iface_update_mac ||
Marek Lindnercd8b78e2012-02-07 17:20:49 +0800510 !bat_algo_ops->bat_primary_iface_set ||
Marek Lindner01c42242011-11-28 21:31:55 +0800511 !bat_algo_ops->bat_ogm_schedule ||
Antonio Quartullia3285a82013-09-02 12:15:04 +0200512 !bat_algo_ops->bat_ogm_emit ||
Antonio Quartullic43c9812013-09-02 12:15:05 +0200513 !bat_algo_ops->bat_neigh_cmp ||
514 !bat_algo_ops->bat_neigh_is_equiv_or_better) {
Marek Lindner01c42242011-11-28 21:31:55 +0800515 pr_info("Routing algo '%s' does not implement required ops\n",
516 bat_algo_ops->name);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200517 ret = -EINVAL;
Marek Lindner01c42242011-11-28 21:31:55 +0800518 goto out;
519 }
520
Marek Lindner1c280472011-11-28 17:40:17 +0800521 INIT_HLIST_NODE(&bat_algo_ops->list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200522 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +0800523 ret = 0;
524
525out:
526 return ret;
527}
528
Sven Eckelmann56303d32012-06-05 22:31:31 +0200529int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800530{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200531 struct batadv_algo_ops *bat_algo_ops;
Sven Eckelmann5346c352012-05-05 13:27:28 +0200532 int ret = -EINVAL;
Marek Lindner1c280472011-11-28 17:40:17 +0800533
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200534 bat_algo_ops = batadv_algo_get(name);
Marek Lindner1c280472011-11-28 17:40:17 +0800535 if (!bat_algo_ops)
536 goto out;
537
538 bat_priv->bat_algo_ops = bat_algo_ops;
539 ret = 0;
540
541out:
542 return ret;
543}
544
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200545int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
Marek Lindner1c280472011-11-28 17:40:17 +0800546{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200547 struct batadv_algo_ops *bat_algo_ops;
Marek Lindner1c280472011-11-28 17:40:17 +0800548
Antonio Quartulli0c814652013-03-21 09:23:29 +0100549 seq_puts(seq, "Available routing algorithms:\n");
Marek Lindner1c280472011-11-28 17:40:17 +0800550
Sasha Levinb67bfe02013-02-27 17:06:00 -0800551 hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800552 seq_printf(seq, "%s\n", bat_algo_ops->name);
553 }
554
555 return 0;
556}
557
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200558/**
559 * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in
560 * the header
561 * @skb: skb pointing to fragmented socket buffers
562 * @payload_ptr: Pointer to position inside the head buffer of the skb
563 * marking the start of the data to be CRC'ed
564 *
565 * payload_ptr must always point to an address in the skb head buffer and not to
566 * a fragment.
567 */
568__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
569{
570 u32 crc = 0;
571 unsigned int from;
572 unsigned int to = skb->len;
573 struct skb_seq_state st;
574 const u8 *data;
575 unsigned int len;
576 unsigned int consumed = 0;
577
578 from = (unsigned int)(payload_ptr - skb->data);
579
580 skb_prepare_seq_read(skb, from, to, &st);
581 while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
582 crc = crc32c(crc, data, len);
583 consumed += len;
584 }
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200585
586 return htonl(crc);
587}
588
Marek Lindneref261572013-04-23 21:39:57 +0800589/**
590 * batadv_tvlv_handler_free_ref - decrement the tvlv handler refcounter and
591 * possibly free it
592 * @tvlv_handler: the tvlv handler to free
593 */
594static void
595batadv_tvlv_handler_free_ref(struct batadv_tvlv_handler *tvlv_handler)
596{
597 if (atomic_dec_and_test(&tvlv_handler->refcount))
598 kfree_rcu(tvlv_handler, rcu);
599}
600
601/**
602 * batadv_tvlv_handler_get - retrieve tvlv handler from the tvlv handler list
603 * based on the provided type and version (both need to match)
604 * @bat_priv: the bat priv with all the soft interface information
605 * @type: tvlv handler type to look for
606 * @version: tvlv handler version to look for
607 *
608 * Returns tvlv handler if found or NULL otherwise.
609 */
610static struct batadv_tvlv_handler
611*batadv_tvlv_handler_get(struct batadv_priv *bat_priv,
612 uint8_t type, uint8_t version)
613{
614 struct batadv_tvlv_handler *tvlv_handler_tmp, *tvlv_handler = NULL;
615
616 rcu_read_lock();
617 hlist_for_each_entry_rcu(tvlv_handler_tmp,
618 &bat_priv->tvlv.handler_list, list) {
619 if (tvlv_handler_tmp->type != type)
620 continue;
621
622 if (tvlv_handler_tmp->version != version)
623 continue;
624
625 if (!atomic_inc_not_zero(&tvlv_handler_tmp->refcount))
626 continue;
627
628 tvlv_handler = tvlv_handler_tmp;
629 break;
630 }
631 rcu_read_unlock();
632
633 return tvlv_handler;
634}
635
636/**
637 * batadv_tvlv_container_free_ref - decrement the tvlv container refcounter and
638 * possibly free it
639 * @tvlv_handler: the tvlv container to free
640 */
641static void batadv_tvlv_container_free_ref(struct batadv_tvlv_container *tvlv)
642{
643 if (atomic_dec_and_test(&tvlv->refcount))
644 kfree(tvlv);
645}
646
647/**
648 * batadv_tvlv_container_get - retrieve tvlv container from the tvlv container
649 * list based on the provided type and version (both need to match)
650 * @bat_priv: the bat priv with all the soft interface information
651 * @type: tvlv container type to look for
652 * @version: tvlv container version to look for
653 *
654 * Has to be called with the appropriate locks being acquired
655 * (tvlv.container_list_lock).
656 *
657 * Returns tvlv container if found or NULL otherwise.
658 */
659static struct batadv_tvlv_container
660*batadv_tvlv_container_get(struct batadv_priv *bat_priv,
661 uint8_t type, uint8_t version)
662{
663 struct batadv_tvlv_container *tvlv_tmp, *tvlv = NULL;
664
665 hlist_for_each_entry(tvlv_tmp, &bat_priv->tvlv.container_list, list) {
666 if (tvlv_tmp->tvlv_hdr.type != type)
667 continue;
668
669 if (tvlv_tmp->tvlv_hdr.version != version)
670 continue;
671
672 if (!atomic_inc_not_zero(&tvlv_tmp->refcount))
673 continue;
674
675 tvlv = tvlv_tmp;
676 break;
677 }
678
679 return tvlv;
680}
681
682/**
683 * batadv_tvlv_container_list_size - calculate the size of the tvlv container
684 * list entries
685 * @bat_priv: the bat priv with all the soft interface information
686 *
687 * Has to be called with the appropriate locks being acquired
688 * (tvlv.container_list_lock).
689 *
690 * Returns size of all currently registered tvlv containers in bytes.
691 */
692static uint16_t batadv_tvlv_container_list_size(struct batadv_priv *bat_priv)
693{
694 struct batadv_tvlv_container *tvlv;
695 uint16_t tvlv_len = 0;
696
697 hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
698 tvlv_len += sizeof(struct batadv_tvlv_hdr);
699 tvlv_len += ntohs(tvlv->tvlv_hdr.len);
700 }
701
702 return tvlv_len;
703}
704
705/**
706 * batadv_tvlv_container_remove - remove tvlv container from the tvlv container
707 * list
708 * @tvlv: the to be removed tvlv container
709 *
710 * Has to be called with the appropriate locks being acquired
711 * (tvlv.container_list_lock).
712 */
713static void batadv_tvlv_container_remove(struct batadv_tvlv_container *tvlv)
714{
715 if (!tvlv)
716 return;
717
718 hlist_del(&tvlv->list);
719
720 /* first call to decrement the counter, second call to free */
721 batadv_tvlv_container_free_ref(tvlv);
722 batadv_tvlv_container_free_ref(tvlv);
723}
724
725/**
726 * batadv_tvlv_container_unregister - unregister tvlv container based on the
727 * 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 unregister
730 * @version: tvlv container type to unregister
731 */
732void batadv_tvlv_container_unregister(struct batadv_priv *bat_priv,
733 uint8_t type, uint8_t version)
734{
735 struct batadv_tvlv_container *tvlv;
736
737 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
738 tvlv = batadv_tvlv_container_get(bat_priv, type, version);
739 batadv_tvlv_container_remove(tvlv);
740 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
741}
742
743/**
744 * batadv_tvlv_container_register - register tvlv type, version and content
745 * to be propagated with each (primary interface) OGM
746 * @bat_priv: the bat priv with all the soft interface information
747 * @type: tvlv container type
748 * @version: tvlv container version
749 * @tvlv_value: tvlv container content
750 * @tvlv_value_len: tvlv container content length
751 *
752 * If a container of the same type and version was already registered the new
753 * content is going to replace the old one.
754 */
755void batadv_tvlv_container_register(struct batadv_priv *bat_priv,
756 uint8_t type, uint8_t version,
757 void *tvlv_value, uint16_t tvlv_value_len)
758{
759 struct batadv_tvlv_container *tvlv_old, *tvlv_new;
760
761 if (!tvlv_value)
762 tvlv_value_len = 0;
763
764 tvlv_new = kzalloc(sizeof(*tvlv_new) + tvlv_value_len, GFP_ATOMIC);
765 if (!tvlv_new)
766 return;
767
768 tvlv_new->tvlv_hdr.version = version;
769 tvlv_new->tvlv_hdr.type = type;
770 tvlv_new->tvlv_hdr.len = htons(tvlv_value_len);
771
772 memcpy(tvlv_new + 1, tvlv_value, ntohs(tvlv_new->tvlv_hdr.len));
773 INIT_HLIST_NODE(&tvlv_new->list);
774 atomic_set(&tvlv_new->refcount, 1);
775
776 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
777 tvlv_old = batadv_tvlv_container_get(bat_priv, type, version);
778 batadv_tvlv_container_remove(tvlv_old);
779 hlist_add_head(&tvlv_new->list, &bat_priv->tvlv.container_list);
780 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
781}
782
783/**
784 * batadv_tvlv_realloc_packet_buff - reallocate packet buffer to accomodate
785 * requested packet size
786 * @packet_buff: packet buffer
787 * @packet_buff_len: packet buffer size
788 * @packet_min_len: requested packet minimum size
789 * @additional_packet_len: requested additional packet size on top of minimum
790 * size
791 *
792 * Returns true of the packet buffer could be changed to the requested size,
793 * false otherwise.
794 */
795static bool batadv_tvlv_realloc_packet_buff(unsigned char **packet_buff,
796 int *packet_buff_len,
797 int min_packet_len,
798 int additional_packet_len)
799{
800 unsigned char *new_buff;
801
802 new_buff = kmalloc(min_packet_len + additional_packet_len, GFP_ATOMIC);
803
804 /* keep old buffer if kmalloc should fail */
805 if (new_buff) {
806 memcpy(new_buff, *packet_buff, min_packet_len);
807 kfree(*packet_buff);
808 *packet_buff = new_buff;
809 *packet_buff_len = min_packet_len + additional_packet_len;
810 return true;
811 }
812
813 return false;
814}
815
816/**
817 * batadv_tvlv_container_ogm_append - append tvlv container content to given
818 * OGM packet buffer
819 * @bat_priv: the bat priv with all the soft interface information
820 * @packet_buff: ogm packet buffer
821 * @packet_buff_len: ogm packet buffer size including ogm header and tvlv
822 * content
823 * @packet_min_len: ogm header size to be preserved for the OGM itself
824 *
825 * The ogm packet might be enlarged or shrunk depending on the current size
826 * and the size of the to-be-appended tvlv containers.
827 *
828 * Returns size of all appended tvlv containers in bytes.
829 */
830uint16_t batadv_tvlv_container_ogm_append(struct batadv_priv *bat_priv,
831 unsigned char **packet_buff,
832 int *packet_buff_len,
833 int packet_min_len)
834{
835 struct batadv_tvlv_container *tvlv;
836 struct batadv_tvlv_hdr *tvlv_hdr;
837 uint16_t tvlv_value_len;
838 void *tvlv_value;
839 bool ret;
840
841 spin_lock_bh(&bat_priv->tvlv.container_list_lock);
842 tvlv_value_len = batadv_tvlv_container_list_size(bat_priv);
843
844 ret = batadv_tvlv_realloc_packet_buff(packet_buff, packet_buff_len,
845 packet_min_len, tvlv_value_len);
846
847 if (!ret)
848 goto end;
849
850 if (!tvlv_value_len)
851 goto end;
852
853 tvlv_value = (*packet_buff) + packet_min_len;
854
855 hlist_for_each_entry(tvlv, &bat_priv->tvlv.container_list, list) {
856 tvlv_hdr = tvlv_value;
857 tvlv_hdr->type = tvlv->tvlv_hdr.type;
858 tvlv_hdr->version = tvlv->tvlv_hdr.version;
859 tvlv_hdr->len = tvlv->tvlv_hdr.len;
860 tvlv_value = tvlv_hdr + 1;
861 memcpy(tvlv_value, tvlv + 1, ntohs(tvlv->tvlv_hdr.len));
862 tvlv_value = (uint8_t *)tvlv_value + ntohs(tvlv->tvlv_hdr.len);
863 }
864
865end:
866 spin_unlock_bh(&bat_priv->tvlv.container_list_lock);
867 return tvlv_value_len;
868}
869
870/**
871 * batadv_tvlv_call_handler - parse the given tvlv buffer to call the
872 * appropriate handlers
873 * @bat_priv: the bat priv with all the soft interface information
874 * @tvlv_handler: tvlv callback function handling the tvlv content
875 * @ogm_source: flag indicating wether the tvlv is an ogm or a unicast packet
876 * @orig_node: orig node emitting the ogm packet
877 * @src: source mac address of the unicast packet
878 * @dst: destination mac address of the unicast packet
879 * @tvlv_value: tvlv content
880 * @tvlv_value_len: tvlv content length
881 *
882 * Returns success if handler was not found or the return value of the handler
883 * callback.
884 */
885static int batadv_tvlv_call_handler(struct batadv_priv *bat_priv,
886 struct batadv_tvlv_handler *tvlv_handler,
887 bool ogm_source,
888 struct batadv_orig_node *orig_node,
889 uint8_t *src, uint8_t *dst,
890 void *tvlv_value, uint16_t tvlv_value_len)
891{
892 if (!tvlv_handler)
893 return NET_RX_SUCCESS;
894
895 if (ogm_source) {
896 if (!tvlv_handler->ogm_handler)
897 return NET_RX_SUCCESS;
898
899 if (!orig_node)
900 return NET_RX_SUCCESS;
901
902 tvlv_handler->ogm_handler(bat_priv, orig_node,
903 BATADV_NO_FLAGS,
904 tvlv_value, tvlv_value_len);
905 tvlv_handler->flags |= BATADV_TVLV_HANDLER_OGM_CALLED;
906 } else {
907 if (!src)
908 return NET_RX_SUCCESS;
909
910 if (!dst)
911 return NET_RX_SUCCESS;
912
913 if (!tvlv_handler->unicast_handler)
914 return NET_RX_SUCCESS;
915
916 return tvlv_handler->unicast_handler(bat_priv, src,
917 dst, tvlv_value,
918 tvlv_value_len);
919 }
920
921 return NET_RX_SUCCESS;
922}
923
924/**
925 * batadv_tvlv_containers_process - parse the given tvlv buffer to call the
926 * appropriate handlers
927 * @bat_priv: the bat priv with all the soft interface information
928 * @ogm_source: flag indicating wether the tvlv is an ogm or a unicast packet
929 * @orig_node: orig node emitting the ogm packet
930 * @src: source mac address of the unicast packet
931 * @dst: destination mac address of the unicast packet
932 * @tvlv_value: tvlv content
933 * @tvlv_value_len: tvlv content length
934 *
935 * Returns success when processing an OGM or the return value of all called
936 * handler callbacks.
937 */
938int batadv_tvlv_containers_process(struct batadv_priv *bat_priv,
939 bool ogm_source,
940 struct batadv_orig_node *orig_node,
941 uint8_t *src, uint8_t *dst,
942 void *tvlv_value, uint16_t tvlv_value_len)
943{
944 struct batadv_tvlv_handler *tvlv_handler;
945 struct batadv_tvlv_hdr *tvlv_hdr;
946 uint16_t tvlv_value_cont_len;
947 uint8_t cifnotfound = BATADV_TVLV_HANDLER_OGM_CIFNOTFND;
948 int ret = NET_RX_SUCCESS;
949
950 while (tvlv_value_len >= sizeof(*tvlv_hdr)) {
951 tvlv_hdr = tvlv_value;
952 tvlv_value_cont_len = ntohs(tvlv_hdr->len);
953 tvlv_value = tvlv_hdr + 1;
954 tvlv_value_len -= sizeof(*tvlv_hdr);
955
956 if (tvlv_value_cont_len > tvlv_value_len)
957 break;
958
959 tvlv_handler = batadv_tvlv_handler_get(bat_priv,
960 tvlv_hdr->type,
961 tvlv_hdr->version);
962
963 ret |= batadv_tvlv_call_handler(bat_priv, tvlv_handler,
964 ogm_source, orig_node,
965 src, dst, tvlv_value,
966 tvlv_value_cont_len);
967 if (tvlv_handler)
968 batadv_tvlv_handler_free_ref(tvlv_handler);
969 tvlv_value = (uint8_t *)tvlv_value + tvlv_value_cont_len;
970 tvlv_value_len -= tvlv_value_cont_len;
971 }
972
973 if (!ogm_source)
974 return ret;
975
976 rcu_read_lock();
977 hlist_for_each_entry_rcu(tvlv_handler,
978 &bat_priv->tvlv.handler_list, list) {
979 if ((tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) &&
980 !(tvlv_handler->flags & BATADV_TVLV_HANDLER_OGM_CALLED))
981 tvlv_handler->ogm_handler(bat_priv, orig_node,
982 cifnotfound, NULL, 0);
983
984 tvlv_handler->flags &= ~BATADV_TVLV_HANDLER_OGM_CALLED;
985 }
986 rcu_read_unlock();
987
988 return NET_RX_SUCCESS;
989}
990
991/**
992 * batadv_tvlv_ogm_receive - process an incoming ogm and call the appropriate
993 * handlers
994 * @bat_priv: the bat priv with all the soft interface information
995 * @batadv_ogm_packet: ogm packet containing the tvlv containers
996 * @orig_node: orig node emitting the ogm packet
997 */
998void batadv_tvlv_ogm_receive(struct batadv_priv *bat_priv,
999 struct batadv_ogm_packet *batadv_ogm_packet,
1000 struct batadv_orig_node *orig_node)
1001{
1002 void *tvlv_value;
1003 uint16_t tvlv_value_len;
1004
1005 if (!batadv_ogm_packet)
1006 return;
1007
1008 tvlv_value_len = ntohs(batadv_ogm_packet->tvlv_len);
1009 if (!tvlv_value_len)
1010 return;
1011
1012 tvlv_value = batadv_ogm_packet + 1;
1013
1014 batadv_tvlv_containers_process(bat_priv, true, orig_node, NULL, NULL,
1015 tvlv_value, tvlv_value_len);
1016}
1017
1018/**
1019 * batadv_tvlv_handler_register - register tvlv handler based on the provided
1020 * type and version (both need to match) for ogm tvlv payload and/or unicast
1021 * payload
1022 * @bat_priv: the bat priv with all the soft interface information
1023 * @optr: ogm tvlv handler callback function. This function receives the orig
1024 * node, flags and the tvlv content as argument to process.
1025 * @uptr: unicast tvlv handler callback function. This function receives the
1026 * source & destination of the unicast packet as well as the tvlv content
1027 * to process.
1028 * @type: tvlv handler type to be registered
1029 * @version: tvlv handler version to be registered
1030 * @flags: flags to enable or disable TVLV API behavior
1031 */
1032void batadv_tvlv_handler_register(struct batadv_priv *bat_priv,
1033 void (*optr)(struct batadv_priv *bat_priv,
1034 struct batadv_orig_node *orig,
1035 uint8_t flags,
1036 void *tvlv_value,
1037 uint16_t tvlv_value_len),
1038 int (*uptr)(struct batadv_priv *bat_priv,
1039 uint8_t *src, uint8_t *dst,
1040 void *tvlv_value,
1041 uint16_t tvlv_value_len),
1042 uint8_t type, uint8_t version, uint8_t flags)
1043{
1044 struct batadv_tvlv_handler *tvlv_handler;
1045
1046 tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1047 if (tvlv_handler) {
1048 batadv_tvlv_handler_free_ref(tvlv_handler);
1049 return;
1050 }
1051
1052 tvlv_handler = kzalloc(sizeof(*tvlv_handler), GFP_ATOMIC);
1053 if (!tvlv_handler)
1054 return;
1055
1056 tvlv_handler->ogm_handler = optr;
1057 tvlv_handler->unicast_handler = uptr;
1058 tvlv_handler->type = type;
1059 tvlv_handler->version = version;
1060 tvlv_handler->flags = flags;
1061 atomic_set(&tvlv_handler->refcount, 1);
1062 INIT_HLIST_NODE(&tvlv_handler->list);
1063
1064 spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1065 hlist_add_head_rcu(&tvlv_handler->list, &bat_priv->tvlv.handler_list);
1066 spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1067}
1068
1069/**
1070 * batadv_tvlv_handler_unregister - unregister tvlv handler based on the
1071 * provided type and version (both need to match)
1072 * @bat_priv: the bat priv with all the soft interface information
1073 * @type: tvlv handler type to be unregistered
1074 * @version: tvlv handler version to be unregistered
1075 */
1076void batadv_tvlv_handler_unregister(struct batadv_priv *bat_priv,
1077 uint8_t type, uint8_t version)
1078{
1079 struct batadv_tvlv_handler *tvlv_handler;
1080
1081 tvlv_handler = batadv_tvlv_handler_get(bat_priv, type, version);
1082 if (!tvlv_handler)
1083 return;
1084
1085 batadv_tvlv_handler_free_ref(tvlv_handler);
1086 spin_lock_bh(&bat_priv->tvlv.handler_list_lock);
1087 hlist_del_rcu(&tvlv_handler->list);
1088 spin_unlock_bh(&bat_priv->tvlv.handler_list_lock);
1089 batadv_tvlv_handler_free_ref(tvlv_handler);
1090}
1091
1092/**
1093 * batadv_tvlv_unicast_send - send a unicast packet with tvlv payload to the
1094 * specified host
1095 * @bat_priv: the bat priv with all the soft interface information
1096 * @src: source mac address of the unicast packet
1097 * @dst: destination mac address of the unicast packet
1098 * @type: tvlv type
1099 * @version: tvlv version
1100 * @tvlv_value: tvlv content
1101 * @tvlv_value_len: tvlv content length
1102 */
1103void batadv_tvlv_unicast_send(struct batadv_priv *bat_priv, uint8_t *src,
1104 uint8_t *dst, uint8_t type, uint8_t version,
1105 void *tvlv_value, uint16_t tvlv_value_len)
1106{
1107 struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
1108 struct batadv_tvlv_hdr *tvlv_hdr;
1109 struct batadv_orig_node *orig_node;
1110 struct sk_buff *skb = NULL;
1111 unsigned char *tvlv_buff;
1112 unsigned int tvlv_len;
1113 ssize_t hdr_len = sizeof(*unicast_tvlv_packet);
1114 bool ret = false;
1115
1116 orig_node = batadv_orig_hash_find(bat_priv, dst);
1117 if (!orig_node)
1118 goto out;
1119
1120 tvlv_len = sizeof(*tvlv_hdr) + tvlv_value_len;
1121
1122 skb = netdev_alloc_skb_ip_align(NULL, ETH_HLEN + hdr_len + tvlv_len);
1123 if (!skb)
1124 goto out;
1125
1126 skb->priority = TC_PRIO_CONTROL;
1127 skb_reserve(skb, ETH_HLEN);
1128 tvlv_buff = skb_put(skb, sizeof(*unicast_tvlv_packet) + tvlv_len);
1129 unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)tvlv_buff;
Simon Wunderlicha40d9b02013-12-02 20:38:31 +01001130 unicast_tvlv_packet->packet_type = BATADV_UNICAST_TVLV;
1131 unicast_tvlv_packet->version = BATADV_COMPAT_VERSION;
1132 unicast_tvlv_packet->ttl = BATADV_TTL;
Marek Lindneref261572013-04-23 21:39:57 +08001133 unicast_tvlv_packet->reserved = 0;
1134 unicast_tvlv_packet->tvlv_len = htons(tvlv_len);
1135 unicast_tvlv_packet->align = 0;
1136 memcpy(unicast_tvlv_packet->src, src, ETH_ALEN);
1137 memcpy(unicast_tvlv_packet->dst, dst, ETH_ALEN);
1138
1139 tvlv_buff = (unsigned char *)(unicast_tvlv_packet + 1);
1140 tvlv_hdr = (struct batadv_tvlv_hdr *)tvlv_buff;
1141 tvlv_hdr->version = version;
1142 tvlv_hdr->type = type;
1143 tvlv_hdr->len = htons(tvlv_value_len);
1144 tvlv_buff += sizeof(*tvlv_hdr);
1145 memcpy(tvlv_buff, tvlv_value, tvlv_value_len);
1146
1147 if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
1148 ret = true;
1149
1150out:
1151 if (skb && !ret)
1152 kfree_skb(skb);
1153 if (orig_node)
1154 batadv_orig_node_free_ref(orig_node);
1155}
1156
Antonio Quartullic018ad32013-06-04 12:11:39 +02001157/**
1158 * batadv_get_vid - extract the VLAN identifier from skb if any
1159 * @skb: the buffer containing the packet
1160 * @header_len: length of the batman header preceding the ethernet header
1161 *
1162 * If the packet embedded in the skb is vlan tagged this function returns the
1163 * VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS is returned.
1164 */
1165unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len)
1166{
1167 struct ethhdr *ethhdr = (struct ethhdr *)(skb->data + header_len);
1168 struct vlan_ethhdr *vhdr;
1169 unsigned short vid;
1170
1171 if (ethhdr->h_proto != htons(ETH_P_8021Q))
1172 return BATADV_NO_FLAGS;
1173
1174 if (!pskb_may_pull(skb, header_len + VLAN_ETH_HLEN))
1175 return BATADV_NO_FLAGS;
1176
1177 vhdr = (struct vlan_ethhdr *)(skb->data + header_len);
1178 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
1179 vid |= BATADV_VLAN_HAS_TAG;
1180
1181 return vid;
1182}
1183
Antonio Quartullieceb22a2013-11-16 12:03:51 +01001184/**
1185 * batadv_vlan_ap_isola_get - return the AP isolation status for the given vlan
1186 * @bat_priv: the bat priv with all the soft interface information
1187 * @vid: the VLAN identifier for which the AP isolation attributed as to be
1188 * looked up
1189 *
1190 * Returns true if AP isolation is on for the VLAN idenfied by vid, false
1191 * otherwise
1192 */
1193bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid)
1194{
1195 bool ap_isolation_enabled = false;
1196 struct batadv_softif_vlan *vlan;
1197
1198 /* if the AP isolation is requested on a VLAN, then check for its
1199 * setting in the proper VLAN private data structure
1200 */
1201 vlan = batadv_softif_vlan_get(bat_priv, vid);
1202 if (vlan) {
1203 ap_isolation_enabled = atomic_read(&vlan->ap_isolation);
1204 batadv_softif_vlan_free_ref(vlan);
1205 }
1206
1207 return ap_isolation_enabled;
1208}
1209
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001210static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
Marek Lindnerd419be12011-12-10 19:45:53 +08001211{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001212 struct batadv_algo_ops *bat_algo_ops;
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001213 char *algo_name = (char *)val;
1214 size_t name_len = strlen(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +08001215
Marek Lindner293c9c12013-04-27 16:22:28 +08001216 if (name_len > 0 && algo_name[name_len - 1] == '\n')
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001217 algo_name[name_len - 1] = '\0';
1218
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001219 bat_algo_ops = batadv_algo_get(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +08001220 if (!bat_algo_ops) {
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001221 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +08001222 return -EINVAL;
1223 }
1224
Marek Lindnerd8cb54862012-04-18 17:16:39 +08001225 return param_set_copystring(algo_name, kp);
Marek Lindnerd419be12011-12-10 19:45:53 +08001226}
1227
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001228static const struct kernel_param_ops batadv_param_ops_ra = {
1229 .set = batadv_param_set_ra,
Marek Lindnerd419be12011-12-10 19:45:53 +08001230 .get = param_get_string,
1231};
1232
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001233static struct kparam_string batadv_param_string_ra = {
Sven Eckelmann3193e8f2012-05-12 02:09:42 +02001234 .maxlen = sizeof(batadv_routing_algo),
1235 .string = batadv_routing_algo,
Marek Lindnerd419be12011-12-10 19:45:53 +08001236};
1237
Sven Eckelmannee11ad62012-05-16 20:23:19 +02001238module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
1239 0644);
1240module_init(batadv_init);
1241module_exit(batadv_exit);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +00001242
1243MODULE_LICENSE("GPL");
1244
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001245MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
1246MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
1247MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
1248MODULE_VERSION(BATADV_SOURCE_VERSION);