1 /* Copyright (C) 2007-2013 B.A.T.M.A.N. contributors: 2 * 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 18 */ 19 20 #include <linux/crc32c.h> 21 #include <linux/highmem.h> 22 #include "main.h" 23 #include "sysfs.h" 24 #include "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 "distributed-arp-table.h" 35 #include "vis.h" 36 #include "hash.h" 37 #include "bat_algo.h" 38 #include "network-coding.h" 39 40 41 /* List manipulations on hardif_list have to be rtnl_lock()'ed, 42 * list traversals just rcu-locked 43 */ 44 struct list_head batadv_hardif_list; 45 static int (*batadv_rx_handler[256])(struct sk_buff *, 46 struct batadv_hard_iface *); 47 char batadv_routing_algo[20] = "BATMAN_IV"; 48 static struct hlist_head batadv_algo_list; 49 50 unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 51 52 struct workqueue_struct *batadv_event_workqueue; 53 54 static void batadv_recv_handler_init(void); 55 batadv_init(void)56 static int __init batadv_init(void) 57 { 58 INIT_LIST_HEAD(&batadv_hardif_list); 59 INIT_HLIST_HEAD(&batadv_algo_list); 60 61 batadv_recv_handler_init(); 62 63 batadv_iv_init(); 64 65 batadv_event_workqueue = create_singlethread_workqueue("bat_events"); 66 67 if (!batadv_event_workqueue) 68 return -ENOMEM; 69 70 batadv_socket_init(); 71 batadv_debugfs_init(); 72 73 register_netdevice_notifier(&batadv_hard_if_notifier); 74 rtnl_link_register(&batadv_link_ops); 75 76 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n", 77 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION); 78 79 return 0; 80 } 81 batadv_exit(void)82 static void __exit batadv_exit(void) 83 { 84 batadv_debugfs_destroy(); 85 rtnl_link_unregister(&batadv_link_ops); 86 unregister_netdevice_notifier(&batadv_hard_if_notifier); 87 batadv_hardif_remove_interfaces(); 88 89 flush_workqueue(batadv_event_workqueue); 90 destroy_workqueue(batadv_event_workqueue); 91 batadv_event_workqueue = NULL; 92 93 rcu_barrier(); 94 } 95 batadv_mesh_init(struct net_device * soft_iface)96 int batadv_mesh_init(struct net_device *soft_iface) 97 { 98 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 99 int ret; 100 101 spin_lock_init(&bat_priv->forw_bat_list_lock); 102 spin_lock_init(&bat_priv->forw_bcast_list_lock); 103 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); 110 111 INIT_HLIST_HEAD(&bat_priv->forw_bat_list); 112 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list); 113 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); 117 118 ret = batadv_originator_init(bat_priv); 119 if (ret < 0) 120 goto err; 121 122 ret = batadv_tt_init(bat_priv); 123 if (ret < 0) 124 goto err; 125 126 batadv_tt_local_add(soft_iface, soft_iface->dev_addr, 127 BATADV_NULL_IFINDEX); 128 129 ret = batadv_vis_init(bat_priv); 130 if (ret < 0) 131 goto err; 132 133 ret = batadv_bla_init(bat_priv); 134 if (ret < 0) 135 goto err; 136 137 ret = batadv_dat_init(bat_priv); 138 if (ret < 0) 139 goto err; 140 141 ret = batadv_nc_init(bat_priv); 142 if (ret < 0) 143 goto err; 144 145 atomic_set(&bat_priv->gw.reselect, 0); 146 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE); 147 148 return 0; 149 150 err: 151 batadv_mesh_free(soft_iface); 152 return ret; 153 } 154 batadv_mesh_free(struct net_device * soft_iface)155 void batadv_mesh_free(struct net_device *soft_iface) 156 { 157 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 158 159 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING); 160 161 batadv_purge_outstanding_packets(bat_priv, NULL); 162 163 batadv_vis_quit(bat_priv); 164 165 batadv_gw_node_purge(bat_priv); 166 batadv_nc_free(bat_priv); 167 batadv_dat_free(bat_priv); 168 batadv_bla_free(bat_priv); 169 170 /* 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); 182 183 free_percpu(bat_priv->bat_counters); 184 bat_priv->bat_counters = NULL; 185 186 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE); 187 } 188 189 /** 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 */ batadv_is_my_mac(struct batadv_priv * bat_priv,const uint8_t * addr)195 int batadv_is_my_mac(struct batadv_priv *bat_priv, const uint8_t *addr) 196 { 197 const struct batadv_hard_iface *hard_iface; 198 199 rcu_read_lock(); 200 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 201 if (hard_iface->if_status != BATADV_IF_ACTIVE) 202 continue; 203 204 if (hard_iface->soft_iface != bat_priv->soft_iface) 205 continue; 206 207 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) { 208 rcu_read_unlock(); 209 return 1; 210 } 211 } 212 rcu_read_unlock(); 213 return 0; 214 } 215 216 /** 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 */ 223 struct batadv_hard_iface * batadv_seq_print_text_primary_if_get(struct seq_file * seq)224 batadv_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 248 out: 249 return primary_if; 250 } 251 batadv_recv_unhandled_packet(struct sk_buff * skb,struct batadv_hard_iface * recv_if)252 static int batadv_recv_unhandled_packet(struct sk_buff *skb, 253 struct batadv_hard_iface *recv_if) 254 { 255 return NET_RX_DROP; 256 } 257 258 /* incoming packets with the batman ethertype received on any active hard 259 * interface 260 */ batadv_batman_skb_recv(struct sk_buff * skb,struct net_device * dev,struct packet_type * ptype,struct net_device * orig_dev)261 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, 262 struct packet_type *ptype, 263 struct net_device *orig_dev) 264 { 265 struct batadv_priv *bat_priv; 266 struct batadv_ogm_packet *batadv_ogm_packet; 267 struct batadv_hard_iface *hard_iface; 268 uint8_t idx; 269 int ret; 270 271 hard_iface = container_of(ptype, struct batadv_hard_iface, 272 batman_adv_ptype); 273 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 292 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) 293 goto err_free; 294 295 /* discard frames on not active interfaces */ 296 if (hard_iface->if_status != BATADV_IF_ACTIVE) 297 goto err_free; 298 299 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data; 300 301 if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) { 302 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 303 "Drop packet: incompatible batman version (%i)\n", 304 batadv_ogm_packet->header.version); 305 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 */ 311 idx = batadv_ogm_packet->header.packet_type; 312 ret = (*batadv_rx_handler[idx])(skb, hard_iface); 313 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 323 err_free: 324 kfree_skb(skb); 325 err_out: 326 return NET_RX_DROP; 327 } 328 batadv_recv_handler_init(void)329 static void batadv_recv_handler_init(void) 330 { 331 int i; 332 333 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++) 334 batadv_rx_handler[i] = batadv_recv_unhandled_packet; 335 336 /* batman icmp packet */ 337 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet; 338 /* unicast with 4 addresses packet */ 339 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet; 340 /* unicast packet */ 341 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet; 342 /* fragmented unicast packet */ 343 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_ucast_frag_packet; 344 /* broadcast packet */ 345 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet; 346 /* vis packet */ 347 batadv_rx_handler[BATADV_VIS] = batadv_recv_vis_packet; 348 /* Translation table query (request or response) */ 349 batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query; 350 /* Roaming advertisement */ 351 batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv; 352 } 353 354 int batadv_recv_handler_register(uint8_t packet_type,int (* recv_handler)(struct sk_buff *,struct batadv_hard_iface *))355 batadv_recv_handler_register(uint8_t packet_type, 356 int (*recv_handler)(struct sk_buff *, 357 struct batadv_hard_iface *)) 358 { 359 if (batadv_rx_handler[packet_type] != &batadv_recv_unhandled_packet) 360 return -EBUSY; 361 362 batadv_rx_handler[packet_type] = recv_handler; 363 return 0; 364 } 365 batadv_recv_handler_unregister(uint8_t packet_type)366 void batadv_recv_handler_unregister(uint8_t packet_type) 367 { 368 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet; 369 } 370 batadv_algo_get(char * name)371 static struct batadv_algo_ops *batadv_algo_get(char *name) 372 { 373 struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp; 374 375 hlist_for_each_entry(bat_algo_ops_tmp, &batadv_algo_list, list) { 376 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 batadv_algo_register(struct batadv_algo_ops * bat_algo_ops)386 int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops) 387 { 388 struct batadv_algo_ops *bat_algo_ops_tmp; 389 int ret; 390 391 bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name); 392 if (bat_algo_ops_tmp) { 393 pr_info("Trying to register already registered routing algorithm: %s\n", 394 bat_algo_ops->name); 395 ret = -EEXIST; 396 goto out; 397 } 398 399 /* all algorithms must implement all ops (for now) */ 400 if (!bat_algo_ops->bat_iface_enable || 401 !bat_algo_ops->bat_iface_disable || 402 !bat_algo_ops->bat_iface_update_mac || 403 !bat_algo_ops->bat_primary_iface_set || 404 !bat_algo_ops->bat_ogm_schedule || 405 !bat_algo_ops->bat_ogm_emit) { 406 pr_info("Routing algo '%s' does not implement required ops\n", 407 bat_algo_ops->name); 408 ret = -EINVAL; 409 goto out; 410 } 411 412 INIT_HLIST_NODE(&bat_algo_ops->list); 413 hlist_add_head(&bat_algo_ops->list, &batadv_algo_list); 414 ret = 0; 415 416 out: 417 return ret; 418 } 419 batadv_algo_select(struct batadv_priv * bat_priv,char * name)420 int batadv_algo_select(struct batadv_priv *bat_priv, char *name) 421 { 422 struct batadv_algo_ops *bat_algo_ops; 423 int ret = -EINVAL; 424 425 bat_algo_ops = batadv_algo_get(name); 426 if (!bat_algo_ops) 427 goto out; 428 429 bat_priv->bat_algo_ops = bat_algo_ops; 430 ret = 0; 431 432 out: 433 return ret; 434 } 435 batadv_algo_seq_print_text(struct seq_file * seq,void * offset)436 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset) 437 { 438 struct batadv_algo_ops *bat_algo_ops; 439 440 seq_puts(seq, "Available routing algorithms:\n"); 441 442 hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) { 443 seq_printf(seq, "%s\n", bat_algo_ops->name); 444 } 445 446 return 0; 447 } 448 449 /** 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 */ batadv_skb_crc32(struct sk_buff * skb,u8 * payload_ptr)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 batadv_param_set_ra(const char * val,const struct kernel_param * kp)481 static int batadv_param_set_ra(const char *val, const struct kernel_param *kp) 482 { 483 struct batadv_algo_ops *bat_algo_ops; 484 char *algo_name = (char *)val; 485 size_t name_len = strlen(algo_name); 486 487 if (name_len > 0 && algo_name[name_len - 1] == '\n') 488 algo_name[name_len - 1] = '\0'; 489 490 bat_algo_ops = batadv_algo_get(algo_name); 491 if (!bat_algo_ops) { 492 pr_err("Routing algorithm '%s' is not supported\n", algo_name); 493 return -EINVAL; 494 } 495 496 return param_set_copystring(algo_name, kp); 497 } 498 499 static const struct kernel_param_ops batadv_param_ops_ra = { 500 .set = batadv_param_set_ra, 501 .get = param_get_string, 502 }; 503 504 static struct kparam_string batadv_param_string_ra = { 505 .maxlen = sizeof(batadv_routing_algo), 506 .string = batadv_routing_algo, 507 }; 508 509 module_param_cb(routing_algo, &batadv_param_ops_ra, &batadv_param_string_ra, 510 0644); 511 module_init(batadv_init); 512 module_exit(batadv_exit); 513 514 MODULE_LICENSE("GPL"); 515 516 MODULE_AUTHOR(BATADV_DRIVER_AUTHOR); 517 MODULE_DESCRIPTION(BATADV_DRIVER_DESC); 518 MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE); 519 MODULE_VERSION(BATADV_SOURCE_VERSION); 520