blob: 51aafd669cbbd6a7714f9ab075f647313c8234d5 [file] [log] [blame]
Antonio Quartulli0b873932013-01-04 03:05:31 +01001/* Copyright (C) 2007-2013 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
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000018 */
19
Sven Eckelmann95a066d2012-10-17 21:10:39 +020020#include <linux/crc32c.h>
21#include <linux/highmem.h>
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000022#include "main.h"
Sven Eckelmannb706b132012-06-10 23:58:51 +020023#include "sysfs.h"
24#include "debugfs.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000025#include "routing.h"
26#include "send.h"
27#include "originator.h"
28#include "soft-interface.h"
29#include "icmp_socket.h"
30#include "translation-table.h"
31#include "hard-interface.h"
32#include "gateway_client.h"
Simon Wunderlich23721382012-01-22 20:00:19 +010033#include "bridge_loop_avoidance.h"
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +020034#include "distributed-arp-table.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000035#include "vis.h"
36#include "hash.h"
Marek Lindner1c280472011-11-28 17:40:17 +080037#include "bat_algo.h"
Martin Hundebølld353d8d2013-01-25 11:12:38 +010038#include "network-coding.h"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000039
Sven Eckelmannc3caf512011-05-03 11:51:38 +020040
41/* List manipulations on hardif_list have to be rtnl_lock()'ed,
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +020042 * list traversals just rcu-locked
43 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020044struct list_head batadv_hardif_list;
Sven Eckelmannee11ad62012-05-16 20:23:19 +020045static int (*batadv_rx_handler[256])(struct sk_buff *,
Sven Eckelmann56303d32012-06-05 22:31:31 +020046 struct batadv_hard_iface *);
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020047char batadv_routing_algo[20] = "BATMAN_IV";
Sven Eckelmannee11ad62012-05-16 20:23:19 +020048static struct hlist_head batadv_algo_list;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000049
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020050unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000051
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020052struct workqueue_struct *batadv_event_workqueue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000053
Sven Eckelmannee11ad62012-05-16 20:23:19 +020054static void batadv_recv_handler_init(void);
Marek Lindnerffa995e2012-03-01 15:35:17 +080055
Sven Eckelmannee11ad62012-05-16 20:23:19 +020056static int __init batadv_init(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000057{
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020058 INIT_LIST_HEAD(&batadv_hardif_list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +020059 INIT_HLIST_HEAD(&batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +080060
Sven Eckelmannee11ad62012-05-16 20:23:19 +020061 batadv_recv_handler_init();
Marek Lindnerffa995e2012-03-01 15:35:17 +080062
Sven Eckelmann81c524f2012-05-12 02:09:22 +020063 batadv_iv_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000064
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020065 batadv_event_workqueue = create_singlethread_workqueue("bat_events");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000066
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020067 if (!batadv_event_workqueue)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000068 return -ENOMEM;
69
Sven Eckelmann9039dc72012-05-12 02:09:33 +020070 batadv_socket_init();
Sven Eckelmann40a072d2012-05-12 02:09:23 +020071 batadv_debugfs_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000072
Sven Eckelmann95638772012-05-12 02:09:31 +020073 register_netdevice_notifier(&batadv_hard_if_notifier);
Sven Eckelmanna4ac28c2013-02-11 17:10:26 +080074 rtnl_link_register(&batadv_link_ops);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000075
Sven Eckelmann86ceb362012-03-07 09:07:45 +010076 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
Sven Eckelmann42d0b042012-06-03 22:19:17 +020077 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000078
79 return 0;
80}
81
Sven Eckelmannee11ad62012-05-16 20:23:19 +020082static void __exit batadv_exit(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000083{
Sven Eckelmann40a072d2012-05-12 02:09:23 +020084 batadv_debugfs_destroy();
Sven Eckelmanna4ac28c2013-02-11 17:10:26 +080085 rtnl_link_unregister(&batadv_link_ops);
Sven Eckelmann95638772012-05-12 02:09:31 +020086 unregister_netdevice_notifier(&batadv_hard_if_notifier);
87 batadv_hardif_remove_interfaces();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000088
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020089 flush_workqueue(batadv_event_workqueue);
90 destroy_workqueue(batadv_event_workqueue);
91 batadv_event_workqueue = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000092
93 rcu_barrier();
94}
95
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020096int batadv_mesh_init(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000097{
Sven Eckelmann56303d32012-06-05 22:31:31 +020098 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +020099 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000100
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000101 spin_lock_init(&bat_priv->forw_bat_list_lock);
102 spin_lock_init(&bat_priv->forw_bcast_list_lock);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200103 spin_lock_init(&bat_priv->tt.changes_list_lock);
104 spin_lock_init(&bat_priv->tt.req_list_lock);
105 spin_lock_init(&bat_priv->tt.roam_list_lock);
106 spin_lock_init(&bat_priv->tt.last_changeset_lock);
107 spin_lock_init(&bat_priv->gw.list_lock);
108 spin_lock_init(&bat_priv->vis.hash_lock);
109 spin_lock_init(&bat_priv->vis.list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000110
111 INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
112 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200113 INIT_HLIST_HEAD(&bat_priv->gw.list);
114 INIT_LIST_HEAD(&bat_priv->tt.changes_list);
115 INIT_LIST_HEAD(&bat_priv->tt.req_list);
116 INIT_LIST_HEAD(&bat_priv->tt.roam_list);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000117
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200118 ret = batadv_originator_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200119 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000120 goto err;
121
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200122 ret = batadv_tt_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200123 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000124 goto err;
125
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200126 batadv_tt_local_add(soft_iface, soft_iface->dev_addr,
127 BATADV_NULL_IFINDEX);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000128
Sven Eckelmannd0f714f2012-05-12 02:09:41 +0200129 ret = batadv_vis_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200130 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000131 goto err;
132
Sven Eckelmann08adf152012-05-12 13:38:47 +0200133 ret = batadv_bla_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200134 if (ret < 0)
Simon Wunderlich23721382012-01-22 20:00:19 +0100135 goto err;
136
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200137 ret = batadv_dat_init(bat_priv);
138 if (ret < 0)
139 goto err;
140
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100141 ret = batadv_nc_init(bat_priv);
142 if (ret < 0)
143 goto err;
144
Sven Eckelmann807736f2012-07-15 22:26:51 +0200145 atomic_set(&bat_priv->gw.reselect, 0);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200146 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200147
148 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000149
150err:
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200151 batadv_mesh_free(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200152 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000153}
154
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200155void batadv_mesh_free(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000156{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200157 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000158
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200159 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000160
Sven Eckelmann9455e342012-05-12 02:09:37 +0200161 batadv_purge_outstanding_packets(bat_priv, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000162
Sven Eckelmannd0f714f2012-05-12 02:09:41 +0200163 batadv_vis_quit(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000164
Sven Eckelmann7cf06bc2012-05-12 02:09:29 +0200165 batadv_gw_node_purge(bat_priv);
Martin Hundebølld353d8d2013-01-25 11:12:38 +0100166 batadv_nc_free(bat_priv);
Antonio Quartullia4361862013-05-07 01:06:18 +0200167 batadv_dat_free(bat_priv);
Sven Eckelmann08adf152012-05-12 13:38:47 +0200168 batadv_bla_free(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +0100169
Antonio Quartullia4361862013-05-07 01:06:18 +0200170 /* Free the TT and the originator tables only after having terminated
171 * all the other depending components which may use these structures for
172 * their purposes.
173 */
174 batadv_tt_free(bat_priv);
175
176 /* Since the originator table clean up routine is accessing the TT
177 * tables as well, it has to be invoked after the TT tables have been
178 * freed and marked as empty. This ensures that no cleanup RCU callbacks
179 * accessing the TT data are scheduled for later execution.
180 */
181 batadv_originator_free(bat_priv);
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200182
Martin Hundebøllf8214862012-04-20 17:02:45 +0200183 free_percpu(bat_priv->bat_counters);
Martin Hundebøllf69ae772013-04-17 21:13:16 +0200184 bat_priv->bat_counters = NULL;
Martin Hundebøllf8214862012-04-20 17:02:45 +0200185
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200186 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000187}
188
David S. Miller6e0895c2013-04-22 20:32:51 -0400189/**
190 * batadv_is_my_mac - check if the given mac address belongs to any of the real
191 * interfaces in the current mesh
192 * @bat_priv: the bat priv with all the soft interface information
193 * @addr: the address to check
194 */
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200195int batadv_is_my_mac(struct batadv_priv *bat_priv, const uint8_t *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000196{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200197 const struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000198
199 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200200 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200201 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000202 continue;
203
Antonio Quartullife8a93b2013-04-03 19:10:26 +0200204 if (hard_iface->soft_iface != bat_priv->soft_iface)
205 continue;
206
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200207 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000208 rcu_read_unlock();
209 return 1;
210 }
211 }
212 rcu_read_unlock();
213 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000214}
215
Marek Lindner30da63a2012-08-03 17:15:46 +0200216/**
217 * batadv_seq_print_text_primary_if_get - called from debugfs table printing
218 * function that requires the primary interface
219 * @seq: debugfs table seq_file struct
220 *
221 * Returns primary interface if found or NULL otherwise.
222 */
223struct batadv_hard_iface *
224batadv_seq_print_text_primary_if_get(struct seq_file *seq)
225{
226 struct net_device *net_dev = (struct net_device *)seq->private;
227 struct batadv_priv *bat_priv = netdev_priv(net_dev);
228 struct batadv_hard_iface *primary_if;
229
230 primary_if = batadv_primary_if_get_selected(bat_priv);
231
232 if (!primary_if) {
233 seq_printf(seq,
234 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
235 net_dev->name);
236 goto out;
237 }
238
239 if (primary_if->if_status == BATADV_IF_ACTIVE)
240 goto out;
241
242 seq_printf(seq,
243 "BATMAN mesh %s disabled - primary interface not active\n",
244 net_dev->name);
245 batadv_hardif_free_ref(primary_if);
246 primary_if = NULL;
247
248out:
249 return primary_if;
250}
251
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200252static int batadv_recv_unhandled_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200253 struct batadv_hard_iface *recv_if)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800254{
255 return NET_RX_DROP;
256}
257
258/* incoming packets with the batman ethertype received on any active hard
259 * interface
260 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200261int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
262 struct packet_type *ptype,
263 struct net_device *orig_dev)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800264{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200265 struct batadv_priv *bat_priv;
Sven Eckelmann96412692012-06-05 22:31:30 +0200266 struct batadv_ogm_packet *batadv_ogm_packet;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200267 struct batadv_hard_iface *hard_iface;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800268 uint8_t idx;
269 int ret;
270
Sven Eckelmann56303d32012-06-05 22:31:31 +0200271 hard_iface = container_of(ptype, struct batadv_hard_iface,
272 batman_adv_ptype);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800273 skb = skb_share_check(skb, GFP_ATOMIC);
274
275 /* skb was released by skb_share_check() */
276 if (!skb)
277 goto err_out;
278
279 /* packet should hold at least type and version */
280 if (unlikely(!pskb_may_pull(skb, 2)))
281 goto err_free;
282
283 /* expect a valid ethernet header here. */
284 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
285 goto err_free;
286
287 if (!hard_iface->soft_iface)
288 goto err_free;
289
290 bat_priv = netdev_priv(hard_iface->soft_iface);
291
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200292 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800293 goto err_free;
294
295 /* discard frames on not active interfaces */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200296 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800297 goto err_free;
298
Sven Eckelmann96412692012-06-05 22:31:30 +0200299 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800300
Sven Eckelmann96412692012-06-05 22:31:30 +0200301 if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200302 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200303 "Drop packet: incompatible batman version (%i)\n",
Sven Eckelmann96412692012-06-05 22:31:30 +0200304 batadv_ogm_packet->header.version);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800305 goto err_free;
306 }
307
308 /* all receive handlers return whether they received or reused
309 * the supplied skb. if not, we have to free the skb.
310 */
Sven Eckelmann96412692012-06-05 22:31:30 +0200311 idx = batadv_ogm_packet->header.packet_type;
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200312 ret = (*batadv_rx_handler[idx])(skb, hard_iface);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800313
314 if (ret == NET_RX_DROP)
315 kfree_skb(skb);
316
317 /* return NET_RX_SUCCESS in any case as we
318 * most probably dropped the packet for
319 * routing-logical reasons.
320 */
321 return NET_RX_SUCCESS;
322
323err_free:
324 kfree_skb(skb);
325err_out:
326 return NET_RX_DROP;
327}
328
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200329static void batadv_recv_handler_init(void)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800330{
331 int i;
332
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200333 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
334 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800335
Marek Lindnerffa995e2012-03-01 15:35:17 +0800336 /* batman icmp packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200337 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200338 /* unicast with 4 addresses packet */
339 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800340 /* unicast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200341 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800342 /* fragmented unicast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200343 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_ucast_frag_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800344 /* broadcast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200345 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800346 /* vis packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200347 batadv_rx_handler[BATADV_VIS] = batadv_recv_vis_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800348 /* Translation table query (request or response) */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200349 batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800350 /* Roaming advertisement */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200351 batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800352}
353
Sven Eckelmann56303d32012-06-05 22:31:31 +0200354int
355batadv_recv_handler_register(uint8_t packet_type,
356 int (*recv_handler)(struct sk_buff *,
357 struct batadv_hard_iface *))
Marek Lindnerffa995e2012-03-01 15:35:17 +0800358{
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200359 if (batadv_rx_handler[packet_type] != &batadv_recv_unhandled_packet)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800360 return -EBUSY;
361
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200362 batadv_rx_handler[packet_type] = recv_handler;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800363 return 0;
364}
365
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200366void batadv_recv_handler_unregister(uint8_t packet_type)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800367{
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200368 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800369}
370
Sven Eckelmann56303d32012-06-05 22:31:31 +0200371static struct batadv_algo_ops *batadv_algo_get(char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800372{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200373 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
Marek Lindner1c280472011-11-28 17:40:17 +0800374
Sasha Levinb67bfe02013-02-27 17:06:00 -0800375 hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800376 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
377 continue;
378
379 bat_algo_ops = bat_algo_ops_tmp;
380 break;
381 }
382
383 return bat_algo_ops;
384}
385
Sven Eckelmann56303d32012-06-05 22:31:31 +0200386int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
Marek Lindner1c280472011-11-28 17:40:17 +0800387{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200388 struct batadv_algo_ops *bat_algo_ops_tmp;
Sven Eckelmann5346c352012-05-05 13:27:28 +0200389 int ret;
Marek Lindner1c280472011-11-28 17:40:17 +0800390
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200391 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
Marek Lindner1c280472011-11-28 17:40:17 +0800392 if (bat_algo_ops_tmp) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100393 pr_info("Trying to register already registered routing algorithm: %s\n",
394 bat_algo_ops->name);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200395 ret = -EEXIST;
Marek Lindner1c280472011-11-28 17:40:17 +0800396 goto out;
397 }
398
Marek Lindner01c42242011-11-28 21:31:55 +0800399 /* all algorithms must implement all ops (for now) */
Marek Lindnerc2aca022012-02-07 17:20:45 +0800400 if (!bat_algo_ops->bat_iface_enable ||
Marek Lindner00a50072012-02-07 17:20:47 +0800401 !bat_algo_ops->bat_iface_disable ||
Marek Lindnerc3229392012-03-11 06:17:50 +0800402 !bat_algo_ops->bat_iface_update_mac ||
Marek Lindnercd8b78e2012-02-07 17:20:49 +0800403 !bat_algo_ops->bat_primary_iface_set ||
Marek Lindner01c42242011-11-28 21:31:55 +0800404 !bat_algo_ops->bat_ogm_schedule ||
Marek Lindnerc3e29312012-03-04 16:56:25 +0800405 !bat_algo_ops->bat_ogm_emit) {
Marek Lindner01c42242011-11-28 21:31:55 +0800406 pr_info("Routing algo '%s' does not implement required ops\n",
407 bat_algo_ops->name);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200408 ret = -EINVAL;
Marek Lindner01c42242011-11-28 21:31:55 +0800409 goto out;
410 }
411
Marek Lindner1c280472011-11-28 17:40:17 +0800412 INIT_HLIST_NODE(&bat_algo_ops->list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200413 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +0800414 ret = 0;
415
416out:
417 return ret;
418}
419
Sven Eckelmann56303d32012-06-05 22:31:31 +0200420int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800421{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200422 struct batadv_algo_ops *bat_algo_ops;
Sven Eckelmann5346c352012-05-05 13:27:28 +0200423 int ret = -EINVAL;
Marek Lindner1c280472011-11-28 17:40:17 +0800424
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200425 bat_algo_ops = batadv_algo_get(name);
Marek Lindner1c280472011-11-28 17:40:17 +0800426 if (!bat_algo_ops)
427 goto out;
428
429 bat_priv->bat_algo_ops = bat_algo_ops;
430 ret = 0;
431
432out:
433 return ret;
434}
435
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200436int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
Marek Lindner1c280472011-11-28 17:40:17 +0800437{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200438 struct batadv_algo_ops *bat_algo_ops;
Marek Lindner1c280472011-11-28 17:40:17 +0800439
Antonio Quartulli0c814652013-03-21 09:23:29 +0100440 seq_puts(seq, "Available routing algorithms:\n");
Marek Lindner1c280472011-11-28 17:40:17 +0800441
Sasha Levinb67bfe02013-02-27 17:06:00 -0800442 hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800443 seq_printf(seq, "%s\n", bat_algo_ops->name);
444 }
445
446 return 0;
447}
448
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200449/**
450 * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in
451 * the header
452 * @skb: skb pointing to fragmented socket buffers
453 * @payload_ptr: Pointer to position inside the head buffer of the skb
454 * marking the start of the data to be CRC'ed
455 *
456 * payload_ptr must always point to an address in the skb head buffer and not to
457 * a fragment.
458 */
459__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
460{
461 u32 crc = 0;
462 unsigned int from;
463 unsigned int to = skb->len;
464 struct skb_seq_state st;
465 const u8 *data;
466 unsigned int len;
467 unsigned int consumed = 0;
468
469 from = (unsigned int)(payload_ptr - skb->data);
470
471 skb_prepare_seq_read(skb, from, to, &st);
472 while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
473 crc = crc32c(crc, data, len);
474 consumed += len;
475 }
476 skb_abort_seq_read(&st);
477
478 return htonl(crc);
479}
480
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200481static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
Marek Lindnerd419be12011-12-10 19:45:53 +0800482{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200483 struct batadv_algo_ops *bat_algo_ops;
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800484 char *algo_name = (char *)val;
485 size_t name_len = strlen(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +0800486
Marek Lindner293c9c12013-04-27 16:22:28 +0800487 if (name_len > 0 && algo_name[name_len - 1] == '\n')
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800488 algo_name[name_len - 1] = '\0';
489
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200490 bat_algo_ops = batadv_algo_get(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +0800491 if (!bat_algo_ops) {
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800492 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +0800493 return -EINVAL;
494 }
495
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800496 return param_set_copystring(algo_name, kp);
Marek Lindnerd419be12011-12-10 19:45:53 +0800497}
498
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200499static const struct kernel_param_ops batadv_param_ops_ra = {
500 .set = batadv_param_set_ra,
Marek Lindnerd419be12011-12-10 19:45:53 +0800501 .get = param_get_string,
502};
503
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200504static struct kparam_string batadv_param_string_ra = {
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200505 .maxlen = sizeof(batadv_routing_algo),
506 .string = batadv_routing_algo,
Marek Lindnerd419be12011-12-10 19:45:53 +0800507};
508
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200509module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
510 0644);
511module_init(batadv_init);
512module_exit(batadv_exit);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000513
514MODULE_LICENSE("GPL");
515
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200516MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
517MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
518MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
519MODULE_VERSION(BATADV_SOURCE_VERSION);