blob: f65a222b7b83c0d691f859f2eef1ea189ac84e2c [file] [log] [blame]
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001/* Copyright (C) 2007-2012 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"
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000038
Sven Eckelmannc3caf512011-05-03 11:51:38 +020039
40/* List manipulations on hardif_list have to be rtnl_lock()'ed,
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +020041 * list traversals just rcu-locked
42 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020043struct list_head batadv_hardif_list;
Sven Eckelmannee11ad62012-05-16 20:23:19 +020044static int (*batadv_rx_handler[256])(struct sk_buff *,
Sven Eckelmann56303d32012-06-05 22:31:31 +020045 struct batadv_hard_iface *);
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020046char batadv_routing_algo[20] = "BATMAN_IV";
Sven Eckelmannee11ad62012-05-16 20:23:19 +020047static struct hlist_head batadv_algo_list;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000048
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020049unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000050
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020051struct workqueue_struct *batadv_event_workqueue;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000052
Sven Eckelmannee11ad62012-05-16 20:23:19 +020053static void batadv_recv_handler_init(void);
Marek Lindnerffa995e2012-03-01 15:35:17 +080054
Sven Eckelmannee11ad62012-05-16 20:23:19 +020055static int __init batadv_init(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000056{
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020057 INIT_LIST_HEAD(&batadv_hardif_list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +020058 INIT_HLIST_HEAD(&batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +080059
Sven Eckelmannee11ad62012-05-16 20:23:19 +020060 batadv_recv_handler_init();
Marek Lindnerffa995e2012-03-01 15:35:17 +080061
Sven Eckelmann81c524f2012-05-12 02:09:22 +020062 batadv_iv_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000063
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020064 batadv_event_workqueue = create_singlethread_workqueue("bat_events");
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000065
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020066 if (!batadv_event_workqueue)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000067 return -ENOMEM;
68
Sven Eckelmann9039dc72012-05-12 02:09:33 +020069 batadv_socket_init();
Sven Eckelmann40a072d2012-05-12 02:09:23 +020070 batadv_debugfs_init();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000071
Sven Eckelmann95638772012-05-12 02:09:31 +020072 register_netdevice_notifier(&batadv_hard_if_notifier);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000073
Sven Eckelmann86ceb362012-03-07 09:07:45 +010074 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
Sven Eckelmann42d0b042012-06-03 22:19:17 +020075 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000076
77 return 0;
78}
79
Sven Eckelmannee11ad62012-05-16 20:23:19 +020080static void __exit batadv_exit(void)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000081{
Sven Eckelmann40a072d2012-05-12 02:09:23 +020082 batadv_debugfs_destroy();
Sven Eckelmann95638772012-05-12 02:09:31 +020083 unregister_netdevice_notifier(&batadv_hard_if_notifier);
84 batadv_hardif_remove_interfaces();
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000085
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020086 flush_workqueue(batadv_event_workqueue);
87 destroy_workqueue(batadv_event_workqueue);
88 batadv_event_workqueue = NULL;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000089
90 rcu_barrier();
91}
92
Sven Eckelmann3193e8f2012-05-12 02:09:42 +020093int batadv_mesh_init(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000094{
Sven Eckelmann56303d32012-06-05 22:31:31 +020095 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +020096 int ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000097
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +000098 spin_lock_init(&bat_priv->forw_bat_list_lock);
99 spin_lock_init(&bat_priv->forw_bcast_list_lock);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200100 spin_lock_init(&bat_priv->tt.changes_list_lock);
101 spin_lock_init(&bat_priv->tt.req_list_lock);
102 spin_lock_init(&bat_priv->tt.roam_list_lock);
103 spin_lock_init(&bat_priv->tt.last_changeset_lock);
104 spin_lock_init(&bat_priv->gw.list_lock);
105 spin_lock_init(&bat_priv->vis.hash_lock);
106 spin_lock_init(&bat_priv->vis.list_lock);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000107
108 INIT_HLIST_HEAD(&bat_priv->forw_bat_list);
109 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200110 INIT_HLIST_HEAD(&bat_priv->gw.list);
111 INIT_LIST_HEAD(&bat_priv->tt.changes_list);
112 INIT_LIST_HEAD(&bat_priv->tt.req_list);
113 INIT_LIST_HEAD(&bat_priv->tt.roam_list);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000114
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200115 ret = batadv_originator_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200116 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000117 goto err;
118
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200119 ret = batadv_tt_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200120 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000121 goto err;
122
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200123 batadv_tt_local_add(soft_iface, soft_iface->dev_addr,
124 BATADV_NULL_IFINDEX);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000125
Sven Eckelmannd0f714f2012-05-12 02:09:41 +0200126 ret = batadv_vis_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200127 if (ret < 0)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000128 goto err;
129
Sven Eckelmann08adf152012-05-12 13:38:47 +0200130 ret = batadv_bla_init(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200131 if (ret < 0)
Simon Wunderlich23721382012-01-22 20:00:19 +0100132 goto err;
133
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200134 ret = batadv_dat_init(bat_priv);
135 if (ret < 0)
136 goto err;
137
Sven Eckelmann807736f2012-07-15 22:26:51 +0200138 atomic_set(&bat_priv->gw.reselect, 0);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200139 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200140
141 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000142
143err:
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200144 batadv_mesh_free(soft_iface);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200145 return ret;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000146}
147
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200148void batadv_mesh_free(struct net_device *soft_iface)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000149{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200150 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000151
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200152 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000153
Sven Eckelmann9455e342012-05-12 02:09:37 +0200154 batadv_purge_outstanding_packets(bat_priv, NULL);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000155
Sven Eckelmannd0f714f2012-05-12 02:09:41 +0200156 batadv_vis_quit(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000157
Sven Eckelmann7cf06bc2012-05-12 02:09:29 +0200158 batadv_gw_node_purge(bat_priv);
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200159 batadv_originator_free(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000160
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200161 batadv_tt_free(bat_priv);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000162
Sven Eckelmann08adf152012-05-12 13:38:47 +0200163 batadv_bla_free(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +0100164
Antonio Quartulli2f1dfbe2012-06-30 20:01:19 +0200165 batadv_dat_free(bat_priv);
166
Martin Hundebøllf8214862012-04-20 17:02:45 +0200167 free_percpu(bat_priv->bat_counters);
168
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200169 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000170}
171
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200172int batadv_is_my_mac(const uint8_t *addr)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000173{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200174 const struct batadv_hard_iface *hard_iface;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000175
176 rcu_read_lock();
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200177 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200178 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000179 continue;
180
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200181 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) {
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000182 rcu_read_unlock();
183 return 1;
184 }
185 }
186 rcu_read_unlock();
187 return 0;
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000188}
189
Marek Lindner30da63a2012-08-03 17:15:46 +0200190/**
191 * batadv_seq_print_text_primary_if_get - called from debugfs table printing
192 * function that requires the primary interface
193 * @seq: debugfs table seq_file struct
194 *
195 * Returns primary interface if found or NULL otherwise.
196 */
197struct batadv_hard_iface *
198batadv_seq_print_text_primary_if_get(struct seq_file *seq)
199{
200 struct net_device *net_dev = (struct net_device *)seq->private;
201 struct batadv_priv *bat_priv = netdev_priv(net_dev);
202 struct batadv_hard_iface *primary_if;
203
204 primary_if = batadv_primary_if_get_selected(bat_priv);
205
206 if (!primary_if) {
207 seq_printf(seq,
208 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
209 net_dev->name);
210 goto out;
211 }
212
213 if (primary_if->if_status == BATADV_IF_ACTIVE)
214 goto out;
215
216 seq_printf(seq,
217 "BATMAN mesh %s disabled - primary interface not active\n",
218 net_dev->name);
219 batadv_hardif_free_ref(primary_if);
220 primary_if = NULL;
221
222out:
223 return primary_if;
224}
225
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200226static int batadv_recv_unhandled_packet(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +0200227 struct batadv_hard_iface *recv_if)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800228{
229 return NET_RX_DROP;
230}
231
232/* incoming packets with the batman ethertype received on any active hard
233 * interface
234 */
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200235int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
236 struct packet_type *ptype,
237 struct net_device *orig_dev)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800238{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200239 struct batadv_priv *bat_priv;
Sven Eckelmann96412692012-06-05 22:31:30 +0200240 struct batadv_ogm_packet *batadv_ogm_packet;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200241 struct batadv_hard_iface *hard_iface;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800242 uint8_t idx;
243 int ret;
244
Sven Eckelmann56303d32012-06-05 22:31:31 +0200245 hard_iface = container_of(ptype, struct batadv_hard_iface,
246 batman_adv_ptype);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800247 skb = skb_share_check(skb, GFP_ATOMIC);
248
249 /* skb was released by skb_share_check() */
250 if (!skb)
251 goto err_out;
252
253 /* packet should hold at least type and version */
254 if (unlikely(!pskb_may_pull(skb, 2)))
255 goto err_free;
256
257 /* expect a valid ethernet header here. */
258 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb)))
259 goto err_free;
260
261 if (!hard_iface->soft_iface)
262 goto err_free;
263
264 bat_priv = netdev_priv(hard_iface->soft_iface);
265
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200266 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800267 goto err_free;
268
269 /* discard frames on not active interfaces */
Sven Eckelmanne9a4f292012-06-03 22:19:19 +0200270 if (hard_iface->if_status != BATADV_IF_ACTIVE)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800271 goto err_free;
272
Sven Eckelmann96412692012-06-05 22:31:30 +0200273 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800274
Sven Eckelmann96412692012-06-05 22:31:30 +0200275 if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200276 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200277 "Drop packet: incompatible batman version (%i)\n",
Sven Eckelmann96412692012-06-05 22:31:30 +0200278 batadv_ogm_packet->header.version);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800279 goto err_free;
280 }
281
282 /* all receive handlers return whether they received or reused
283 * the supplied skb. if not, we have to free the skb.
284 */
Sven Eckelmann96412692012-06-05 22:31:30 +0200285 idx = batadv_ogm_packet->header.packet_type;
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200286 ret = (*batadv_rx_handler[idx])(skb, hard_iface);
Marek Lindnerffa995e2012-03-01 15:35:17 +0800287
288 if (ret == NET_RX_DROP)
289 kfree_skb(skb);
290
291 /* return NET_RX_SUCCESS in any case as we
292 * most probably dropped the packet for
293 * routing-logical reasons.
294 */
295 return NET_RX_SUCCESS;
296
297err_free:
298 kfree_skb(skb);
299err_out:
300 return NET_RX_DROP;
301}
302
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200303static void batadv_recv_handler_init(void)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800304{
305 int i;
306
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200307 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++)
308 batadv_rx_handler[i] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800309
Marek Lindnerffa995e2012-03-01 15:35:17 +0800310 /* batman icmp packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200311 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet;
Antonio Quartulli7cdcf6d2012-10-01 09:57:35 +0200312 /* unicast with 4 addresses packet */
313 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800314 /* unicast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200315 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800316 /* fragmented unicast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200317 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_ucast_frag_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800318 /* broadcast packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200319 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800320 /* vis packet */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200321 batadv_rx_handler[BATADV_VIS] = batadv_recv_vis_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800322 /* Translation table query (request or response) */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200323 batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800324 /* Roaming advertisement */
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200325 batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800326}
327
Sven Eckelmann56303d32012-06-05 22:31:31 +0200328int
329batadv_recv_handler_register(uint8_t packet_type,
330 int (*recv_handler)(struct sk_buff *,
331 struct batadv_hard_iface *))
Marek Lindnerffa995e2012-03-01 15:35:17 +0800332{
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200333 if (batadv_rx_handler[packet_type] != &batadv_recv_unhandled_packet)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800334 return -EBUSY;
335
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200336 batadv_rx_handler[packet_type] = recv_handler;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800337 return 0;
338}
339
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200340void batadv_recv_handler_unregister(uint8_t packet_type)
Marek Lindnerffa995e2012-03-01 15:35:17 +0800341{
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200342 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet;
Marek Lindnerffa995e2012-03-01 15:35:17 +0800343}
344
Sven Eckelmann56303d32012-06-05 22:31:31 +0200345static struct batadv_algo_ops *batadv_algo_get(char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800346{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200347 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp;
Marek Lindner1c280472011-11-28 17:40:17 +0800348 struct hlist_node *node;
349
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200350 hlist_for_each_entry(bat_algo_ops_tmp, node, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800351 if (strcmp(bat_algo_ops_tmp->name, name) != 0)
352 continue;
353
354 bat_algo_ops = bat_algo_ops_tmp;
355 break;
356 }
357
358 return bat_algo_ops;
359}
360
Sven Eckelmann56303d32012-06-05 22:31:31 +0200361int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops)
Marek Lindner1c280472011-11-28 17:40:17 +0800362{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200363 struct batadv_algo_ops *bat_algo_ops_tmp;
Sven Eckelmann5346c352012-05-05 13:27:28 +0200364 int ret;
Marek Lindner1c280472011-11-28 17:40:17 +0800365
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200366 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name);
Marek Lindner1c280472011-11-28 17:40:17 +0800367 if (bat_algo_ops_tmp) {
Sven Eckelmann86ceb362012-03-07 09:07:45 +0100368 pr_info("Trying to register already registered routing algorithm: %s\n",
369 bat_algo_ops->name);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200370 ret = -EEXIST;
Marek Lindner1c280472011-11-28 17:40:17 +0800371 goto out;
372 }
373
Marek Lindner01c42242011-11-28 21:31:55 +0800374 /* all algorithms must implement all ops (for now) */
Marek Lindnerc2aca022012-02-07 17:20:45 +0800375 if (!bat_algo_ops->bat_iface_enable ||
Marek Lindner00a50072012-02-07 17:20:47 +0800376 !bat_algo_ops->bat_iface_disable ||
Marek Lindnerc3229392012-03-11 06:17:50 +0800377 !bat_algo_ops->bat_iface_update_mac ||
Marek Lindnercd8b78e2012-02-07 17:20:49 +0800378 !bat_algo_ops->bat_primary_iface_set ||
Marek Lindner01c42242011-11-28 21:31:55 +0800379 !bat_algo_ops->bat_ogm_schedule ||
Marek Lindnerc3e29312012-03-04 16:56:25 +0800380 !bat_algo_ops->bat_ogm_emit) {
Marek Lindner01c42242011-11-28 21:31:55 +0800381 pr_info("Routing algo '%s' does not implement required ops\n",
382 bat_algo_ops->name);
Sven Eckelmann5346c352012-05-05 13:27:28 +0200383 ret = -EINVAL;
Marek Lindner01c42242011-11-28 21:31:55 +0800384 goto out;
385 }
386
Marek Lindner1c280472011-11-28 17:40:17 +0800387 INIT_HLIST_NODE(&bat_algo_ops->list);
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200388 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list);
Marek Lindner1c280472011-11-28 17:40:17 +0800389 ret = 0;
390
391out:
392 return ret;
393}
394
Sven Eckelmann56303d32012-06-05 22:31:31 +0200395int batadv_algo_select(struct batadv_priv *bat_priv, char *name)
Marek Lindner1c280472011-11-28 17:40:17 +0800396{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200397 struct batadv_algo_ops *bat_algo_ops;
Sven Eckelmann5346c352012-05-05 13:27:28 +0200398 int ret = -EINVAL;
Marek Lindner1c280472011-11-28 17:40:17 +0800399
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200400 bat_algo_ops = batadv_algo_get(name);
Marek Lindner1c280472011-11-28 17:40:17 +0800401 if (!bat_algo_ops)
402 goto out;
403
404 bat_priv->bat_algo_ops = bat_algo_ops;
405 ret = 0;
406
407out:
408 return ret;
409}
410
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200411int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
Marek Lindner1c280472011-11-28 17:40:17 +0800412{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200413 struct batadv_algo_ops *bat_algo_ops;
Marek Lindner1c280472011-11-28 17:40:17 +0800414 struct hlist_node *node;
415
416 seq_printf(seq, "Available routing algorithms:\n");
417
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200418 hlist_for_each_entry(bat_algo_ops, node, &batadv_algo_list, list) {
Marek Lindner1c280472011-11-28 17:40:17 +0800419 seq_printf(seq, "%s\n", bat_algo_ops->name);
420 }
421
422 return 0;
423}
424
Sven Eckelmann95a066d2012-10-17 21:10:39 +0200425/**
426 * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in
427 * the header
428 * @skb: skb pointing to fragmented socket buffers
429 * @payload_ptr: Pointer to position inside the head buffer of the skb
430 * marking the start of the data to be CRC'ed
431 *
432 * payload_ptr must always point to an address in the skb head buffer and not to
433 * a fragment.
434 */
435__be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr)
436{
437 u32 crc = 0;
438 unsigned int from;
439 unsigned int to = skb->len;
440 struct skb_seq_state st;
441 const u8 *data;
442 unsigned int len;
443 unsigned int consumed = 0;
444
445 from = (unsigned int)(payload_ptr - skb->data);
446
447 skb_prepare_seq_read(skb, from, to, &st);
448 while ((len = skb_seq_read(consumed, &data, &st)) != 0) {
449 crc = crc32c(crc, data, len);
450 consumed += len;
451 }
452 skb_abort_seq_read(&st);
453
454 return htonl(crc);
455}
456
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200457static int batadv_param_set_ra(const char *val, const struct kernel_param *kp)
Marek Lindnerd419be12011-12-10 19:45:53 +0800458{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200459 struct batadv_algo_ops *bat_algo_ops;
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800460 char *algo_name = (char *)val;
461 size_t name_len = strlen(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +0800462
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800463 if (algo_name[name_len - 1] == '\n')
464 algo_name[name_len - 1] = '\0';
465
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200466 bat_algo_ops = batadv_algo_get(algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +0800467 if (!bat_algo_ops) {
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800468 pr_err("Routing algorithm '%s' is not supported\n", algo_name);
Marek Lindnerd419be12011-12-10 19:45:53 +0800469 return -EINVAL;
470 }
471
Marek Lindnerd8cb54862012-04-18 17:16:39 +0800472 return param_set_copystring(algo_name, kp);
Marek Lindnerd419be12011-12-10 19:45:53 +0800473}
474
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200475static const struct kernel_param_ops batadv_param_ops_ra = {
476 .set = batadv_param_set_ra,
Marek Lindnerd419be12011-12-10 19:45:53 +0800477 .get = param_get_string,
478};
479
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200480static struct kparam_string batadv_param_string_ra = {
Sven Eckelmann3193e8f2012-05-12 02:09:42 +0200481 .maxlen = sizeof(batadv_routing_algo),
482 .string = batadv_routing_algo,
Marek Lindnerd419be12011-12-10 19:45:53 +0800483};
484
Sven Eckelmannee11ad62012-05-16 20:23:19 +0200485module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra,
486 0644);
487module_init(batadv_init);
488module_exit(batadv_exit);
Sven Eckelmannc6c8fea2010-12-13 11:19:28 +0000489
490MODULE_LICENSE("GPL");
491
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200492MODULE_AUTHOR(BATADV_DRIVER_AUTHOR);
493MODULE_DESCRIPTION(BATADV_DRIVER_DESC);
494MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE);
495MODULE_VERSION(BATADV_SOURCE_VERSION);