1 /* 2 * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of version 2 of the GNU General Public 8 * License as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 18 * 02110-1301, USA 19 * 20 */ 21 22 #include "main.h" 23 #include "bat_sysfs.h" 24 #include "bat_debugfs.h" 25 #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" 33 #include "bridge_loop_avoidance.h" 34 #include "vis.h" 35 #include "hash.h" 36 #include "bat_algo.h" 37 38 39 /* List manipulations on hardif_list have to be rtnl_lock()'ed, 40 * list traversals just rcu-locked */ 41 struct list_head batadv_hardif_list; 42 static int (*recv_packet_handler[256])(struct sk_buff *, struct hard_iface *); 43 char batadv_routing_algo[20] = "BATMAN_IV"; 44 static struct hlist_head bat_algo_list; 45 46 unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 47 48 struct workqueue_struct *batadv_event_workqueue; 49 50 static void recv_handler_init(void); 51 52 static int __init batman_init(void) 53 { 54 INIT_LIST_HEAD(&batadv_hardif_list); 55 INIT_HLIST_HEAD(&bat_algo_list); 56 57 recv_handler_init(); 58 59 batadv_iv_init(); 60 61 /* the name should not be longer than 10 chars - see 62 * http://lwn.net/Articles/23634/ */ 63 batadv_event_workqueue = create_singlethread_workqueue("bat_events"); 64 65 if (!batadv_event_workqueue) 66 return -ENOMEM; 67 68 batadv_socket_init(); 69 batadv_debugfs_init(); 70 71 register_netdevice_notifier(&batadv_hard_if_notifier); 72 73 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n", 74 SOURCE_VERSION, COMPAT_VERSION); 75 76 return 0; 77 } 78 79 static void __exit batman_exit(void) 80 { 81 batadv_debugfs_destroy(); 82 unregister_netdevice_notifier(&batadv_hard_if_notifier); 83 batadv_hardif_remove_interfaces(); 84 85 flush_workqueue(batadv_event_workqueue); 86 destroy_workqueue(batadv_event_workqueue); 87 batadv_event_workqueue = NULL; 88 89 rcu_barrier(); 90 } 91 92 int batadv_mesh_init(struct net_device *soft_iface) 93 { 94 struct bat_priv *bat_priv = netdev_priv(soft_iface); 95 int ret; 96 97 spin_lock_init(&bat_priv->forw_bat_list_lock); 98 spin_lock_init(&bat_priv->forw_bcast_list_lock); 99 spin_lock_init(&bat_priv->tt_changes_list_lock); 100 spin_lock_init(&bat_priv->tt_req_list_lock); 101 spin_lock_init(&bat_priv->tt_roam_list_lock); 102 spin_lock_init(&bat_priv->tt_buff_lock); 103 spin_lock_init(&bat_priv->gw_list_lock); 104 spin_lock_init(&bat_priv->vis_hash_lock); 105 spin_lock_init(&bat_priv->vis_list_lock); 106 107 INIT_HLIST_HEAD(&bat_priv->forw_bat_list); 108 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list); 109 INIT_HLIST_HEAD(&bat_priv->gw_list); 110 INIT_LIST_HEAD(&bat_priv->tt_changes_list); 111 INIT_LIST_HEAD(&bat_priv->tt_req_list); 112 INIT_LIST_HEAD(&bat_priv->tt_roam_list); 113 114 ret = batadv_originator_init(bat_priv); 115 if (ret < 0) 116 goto err; 117 118 ret = batadv_tt_init(bat_priv); 119 if (ret < 0) 120 goto err; 121 122 batadv_tt_local_add(soft_iface, soft_iface->dev_addr, NULL_IFINDEX); 123 124 ret = batadv_vis_init(bat_priv); 125 if (ret < 0) 126 goto err; 127 128 ret = batadv_bla_init(bat_priv); 129 if (ret < 0) 130 goto err; 131 132 atomic_set(&bat_priv->gw_reselect, 0); 133 atomic_set(&bat_priv->mesh_state, MESH_ACTIVE); 134 135 return 0; 136 137 err: 138 batadv_mesh_free(soft_iface); 139 return ret; 140 } 141 142 void batadv_mesh_free(struct net_device *soft_iface) 143 { 144 struct bat_priv *bat_priv = netdev_priv(soft_iface); 145 146 atomic_set(&bat_priv->mesh_state, MESH_DEACTIVATING); 147 148 batadv_purge_outstanding_packets(bat_priv, NULL); 149 150 batadv_vis_quit(bat_priv); 151 152 batadv_gw_node_purge(bat_priv); 153 batadv_originator_free(bat_priv); 154 155 batadv_tt_free(bat_priv); 156 157 batadv_bla_free(bat_priv); 158 159 free_percpu(bat_priv->bat_counters); 160 161 atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); 162 } 163 164 void batadv_inc_module_count(void) 165 { 166 try_module_get(THIS_MODULE); 167 } 168 169 void batadv_dec_module_count(void) 170 { 171 module_put(THIS_MODULE); 172 } 173 174 int batadv_is_my_mac(const uint8_t *addr) 175 { 176 const struct hard_iface *hard_iface; 177 178 rcu_read_lock(); 179 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 180 if (hard_iface->if_status != IF_ACTIVE) 181 continue; 182 183 if (compare_eth(hard_iface->net_dev->dev_addr, addr)) { 184 rcu_read_unlock(); 185 return 1; 186 } 187 } 188 rcu_read_unlock(); 189 return 0; 190 } 191 192 static int recv_unhandled_packet(struct sk_buff *skb, 193 struct hard_iface *recv_if) 194 { 195 return NET_RX_DROP; 196 } 197 198 /* incoming packets with the batman ethertype received on any active hard 199 * interface 200 */ 201 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, 202 struct packet_type *ptype, 203 struct net_device *orig_dev) 204 { 205 struct bat_priv *bat_priv; 206 struct batman_ogm_packet *batman_ogm_packet; 207 struct hard_iface *hard_iface; 208 uint8_t idx; 209 int ret; 210 211 hard_iface = container_of(ptype, struct hard_iface, batman_adv_ptype); 212 skb = skb_share_check(skb, GFP_ATOMIC); 213 214 /* skb was released by skb_share_check() */ 215 if (!skb) 216 goto err_out; 217 218 /* packet should hold at least type and version */ 219 if (unlikely(!pskb_may_pull(skb, 2))) 220 goto err_free; 221 222 /* expect a valid ethernet header here. */ 223 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb))) 224 goto err_free; 225 226 if (!hard_iface->soft_iface) 227 goto err_free; 228 229 bat_priv = netdev_priv(hard_iface->soft_iface); 230 231 if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE) 232 goto err_free; 233 234 /* discard frames on not active interfaces */ 235 if (hard_iface->if_status != IF_ACTIVE) 236 goto err_free; 237 238 batman_ogm_packet = (struct batman_ogm_packet *)skb->data; 239 240 if (batman_ogm_packet->header.version != COMPAT_VERSION) { 241 bat_dbg(DBG_BATMAN, bat_priv, 242 "Drop packet: incompatible batman version (%i)\n", 243 batman_ogm_packet->header.version); 244 goto err_free; 245 } 246 247 /* all receive handlers return whether they received or reused 248 * the supplied skb. if not, we have to free the skb. 249 */ 250 idx = batman_ogm_packet->header.packet_type; 251 ret = (*recv_packet_handler[idx])(skb, hard_iface); 252 253 if (ret == NET_RX_DROP) 254 kfree_skb(skb); 255 256 /* return NET_RX_SUCCESS in any case as we 257 * most probably dropped the packet for 258 * routing-logical reasons. 259 */ 260 return NET_RX_SUCCESS; 261 262 err_free: 263 kfree_skb(skb); 264 err_out: 265 return NET_RX_DROP; 266 } 267 268 static void recv_handler_init(void) 269 { 270 int i; 271 272 for (i = 0; i < ARRAY_SIZE(recv_packet_handler); i++) 273 recv_packet_handler[i] = recv_unhandled_packet; 274 275 /* batman icmp packet */ 276 recv_packet_handler[BAT_ICMP] = batadv_recv_icmp_packet; 277 /* unicast packet */ 278 recv_packet_handler[BAT_UNICAST] = batadv_recv_unicast_packet; 279 /* fragmented unicast packet */ 280 recv_packet_handler[BAT_UNICAST_FRAG] = batadv_recv_ucast_frag_packet; 281 /* broadcast packet */ 282 recv_packet_handler[BAT_BCAST] = batadv_recv_bcast_packet; 283 /* vis packet */ 284 recv_packet_handler[BAT_VIS] = batadv_recv_vis_packet; 285 /* Translation table query (request or response) */ 286 recv_packet_handler[BAT_TT_QUERY] = batadv_recv_tt_query; 287 /* Roaming advertisement */ 288 recv_packet_handler[BAT_ROAM_ADV] = batadv_recv_roam_adv; 289 } 290 291 int batadv_recv_handler_register(uint8_t packet_type, 292 int (*recv_handler)(struct sk_buff *, 293 struct hard_iface *)) 294 { 295 if (recv_packet_handler[packet_type] != &recv_unhandled_packet) 296 return -EBUSY; 297 298 recv_packet_handler[packet_type] = recv_handler; 299 return 0; 300 } 301 302 void batadv_recv_handler_unregister(uint8_t packet_type) 303 { 304 recv_packet_handler[packet_type] = recv_unhandled_packet; 305 } 306 307 static struct bat_algo_ops *bat_algo_get(char *name) 308 { 309 struct bat_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp; 310 struct hlist_node *node; 311 312 hlist_for_each_entry(bat_algo_ops_tmp, node, &bat_algo_list, list) { 313 if (strcmp(bat_algo_ops_tmp->name, name) != 0) 314 continue; 315 316 bat_algo_ops = bat_algo_ops_tmp; 317 break; 318 } 319 320 return bat_algo_ops; 321 } 322 323 int batadv_algo_register(struct bat_algo_ops *bat_algo_ops) 324 { 325 struct bat_algo_ops *bat_algo_ops_tmp; 326 int ret; 327 328 bat_algo_ops_tmp = bat_algo_get(bat_algo_ops->name); 329 if (bat_algo_ops_tmp) { 330 pr_info("Trying to register already registered routing algorithm: %s\n", 331 bat_algo_ops->name); 332 ret = -EEXIST; 333 goto out; 334 } 335 336 /* all algorithms must implement all ops (for now) */ 337 if (!bat_algo_ops->bat_iface_enable || 338 !bat_algo_ops->bat_iface_disable || 339 !bat_algo_ops->bat_iface_update_mac || 340 !bat_algo_ops->bat_primary_iface_set || 341 !bat_algo_ops->bat_ogm_schedule || 342 !bat_algo_ops->bat_ogm_emit) { 343 pr_info("Routing algo '%s' does not implement required ops\n", 344 bat_algo_ops->name); 345 ret = -EINVAL; 346 goto out; 347 } 348 349 INIT_HLIST_NODE(&bat_algo_ops->list); 350 hlist_add_head(&bat_algo_ops->list, &bat_algo_list); 351 ret = 0; 352 353 out: 354 return ret; 355 } 356 357 int batadv_algo_select(struct bat_priv *bat_priv, char *name) 358 { 359 struct bat_algo_ops *bat_algo_ops; 360 int ret = -EINVAL; 361 362 bat_algo_ops = bat_algo_get(name); 363 if (!bat_algo_ops) 364 goto out; 365 366 bat_priv->bat_algo_ops = bat_algo_ops; 367 ret = 0; 368 369 out: 370 return ret; 371 } 372 373 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset) 374 { 375 struct bat_algo_ops *bat_algo_ops; 376 struct hlist_node *node; 377 378 seq_printf(seq, "Available routing algorithms:\n"); 379 380 hlist_for_each_entry(bat_algo_ops, node, &bat_algo_list, list) { 381 seq_printf(seq, "%s\n", bat_algo_ops->name); 382 } 383 384 return 0; 385 } 386 387 static int param_set_ra(const char *val, const struct kernel_param *kp) 388 { 389 struct bat_algo_ops *bat_algo_ops; 390 char *algo_name = (char *)val; 391 size_t name_len = strlen(algo_name); 392 393 if (algo_name[name_len - 1] == '\n') 394 algo_name[name_len - 1] = '\0'; 395 396 bat_algo_ops = bat_algo_get(algo_name); 397 if (!bat_algo_ops) { 398 pr_err("Routing algorithm '%s' is not supported\n", algo_name); 399 return -EINVAL; 400 } 401 402 return param_set_copystring(algo_name, kp); 403 } 404 405 static const struct kernel_param_ops param_ops_ra = { 406 .set = param_set_ra, 407 .get = param_get_string, 408 }; 409 410 static struct kparam_string __param_string_ra = { 411 .maxlen = sizeof(batadv_routing_algo), 412 .string = batadv_routing_algo, 413 }; 414 415 module_param_cb(routing_algo, ¶m_ops_ra, &__param_string_ra, 0644); 416 module_init(batman_init); 417 module_exit(batman_exit); 418 419 MODULE_LICENSE("GPL"); 420 421 MODULE_AUTHOR(DRIVER_AUTHOR); 422 MODULE_DESCRIPTION(DRIVER_DESC); 423 MODULE_SUPPORTED_DEVICE(DRIVER_DEVICE); 424 MODULE_VERSION(SOURCE_VERSION); 425