1 /* 2 * Copyright (C) 2007-2011 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 "hard-interface.h" 24 #include "soft-interface.h" 25 #include "send.h" 26 #include "translation-table.h" 27 #include "routing.h" 28 #include "bat_sysfs.h" 29 #include "originator.h" 30 #include "hash.h" 31 32 #include <linux/if_arp.h> 33 34 /* protect update critical side of hardif_list - but not the content */ 35 static DEFINE_SPINLOCK(hardif_list_lock); 36 37 38 static int batman_skb_recv(struct sk_buff *skb, 39 struct net_device *dev, 40 struct packet_type *ptype, 41 struct net_device *orig_dev); 42 43 void hardif_free_rcu(struct rcu_head *rcu) 44 { 45 struct hard_iface *hard_iface; 46 47 hard_iface = container_of(rcu, struct hard_iface, rcu); 48 dev_put(hard_iface->net_dev); 49 kfree(hard_iface); 50 } 51 52 struct hard_iface *hardif_get_by_netdev(struct net_device *net_dev) 53 { 54 struct hard_iface *hard_iface; 55 56 rcu_read_lock(); 57 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 58 if (hard_iface->net_dev == net_dev && 59 atomic_inc_not_zero(&hard_iface->refcount)) 60 goto out; 61 } 62 63 hard_iface = NULL; 64 65 out: 66 rcu_read_unlock(); 67 return hard_iface; 68 } 69 70 static int is_valid_iface(struct net_device *net_dev) 71 { 72 if (net_dev->flags & IFF_LOOPBACK) 73 return 0; 74 75 if (net_dev->type != ARPHRD_ETHER) 76 return 0; 77 78 if (net_dev->addr_len != ETH_ALEN) 79 return 0; 80 81 /* no batman over batman */ 82 if (softif_is_valid(net_dev)) 83 return 0; 84 85 /* Device is being bridged */ 86 /* if (net_dev->priv_flags & IFF_BRIDGE_PORT) 87 return 0; */ 88 89 return 1; 90 } 91 92 static struct hard_iface *hardif_get_active(struct net_device *soft_iface) 93 { 94 struct hard_iface *hard_iface; 95 96 rcu_read_lock(); 97 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 98 if (hard_iface->soft_iface != soft_iface) 99 continue; 100 101 if (hard_iface->if_status == IF_ACTIVE && 102 atomic_inc_not_zero(&hard_iface->refcount)) 103 goto out; 104 } 105 106 hard_iface = NULL; 107 108 out: 109 rcu_read_unlock(); 110 return hard_iface; 111 } 112 113 static void update_primary_addr(struct bat_priv *bat_priv) 114 { 115 struct vis_packet *vis_packet; 116 117 vis_packet = (struct vis_packet *) 118 bat_priv->my_vis_info->skb_packet->data; 119 memcpy(vis_packet->vis_orig, 120 bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); 121 memcpy(vis_packet->sender_orig, 122 bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); 123 } 124 125 static void set_primary_if(struct bat_priv *bat_priv, 126 struct hard_iface *hard_iface) 127 { 128 struct batman_packet *batman_packet; 129 struct hard_iface *old_if; 130 131 if (hard_iface && !atomic_inc_not_zero(&hard_iface->refcount)) 132 hard_iface = NULL; 133 134 old_if = bat_priv->primary_if; 135 bat_priv->primary_if = hard_iface; 136 137 if (old_if) 138 hardif_free_ref(old_if); 139 140 if (!bat_priv->primary_if) 141 return; 142 143 batman_packet = (struct batman_packet *)(hard_iface->packet_buff); 144 batman_packet->flags = PRIMARIES_FIRST_HOP; 145 batman_packet->ttl = TTL; 146 147 update_primary_addr(bat_priv); 148 149 /*** 150 * hacky trick to make sure that we send the HNA information via 151 * our new primary interface 152 */ 153 atomic_set(&bat_priv->hna_local_changed, 1); 154 } 155 156 static bool hardif_is_iface_up(struct hard_iface *hard_iface) 157 { 158 if (hard_iface->net_dev->flags & IFF_UP) 159 return true; 160 161 return false; 162 } 163 164 static void update_mac_addresses(struct hard_iface *hard_iface) 165 { 166 memcpy(((struct batman_packet *)(hard_iface->packet_buff))->orig, 167 hard_iface->net_dev->dev_addr, ETH_ALEN); 168 memcpy(((struct batman_packet *)(hard_iface->packet_buff))->prev_sender, 169 hard_iface->net_dev->dev_addr, ETH_ALEN); 170 } 171 172 static void check_known_mac_addr(struct net_device *net_dev) 173 { 174 struct hard_iface *hard_iface; 175 176 rcu_read_lock(); 177 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 178 if ((hard_iface->if_status != IF_ACTIVE) && 179 (hard_iface->if_status != IF_TO_BE_ACTIVATED)) 180 continue; 181 182 if (hard_iface->net_dev == net_dev) 183 continue; 184 185 if (!compare_eth(hard_iface->net_dev->dev_addr, 186 net_dev->dev_addr)) 187 continue; 188 189 pr_warning("The newly added mac address (%pM) already exists " 190 "on: %s\n", net_dev->dev_addr, 191 hard_iface->net_dev->name); 192 pr_warning("It is strongly recommended to keep mac addresses " 193 "unique to avoid problems!\n"); 194 } 195 rcu_read_unlock(); 196 } 197 198 int hardif_min_mtu(struct net_device *soft_iface) 199 { 200 struct bat_priv *bat_priv = netdev_priv(soft_iface); 201 struct hard_iface *hard_iface; 202 /* allow big frames if all devices are capable to do so 203 * (have MTU > 1500 + BAT_HEADER_LEN) */ 204 int min_mtu = ETH_DATA_LEN; 205 206 if (atomic_read(&bat_priv->fragmentation)) 207 goto out; 208 209 rcu_read_lock(); 210 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 211 if ((hard_iface->if_status != IF_ACTIVE) && 212 (hard_iface->if_status != IF_TO_BE_ACTIVATED)) 213 continue; 214 215 if (hard_iface->soft_iface != soft_iface) 216 continue; 217 218 min_mtu = min_t(int, hard_iface->net_dev->mtu - BAT_HEADER_LEN, 219 min_mtu); 220 } 221 rcu_read_unlock(); 222 out: 223 return min_mtu; 224 } 225 226 /* adjusts the MTU if a new interface with a smaller MTU appeared. */ 227 void update_min_mtu(struct net_device *soft_iface) 228 { 229 int min_mtu; 230 231 min_mtu = hardif_min_mtu(soft_iface); 232 if (soft_iface->mtu != min_mtu) 233 soft_iface->mtu = min_mtu; 234 } 235 236 static void hardif_activate_interface(struct hard_iface *hard_iface) 237 { 238 struct bat_priv *bat_priv; 239 240 if (hard_iface->if_status != IF_INACTIVE) 241 return; 242 243 bat_priv = netdev_priv(hard_iface->soft_iface); 244 245 update_mac_addresses(hard_iface); 246 hard_iface->if_status = IF_TO_BE_ACTIVATED; 247 248 /** 249 * the first active interface becomes our primary interface or 250 * the next active interface after the old primay interface was removed 251 */ 252 if (!bat_priv->primary_if) 253 set_primary_if(bat_priv, hard_iface); 254 255 bat_info(hard_iface->soft_iface, "Interface activated: %s\n", 256 hard_iface->net_dev->name); 257 258 update_min_mtu(hard_iface->soft_iface); 259 return; 260 } 261 262 static void hardif_deactivate_interface(struct hard_iface *hard_iface) 263 { 264 if ((hard_iface->if_status != IF_ACTIVE) && 265 (hard_iface->if_status != IF_TO_BE_ACTIVATED)) 266 return; 267 268 hard_iface->if_status = IF_INACTIVE; 269 270 bat_info(hard_iface->soft_iface, "Interface deactivated: %s\n", 271 hard_iface->net_dev->name); 272 273 update_min_mtu(hard_iface->soft_iface); 274 } 275 276 int hardif_enable_interface(struct hard_iface *hard_iface, char *iface_name) 277 { 278 struct bat_priv *bat_priv; 279 struct batman_packet *batman_packet; 280 struct net_device *soft_iface; 281 int ret; 282 283 if (hard_iface->if_status != IF_NOT_IN_USE) 284 goto out; 285 286 if (!atomic_inc_not_zero(&hard_iface->refcount)) 287 goto out; 288 289 soft_iface = dev_get_by_name(&init_net, iface_name); 290 291 if (!soft_iface) { 292 soft_iface = softif_create(iface_name); 293 294 if (!soft_iface) { 295 ret = -ENOMEM; 296 goto err; 297 } 298 299 /* dev_get_by_name() increases the reference counter for us */ 300 dev_hold(soft_iface); 301 } 302 303 if (!softif_is_valid(soft_iface)) { 304 pr_err("Can't create batman mesh interface %s: " 305 "already exists as regular interface\n", 306 soft_iface->name); 307 dev_put(soft_iface); 308 ret = -EINVAL; 309 goto err; 310 } 311 312 hard_iface->soft_iface = soft_iface; 313 bat_priv = netdev_priv(hard_iface->soft_iface); 314 hard_iface->packet_len = BAT_PACKET_LEN; 315 hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC); 316 317 if (!hard_iface->packet_buff) { 318 bat_err(hard_iface->soft_iface, "Can't add interface packet " 319 "(%s): out of memory\n", hard_iface->net_dev->name); 320 ret = -ENOMEM; 321 goto err; 322 } 323 324 batman_packet = (struct batman_packet *)(hard_iface->packet_buff); 325 batman_packet->packet_type = BAT_PACKET; 326 batman_packet->version = COMPAT_VERSION; 327 batman_packet->flags = 0; 328 batman_packet->ttl = 2; 329 batman_packet->tq = TQ_MAX_VALUE; 330 batman_packet->num_hna = 0; 331 332 hard_iface->if_num = bat_priv->num_ifaces; 333 bat_priv->num_ifaces++; 334 hard_iface->if_status = IF_INACTIVE; 335 orig_hash_add_if(hard_iface, bat_priv->num_ifaces); 336 337 hard_iface->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN); 338 hard_iface->batman_adv_ptype.func = batman_skb_recv; 339 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; 340 dev_add_pack(&hard_iface->batman_adv_ptype); 341 342 atomic_set(&hard_iface->seqno, 1); 343 atomic_set(&hard_iface->frag_seqno, 1); 344 bat_info(hard_iface->soft_iface, "Adding interface: %s\n", 345 hard_iface->net_dev->name); 346 347 if (atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu < 348 ETH_DATA_LEN + BAT_HEADER_LEN) 349 bat_info(hard_iface->soft_iface, 350 "The MTU of interface %s is too small (%i) to handle " 351 "the transport of batman-adv packets. Packets going " 352 "over this interface will be fragmented on layer2 " 353 "which could impact the performance. Setting the MTU " 354 "to %zi would solve the problem.\n", 355 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 356 ETH_DATA_LEN + BAT_HEADER_LEN); 357 358 if (!atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu < 359 ETH_DATA_LEN + BAT_HEADER_LEN) 360 bat_info(hard_iface->soft_iface, 361 "The MTU of interface %s is too small (%i) to handle " 362 "the transport of batman-adv packets. If you experience" 363 " problems getting traffic through try increasing the " 364 "MTU to %zi.\n", 365 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 366 ETH_DATA_LEN + BAT_HEADER_LEN); 367 368 if (hardif_is_iface_up(hard_iface)) 369 hardif_activate_interface(hard_iface); 370 else 371 bat_err(hard_iface->soft_iface, "Not using interface %s " 372 "(retrying later): interface not active\n", 373 hard_iface->net_dev->name); 374 375 /* begin scheduling originator messages on that interface */ 376 schedule_own_packet(hard_iface); 377 378 out: 379 return 0; 380 381 err: 382 hardif_free_ref(hard_iface); 383 return ret; 384 } 385 386 void hardif_disable_interface(struct hard_iface *hard_iface) 387 { 388 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 389 390 if (hard_iface->if_status == IF_ACTIVE) 391 hardif_deactivate_interface(hard_iface); 392 393 if (hard_iface->if_status != IF_INACTIVE) 394 return; 395 396 bat_info(hard_iface->soft_iface, "Removing interface: %s\n", 397 hard_iface->net_dev->name); 398 dev_remove_pack(&hard_iface->batman_adv_ptype); 399 400 bat_priv->num_ifaces--; 401 orig_hash_del_if(hard_iface, bat_priv->num_ifaces); 402 403 if (hard_iface == bat_priv->primary_if) { 404 struct hard_iface *new_if; 405 406 new_if = hardif_get_active(hard_iface->soft_iface); 407 set_primary_if(bat_priv, new_if); 408 409 if (new_if) 410 hardif_free_ref(new_if); 411 } 412 413 kfree(hard_iface->packet_buff); 414 hard_iface->packet_buff = NULL; 415 hard_iface->if_status = IF_NOT_IN_USE; 416 417 /* delete all references to this hard_iface */ 418 purge_orig_ref(bat_priv); 419 purge_outstanding_packets(bat_priv, hard_iface); 420 dev_put(hard_iface->soft_iface); 421 422 /* nobody uses this interface anymore */ 423 if (!bat_priv->num_ifaces) 424 softif_destroy(hard_iface->soft_iface); 425 426 hard_iface->soft_iface = NULL; 427 hardif_free_ref(hard_iface); 428 } 429 430 static struct hard_iface *hardif_add_interface(struct net_device *net_dev) 431 { 432 struct hard_iface *hard_iface; 433 int ret; 434 435 ret = is_valid_iface(net_dev); 436 if (ret != 1) 437 goto out; 438 439 dev_hold(net_dev); 440 441 hard_iface = kmalloc(sizeof(struct hard_iface), GFP_ATOMIC); 442 if (!hard_iface) { 443 pr_err("Can't add interface (%s): out of memory\n", 444 net_dev->name); 445 goto release_dev; 446 } 447 448 ret = sysfs_add_hardif(&hard_iface->hardif_obj, net_dev); 449 if (ret) 450 goto free_if; 451 452 hard_iface->if_num = -1; 453 hard_iface->net_dev = net_dev; 454 hard_iface->soft_iface = NULL; 455 hard_iface->if_status = IF_NOT_IN_USE; 456 INIT_LIST_HEAD(&hard_iface->list); 457 /* extra reference for return */ 458 atomic_set(&hard_iface->refcount, 2); 459 460 check_known_mac_addr(hard_iface->net_dev); 461 462 spin_lock(&hardif_list_lock); 463 list_add_tail_rcu(&hard_iface->list, &hardif_list); 464 spin_unlock(&hardif_list_lock); 465 466 return hard_iface; 467 468 free_if: 469 kfree(hard_iface); 470 release_dev: 471 dev_put(net_dev); 472 out: 473 return NULL; 474 } 475 476 static void hardif_remove_interface(struct hard_iface *hard_iface) 477 { 478 /* first deactivate interface */ 479 if (hard_iface->if_status != IF_NOT_IN_USE) 480 hardif_disable_interface(hard_iface); 481 482 if (hard_iface->if_status != IF_NOT_IN_USE) 483 return; 484 485 hard_iface->if_status = IF_TO_BE_REMOVED; 486 sysfs_del_hardif(&hard_iface->hardif_obj); 487 hardif_free_ref(hard_iface); 488 } 489 490 void hardif_remove_interfaces(void) 491 { 492 struct hard_iface *hard_iface, *hard_iface_tmp; 493 struct list_head if_queue; 494 495 INIT_LIST_HEAD(&if_queue); 496 497 spin_lock(&hardif_list_lock); 498 list_for_each_entry_safe(hard_iface, hard_iface_tmp, 499 &hardif_list, list) { 500 list_del_rcu(&hard_iface->list); 501 list_add_tail(&hard_iface->list, &if_queue); 502 } 503 spin_unlock(&hardif_list_lock); 504 505 rtnl_lock(); 506 list_for_each_entry_safe(hard_iface, hard_iface_tmp, &if_queue, list) { 507 hardif_remove_interface(hard_iface); 508 } 509 rtnl_unlock(); 510 } 511 512 static int hard_if_event(struct notifier_block *this, 513 unsigned long event, void *ptr) 514 { 515 struct net_device *net_dev = (struct net_device *)ptr; 516 struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev); 517 struct bat_priv *bat_priv; 518 519 if (!hard_iface && event == NETDEV_REGISTER) 520 hard_iface = hardif_add_interface(net_dev); 521 522 if (!hard_iface) 523 goto out; 524 525 switch (event) { 526 case NETDEV_UP: 527 hardif_activate_interface(hard_iface); 528 break; 529 case NETDEV_GOING_DOWN: 530 case NETDEV_DOWN: 531 hardif_deactivate_interface(hard_iface); 532 break; 533 case NETDEV_UNREGISTER: 534 spin_lock(&hardif_list_lock); 535 list_del_rcu(&hard_iface->list); 536 spin_unlock(&hardif_list_lock); 537 538 hardif_remove_interface(hard_iface); 539 break; 540 case NETDEV_CHANGEMTU: 541 if (hard_iface->soft_iface) 542 update_min_mtu(hard_iface->soft_iface); 543 break; 544 case NETDEV_CHANGEADDR: 545 if (hard_iface->if_status == IF_NOT_IN_USE) 546 goto hardif_put; 547 548 check_known_mac_addr(hard_iface->net_dev); 549 update_mac_addresses(hard_iface); 550 551 bat_priv = netdev_priv(hard_iface->soft_iface); 552 if (hard_iface == bat_priv->primary_if) 553 update_primary_addr(bat_priv); 554 break; 555 default: 556 break; 557 }; 558 559 hardif_put: 560 hardif_free_ref(hard_iface); 561 out: 562 return NOTIFY_DONE; 563 } 564 565 /* receive a packet with the batman ethertype coming on a hard 566 * interface */ 567 static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev, 568 struct packet_type *ptype, 569 struct net_device *orig_dev) 570 { 571 struct bat_priv *bat_priv; 572 struct batman_packet *batman_packet; 573 struct hard_iface *hard_iface; 574 int ret; 575 576 hard_iface = container_of(ptype, struct hard_iface, batman_adv_ptype); 577 skb = skb_share_check(skb, GFP_ATOMIC); 578 579 /* skb was released by skb_share_check() */ 580 if (!skb) 581 goto err_out; 582 583 /* packet should hold at least type and version */ 584 if (unlikely(!pskb_may_pull(skb, 2))) 585 goto err_free; 586 587 /* expect a valid ethernet header here. */ 588 if (unlikely(skb->mac_len != sizeof(struct ethhdr) 589 || !skb_mac_header(skb))) 590 goto err_free; 591 592 if (!hard_iface->soft_iface) 593 goto err_free; 594 595 bat_priv = netdev_priv(hard_iface->soft_iface); 596 597 if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE) 598 goto err_free; 599 600 /* discard frames on not active interfaces */ 601 if (hard_iface->if_status != IF_ACTIVE) 602 goto err_free; 603 604 batman_packet = (struct batman_packet *)skb->data; 605 606 if (batman_packet->version != COMPAT_VERSION) { 607 bat_dbg(DBG_BATMAN, bat_priv, 608 "Drop packet: incompatible batman version (%i)\n", 609 batman_packet->version); 610 goto err_free; 611 } 612 613 /* all receive handlers return whether they received or reused 614 * the supplied skb. if not, we have to free the skb. */ 615 616 switch (batman_packet->packet_type) { 617 /* batman originator packet */ 618 case BAT_PACKET: 619 ret = recv_bat_packet(skb, hard_iface); 620 break; 621 622 /* batman icmp packet */ 623 case BAT_ICMP: 624 ret = recv_icmp_packet(skb, hard_iface); 625 break; 626 627 /* unicast packet */ 628 case BAT_UNICAST: 629 ret = recv_unicast_packet(skb, hard_iface); 630 break; 631 632 /* fragmented unicast packet */ 633 case BAT_UNICAST_FRAG: 634 ret = recv_ucast_frag_packet(skb, hard_iface); 635 break; 636 637 /* broadcast packet */ 638 case BAT_BCAST: 639 ret = recv_bcast_packet(skb, hard_iface); 640 break; 641 642 /* vis packet */ 643 case BAT_VIS: 644 ret = recv_vis_packet(skb, hard_iface); 645 break; 646 default: 647 ret = NET_RX_DROP; 648 } 649 650 if (ret == NET_RX_DROP) 651 kfree_skb(skb); 652 653 /* return NET_RX_SUCCESS in any case as we 654 * most probably dropped the packet for 655 * routing-logical reasons. */ 656 657 return NET_RX_SUCCESS; 658 659 err_free: 660 kfree_skb(skb); 661 err_out: 662 return NET_RX_DROP; 663 } 664 665 struct notifier_block hard_if_notifier = { 666 .notifier_call = hard_if_event, 667 }; 668