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 "routing.h" 24 #include "send.h" 25 #include "hash.h" 26 #include "soft-interface.h" 27 #include "hard-interface.h" 28 #include "icmp_socket.h" 29 #include "translation-table.h" 30 #include "originator.h" 31 #include "ring_buffer.h" 32 #include "vis.h" 33 #include "aggregation.h" 34 #include "gateway_common.h" 35 #include "gateway_client.h" 36 #include "unicast.h" 37 38 void slide_own_bcast_window(struct hard_iface *hard_iface) 39 { 40 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 41 struct hashtable_t *hash = bat_priv->orig_hash; 42 struct hlist_node *node; 43 struct hlist_head *head; 44 struct orig_node *orig_node; 45 unsigned long *word; 46 int i; 47 size_t word_index; 48 49 for (i = 0; i < hash->size; i++) { 50 head = &hash->table[i]; 51 52 rcu_read_lock(); 53 hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) { 54 spin_lock_bh(&orig_node->ogm_cnt_lock); 55 word_index = hard_iface->if_num * NUM_WORDS; 56 word = &(orig_node->bcast_own[word_index]); 57 58 bit_get_packet(bat_priv, word, 1, 0); 59 orig_node->bcast_own_sum[hard_iface->if_num] = 60 bit_packet_count(word); 61 spin_unlock_bh(&orig_node->ogm_cnt_lock); 62 } 63 rcu_read_unlock(); 64 } 65 } 66 67 static void update_TT(struct bat_priv *bat_priv, struct orig_node *orig_node, 68 unsigned char *tt_buff, int tt_buff_len) 69 { 70 if ((tt_buff_len != orig_node->tt_buff_len) || 71 ((tt_buff_len > 0) && 72 (orig_node->tt_buff_len > 0) && 73 (memcmp(orig_node->tt_buff, tt_buff, tt_buff_len) != 0))) { 74 75 if (orig_node->tt_buff_len > 0) 76 tt_global_del_orig(bat_priv, orig_node, 77 "originator changed tt"); 78 79 if ((tt_buff_len > 0) && (tt_buff)) 80 tt_global_add_orig(bat_priv, orig_node, 81 tt_buff, tt_buff_len); 82 } 83 } 84 85 static void update_route(struct bat_priv *bat_priv, 86 struct orig_node *orig_node, 87 struct neigh_node *neigh_node, 88 unsigned char *tt_buff, int tt_buff_len) 89 { 90 struct neigh_node *curr_router; 91 92 curr_router = orig_node_get_router(orig_node); 93 94 /* route deleted */ 95 if ((curr_router) && (!neigh_node)) { 96 97 bat_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n", 98 orig_node->orig); 99 tt_global_del_orig(bat_priv, orig_node, 100 "originator timed out"); 101 102 /* route added */ 103 } else if ((!curr_router) && (neigh_node)) { 104 105 bat_dbg(DBG_ROUTES, bat_priv, 106 "Adding route towards: %pM (via %pM)\n", 107 orig_node->orig, neigh_node->addr); 108 tt_global_add_orig(bat_priv, orig_node, 109 tt_buff, tt_buff_len); 110 111 /* route changed */ 112 } else { 113 bat_dbg(DBG_ROUTES, bat_priv, 114 "Changing route towards: %pM " 115 "(now via %pM - was via %pM)\n", 116 orig_node->orig, neigh_node->addr, 117 curr_router->addr); 118 } 119 120 if (curr_router) 121 neigh_node_free_ref(curr_router); 122 123 /* increase refcount of new best neighbor */ 124 if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount)) 125 neigh_node = NULL; 126 127 spin_lock_bh(&orig_node->neigh_list_lock); 128 rcu_assign_pointer(orig_node->router, neigh_node); 129 spin_unlock_bh(&orig_node->neigh_list_lock); 130 131 /* decrease refcount of previous best neighbor */ 132 if (curr_router) 133 neigh_node_free_ref(curr_router); 134 } 135 136 137 void update_routes(struct bat_priv *bat_priv, struct orig_node *orig_node, 138 struct neigh_node *neigh_node, unsigned char *tt_buff, 139 int tt_buff_len) 140 { 141 struct neigh_node *router = NULL; 142 143 if (!orig_node) 144 goto out; 145 146 router = orig_node_get_router(orig_node); 147 148 if (router != neigh_node) 149 update_route(bat_priv, orig_node, neigh_node, 150 tt_buff, tt_buff_len); 151 /* may be just TT changed */ 152 else 153 update_TT(bat_priv, orig_node, tt_buff, tt_buff_len); 154 155 out: 156 if (router) 157 neigh_node_free_ref(router); 158 } 159 160 static int is_bidirectional_neigh(struct orig_node *orig_node, 161 struct orig_node *orig_neigh_node, 162 struct batman_packet *batman_packet, 163 struct hard_iface *if_incoming) 164 { 165 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 166 struct neigh_node *neigh_node = NULL, *tmp_neigh_node; 167 struct hlist_node *node; 168 unsigned char total_count; 169 uint8_t orig_eq_count, neigh_rq_count, tq_own; 170 int tq_asym_penalty, ret = 0; 171 172 /* find corresponding one hop neighbor */ 173 rcu_read_lock(); 174 hlist_for_each_entry_rcu(tmp_neigh_node, node, 175 &orig_neigh_node->neigh_list, list) { 176 177 if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig)) 178 continue; 179 180 if (tmp_neigh_node->if_incoming != if_incoming) 181 continue; 182 183 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount)) 184 continue; 185 186 neigh_node = tmp_neigh_node; 187 break; 188 } 189 rcu_read_unlock(); 190 191 if (!neigh_node) 192 neigh_node = create_neighbor(orig_neigh_node, 193 orig_neigh_node, 194 orig_neigh_node->orig, 195 if_incoming); 196 197 if (!neigh_node) 198 goto out; 199 200 /* if orig_node is direct neighbour update neigh_node last_valid */ 201 if (orig_node == orig_neigh_node) 202 neigh_node->last_valid = jiffies; 203 204 orig_node->last_valid = jiffies; 205 206 /* find packet count of corresponding one hop neighbor */ 207 spin_lock_bh(&orig_node->ogm_cnt_lock); 208 orig_eq_count = orig_neigh_node->bcast_own_sum[if_incoming->if_num]; 209 neigh_rq_count = neigh_node->real_packet_count; 210 spin_unlock_bh(&orig_node->ogm_cnt_lock); 211 212 /* pay attention to not get a value bigger than 100 % */ 213 total_count = (orig_eq_count > neigh_rq_count ? 214 neigh_rq_count : orig_eq_count); 215 216 /* if we have too few packets (too less data) we set tq_own to zero */ 217 /* if we receive too few packets it is not considered bidirectional */ 218 if ((total_count < TQ_LOCAL_BIDRECT_SEND_MINIMUM) || 219 (neigh_rq_count < TQ_LOCAL_BIDRECT_RECV_MINIMUM)) 220 tq_own = 0; 221 else 222 /* neigh_node->real_packet_count is never zero as we 223 * only purge old information when getting new 224 * information */ 225 tq_own = (TQ_MAX_VALUE * total_count) / neigh_rq_count; 226 227 /* 228 * 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does 229 * affect the nearly-symmetric links only a little, but 230 * punishes asymmetric links more. This will give a value 231 * between 0 and TQ_MAX_VALUE 232 */ 233 tq_asym_penalty = TQ_MAX_VALUE - (TQ_MAX_VALUE * 234 (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) * 235 (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count) * 236 (TQ_LOCAL_WINDOW_SIZE - neigh_rq_count)) / 237 (TQ_LOCAL_WINDOW_SIZE * 238 TQ_LOCAL_WINDOW_SIZE * 239 TQ_LOCAL_WINDOW_SIZE); 240 241 batman_packet->tq = ((batman_packet->tq * tq_own * tq_asym_penalty) / 242 (TQ_MAX_VALUE * TQ_MAX_VALUE)); 243 244 bat_dbg(DBG_BATMAN, bat_priv, 245 "bidirectional: " 246 "orig = %-15pM neigh = %-15pM => own_bcast = %2i, " 247 "real recv = %2i, local tq: %3i, asym_penalty: %3i, " 248 "total tq: %3i\n", 249 orig_node->orig, orig_neigh_node->orig, total_count, 250 neigh_rq_count, tq_own, tq_asym_penalty, batman_packet->tq); 251 252 /* if link has the minimum required transmission quality 253 * consider it bidirectional */ 254 if (batman_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT) 255 ret = 1; 256 257 out: 258 if (neigh_node) 259 neigh_node_free_ref(neigh_node); 260 return ret; 261 } 262 263 /* caller must hold the neigh_list_lock */ 264 void bonding_candidate_del(struct orig_node *orig_node, 265 struct neigh_node *neigh_node) 266 { 267 /* this neighbor is not part of our candidate list */ 268 if (list_empty(&neigh_node->bonding_list)) 269 goto out; 270 271 list_del_rcu(&neigh_node->bonding_list); 272 INIT_LIST_HEAD(&neigh_node->bonding_list); 273 neigh_node_free_ref(neigh_node); 274 atomic_dec(&orig_node->bond_candidates); 275 276 out: 277 return; 278 } 279 280 static void bonding_candidate_add(struct orig_node *orig_node, 281 struct neigh_node *neigh_node) 282 { 283 struct hlist_node *node; 284 struct neigh_node *tmp_neigh_node, *router = NULL; 285 uint8_t interference_candidate = 0; 286 287 spin_lock_bh(&orig_node->neigh_list_lock); 288 289 /* only consider if it has the same primary address ... */ 290 if (!compare_eth(orig_node->orig, 291 neigh_node->orig_node->primary_addr)) 292 goto candidate_del; 293 294 router = orig_node_get_router(orig_node); 295 if (!router) 296 goto candidate_del; 297 298 /* ... and is good enough to be considered */ 299 if (neigh_node->tq_avg < router->tq_avg - BONDING_TQ_THRESHOLD) 300 goto candidate_del; 301 302 /** 303 * check if we have another candidate with the same mac address or 304 * interface. If we do, we won't select this candidate because of 305 * possible interference. 306 */ 307 hlist_for_each_entry_rcu(tmp_neigh_node, node, 308 &orig_node->neigh_list, list) { 309 310 if (tmp_neigh_node == neigh_node) 311 continue; 312 313 /* we only care if the other candidate is even 314 * considered as candidate. */ 315 if (list_empty(&tmp_neigh_node->bonding_list)) 316 continue; 317 318 if ((neigh_node->if_incoming == tmp_neigh_node->if_incoming) || 319 (compare_eth(neigh_node->addr, tmp_neigh_node->addr))) { 320 interference_candidate = 1; 321 break; 322 } 323 } 324 325 /* don't care further if it is an interference candidate */ 326 if (interference_candidate) 327 goto candidate_del; 328 329 /* this neighbor already is part of our candidate list */ 330 if (!list_empty(&neigh_node->bonding_list)) 331 goto out; 332 333 if (!atomic_inc_not_zero(&neigh_node->refcount)) 334 goto out; 335 336 list_add_rcu(&neigh_node->bonding_list, &orig_node->bond_list); 337 atomic_inc(&orig_node->bond_candidates); 338 goto out; 339 340 candidate_del: 341 bonding_candidate_del(orig_node, neigh_node); 342 343 out: 344 spin_unlock_bh(&orig_node->neigh_list_lock); 345 346 if (router) 347 neigh_node_free_ref(router); 348 } 349 350 /* copy primary address for bonding */ 351 static void bonding_save_primary(struct orig_node *orig_node, 352 struct orig_node *orig_neigh_node, 353 struct batman_packet *batman_packet) 354 { 355 if (!(batman_packet->flags & PRIMARIES_FIRST_HOP)) 356 return; 357 358 memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN); 359 } 360 361 static void update_orig(struct bat_priv *bat_priv, 362 struct orig_node *orig_node, 363 struct ethhdr *ethhdr, 364 struct batman_packet *batman_packet, 365 struct hard_iface *if_incoming, 366 unsigned char *tt_buff, int tt_buff_len, 367 char is_duplicate) 368 { 369 struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL; 370 struct neigh_node *router = NULL; 371 struct orig_node *orig_node_tmp; 372 struct hlist_node *node; 373 int tmp_tt_buff_len; 374 uint8_t bcast_own_sum_orig, bcast_own_sum_neigh; 375 376 bat_dbg(DBG_BATMAN, bat_priv, "update_originator(): " 377 "Searching and updating originator entry of received packet\n"); 378 379 rcu_read_lock(); 380 hlist_for_each_entry_rcu(tmp_neigh_node, node, 381 &orig_node->neigh_list, list) { 382 if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) && 383 (tmp_neigh_node->if_incoming == if_incoming) && 384 atomic_inc_not_zero(&tmp_neigh_node->refcount)) { 385 if (neigh_node) 386 neigh_node_free_ref(neigh_node); 387 neigh_node = tmp_neigh_node; 388 continue; 389 } 390 391 if (is_duplicate) 392 continue; 393 394 spin_lock_bh(&tmp_neigh_node->tq_lock); 395 ring_buffer_set(tmp_neigh_node->tq_recv, 396 &tmp_neigh_node->tq_index, 0); 397 tmp_neigh_node->tq_avg = 398 ring_buffer_avg(tmp_neigh_node->tq_recv); 399 spin_unlock_bh(&tmp_neigh_node->tq_lock); 400 } 401 402 if (!neigh_node) { 403 struct orig_node *orig_tmp; 404 405 orig_tmp = get_orig_node(bat_priv, ethhdr->h_source); 406 if (!orig_tmp) 407 goto unlock; 408 409 neigh_node = create_neighbor(orig_node, orig_tmp, 410 ethhdr->h_source, if_incoming); 411 412 orig_node_free_ref(orig_tmp); 413 if (!neigh_node) 414 goto unlock; 415 } else 416 bat_dbg(DBG_BATMAN, bat_priv, 417 "Updating existing last-hop neighbor of originator\n"); 418 419 rcu_read_unlock(); 420 421 orig_node->flags = batman_packet->flags; 422 neigh_node->last_valid = jiffies; 423 424 spin_lock_bh(&neigh_node->tq_lock); 425 ring_buffer_set(neigh_node->tq_recv, 426 &neigh_node->tq_index, 427 batman_packet->tq); 428 neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv); 429 spin_unlock_bh(&neigh_node->tq_lock); 430 431 if (!is_duplicate) { 432 orig_node->last_ttl = batman_packet->ttl; 433 neigh_node->last_ttl = batman_packet->ttl; 434 } 435 436 bonding_candidate_add(orig_node, neigh_node); 437 438 tmp_tt_buff_len = (tt_buff_len > batman_packet->num_tt * ETH_ALEN ? 439 batman_packet->num_tt * ETH_ALEN : tt_buff_len); 440 441 /* if this neighbor already is our next hop there is nothing 442 * to change */ 443 router = orig_node_get_router(orig_node); 444 if (router == neigh_node) 445 goto update_tt; 446 447 /* if this neighbor does not offer a better TQ we won't consider it */ 448 if (router && (router->tq_avg > neigh_node->tq_avg)) 449 goto update_tt; 450 451 /* if the TQ is the same and the link not more symetric we 452 * won't consider it either */ 453 if (router && (neigh_node->tq_avg == router->tq_avg)) { 454 orig_node_tmp = router->orig_node; 455 spin_lock_bh(&orig_node_tmp->ogm_cnt_lock); 456 bcast_own_sum_orig = 457 orig_node_tmp->bcast_own_sum[if_incoming->if_num]; 458 spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock); 459 460 orig_node_tmp = neigh_node->orig_node; 461 spin_lock_bh(&orig_node_tmp->ogm_cnt_lock); 462 bcast_own_sum_neigh = 463 orig_node_tmp->bcast_own_sum[if_incoming->if_num]; 464 spin_unlock_bh(&orig_node_tmp->ogm_cnt_lock); 465 466 if (bcast_own_sum_orig >= bcast_own_sum_neigh) 467 goto update_tt; 468 } 469 470 update_routes(bat_priv, orig_node, neigh_node, 471 tt_buff, tmp_tt_buff_len); 472 goto update_gw; 473 474 update_tt: 475 update_routes(bat_priv, orig_node, router, 476 tt_buff, tmp_tt_buff_len); 477 478 update_gw: 479 if (orig_node->gw_flags != batman_packet->gw_flags) 480 gw_node_update(bat_priv, orig_node, batman_packet->gw_flags); 481 482 orig_node->gw_flags = batman_packet->gw_flags; 483 484 /* restart gateway selection if fast or late switching was enabled */ 485 if ((orig_node->gw_flags) && 486 (atomic_read(&bat_priv->gw_mode) == GW_MODE_CLIENT) && 487 (atomic_read(&bat_priv->gw_sel_class) > 2)) 488 gw_check_election(bat_priv, orig_node); 489 490 goto out; 491 492 unlock: 493 rcu_read_unlock(); 494 out: 495 if (neigh_node) 496 neigh_node_free_ref(neigh_node); 497 if (router) 498 neigh_node_free_ref(router); 499 } 500 501 /* checks whether the host restarted and is in the protection time. 502 * returns: 503 * 0 if the packet is to be accepted 504 * 1 if the packet is to be ignored. 505 */ 506 static int window_protected(struct bat_priv *bat_priv, 507 int32_t seq_num_diff, 508 unsigned long *last_reset) 509 { 510 if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE) 511 || (seq_num_diff >= EXPECTED_SEQNO_RANGE)) { 512 if (time_after(jiffies, *last_reset + 513 msecs_to_jiffies(RESET_PROTECTION_MS))) { 514 515 *last_reset = jiffies; 516 bat_dbg(DBG_BATMAN, bat_priv, 517 "old packet received, start protection\n"); 518 519 return 0; 520 } else 521 return 1; 522 } 523 return 0; 524 } 525 526 /* processes a batman packet for all interfaces, adjusts the sequence number and 527 * finds out whether it is a duplicate. 528 * returns: 529 * 1 the packet is a duplicate 530 * 0 the packet has not yet been received 531 * -1 the packet is old and has been received while the seqno window 532 * was protected. Caller should drop it. 533 */ 534 static char count_real_packets(struct ethhdr *ethhdr, 535 struct batman_packet *batman_packet, 536 struct hard_iface *if_incoming) 537 { 538 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 539 struct orig_node *orig_node; 540 struct neigh_node *tmp_neigh_node; 541 struct hlist_node *node; 542 char is_duplicate = 0; 543 int32_t seq_diff; 544 int need_update = 0; 545 int set_mark, ret = -1; 546 547 orig_node = get_orig_node(bat_priv, batman_packet->orig); 548 if (!orig_node) 549 return 0; 550 551 spin_lock_bh(&orig_node->ogm_cnt_lock); 552 seq_diff = batman_packet->seqno - orig_node->last_real_seqno; 553 554 /* signalize caller that the packet is to be dropped. */ 555 if (window_protected(bat_priv, seq_diff, 556 &orig_node->batman_seqno_reset)) 557 goto out; 558 559 rcu_read_lock(); 560 hlist_for_each_entry_rcu(tmp_neigh_node, node, 561 &orig_node->neigh_list, list) { 562 563 is_duplicate |= get_bit_status(tmp_neigh_node->real_bits, 564 orig_node->last_real_seqno, 565 batman_packet->seqno); 566 567 if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) && 568 (tmp_neigh_node->if_incoming == if_incoming)) 569 set_mark = 1; 570 else 571 set_mark = 0; 572 573 /* if the window moved, set the update flag. */ 574 need_update |= bit_get_packet(bat_priv, 575 tmp_neigh_node->real_bits, 576 seq_diff, set_mark); 577 578 tmp_neigh_node->real_packet_count = 579 bit_packet_count(tmp_neigh_node->real_bits); 580 } 581 rcu_read_unlock(); 582 583 if (need_update) { 584 bat_dbg(DBG_BATMAN, bat_priv, 585 "updating last_seqno: old %d, new %d\n", 586 orig_node->last_real_seqno, batman_packet->seqno); 587 orig_node->last_real_seqno = batman_packet->seqno; 588 } 589 590 ret = is_duplicate; 591 592 out: 593 spin_unlock_bh(&orig_node->ogm_cnt_lock); 594 orig_node_free_ref(orig_node); 595 return ret; 596 } 597 598 void receive_bat_packet(struct ethhdr *ethhdr, 599 struct batman_packet *batman_packet, 600 unsigned char *tt_buff, int tt_buff_len, 601 struct hard_iface *if_incoming) 602 { 603 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 604 struct hard_iface *hard_iface; 605 struct orig_node *orig_neigh_node, *orig_node; 606 struct neigh_node *router = NULL, *router_router = NULL; 607 struct neigh_node *orig_neigh_router = NULL; 608 char has_directlink_flag; 609 char is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0; 610 char is_broadcast = 0, is_bidirectional, is_single_hop_neigh; 611 char is_duplicate; 612 uint32_t if_incoming_seqno; 613 614 /* Silently drop when the batman packet is actually not a 615 * correct packet. 616 * 617 * This might happen if a packet is padded (e.g. Ethernet has a 618 * minimum frame length of 64 byte) and the aggregation interprets 619 * it as an additional length. 620 * 621 * TODO: A more sane solution would be to have a bit in the 622 * batman_packet to detect whether the packet is the last 623 * packet in an aggregation. Here we expect that the padding 624 * is always zero (or not 0x01) 625 */ 626 if (batman_packet->packet_type != BAT_PACKET) 627 return; 628 629 /* could be changed by schedule_own_packet() */ 630 if_incoming_seqno = atomic_read(&if_incoming->seqno); 631 632 has_directlink_flag = (batman_packet->flags & DIRECTLINK ? 1 : 0); 633 634 is_single_hop_neigh = (compare_eth(ethhdr->h_source, 635 batman_packet->orig) ? 1 : 0); 636 637 bat_dbg(DBG_BATMAN, bat_priv, 638 "Received BATMAN packet via NB: %pM, IF: %s [%pM] " 639 "(from OG: %pM, via prev OG: %pM, seqno %d, tq %d, " 640 "TTL %d, V %d, IDF %d)\n", 641 ethhdr->h_source, if_incoming->net_dev->name, 642 if_incoming->net_dev->dev_addr, batman_packet->orig, 643 batman_packet->prev_sender, batman_packet->seqno, 644 batman_packet->tq, batman_packet->ttl, batman_packet->version, 645 has_directlink_flag); 646 647 rcu_read_lock(); 648 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 649 if (hard_iface->if_status != IF_ACTIVE) 650 continue; 651 652 if (hard_iface->soft_iface != if_incoming->soft_iface) 653 continue; 654 655 if (compare_eth(ethhdr->h_source, 656 hard_iface->net_dev->dev_addr)) 657 is_my_addr = 1; 658 659 if (compare_eth(batman_packet->orig, 660 hard_iface->net_dev->dev_addr)) 661 is_my_orig = 1; 662 663 if (compare_eth(batman_packet->prev_sender, 664 hard_iface->net_dev->dev_addr)) 665 is_my_oldorig = 1; 666 667 if (compare_eth(ethhdr->h_source, broadcast_addr)) 668 is_broadcast = 1; 669 } 670 rcu_read_unlock(); 671 672 if (batman_packet->version != COMPAT_VERSION) { 673 bat_dbg(DBG_BATMAN, bat_priv, 674 "Drop packet: incompatible batman version (%i)\n", 675 batman_packet->version); 676 return; 677 } 678 679 if (is_my_addr) { 680 bat_dbg(DBG_BATMAN, bat_priv, 681 "Drop packet: received my own broadcast (sender: %pM" 682 ")\n", 683 ethhdr->h_source); 684 return; 685 } 686 687 if (is_broadcast) { 688 bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: " 689 "ignoring all packets with broadcast source addr (sender: %pM" 690 ")\n", ethhdr->h_source); 691 return; 692 } 693 694 if (is_my_orig) { 695 unsigned long *word; 696 int offset; 697 698 orig_neigh_node = get_orig_node(bat_priv, ethhdr->h_source); 699 if (!orig_neigh_node) 700 return; 701 702 /* neighbor has to indicate direct link and it has to 703 * come via the corresponding interface */ 704 /* if received seqno equals last send seqno save new 705 * seqno for bidirectional check */ 706 if (has_directlink_flag && 707 compare_eth(if_incoming->net_dev->dev_addr, 708 batman_packet->orig) && 709 (batman_packet->seqno - if_incoming_seqno + 2 == 0)) { 710 offset = if_incoming->if_num * NUM_WORDS; 711 712 spin_lock_bh(&orig_neigh_node->ogm_cnt_lock); 713 word = &(orig_neigh_node->bcast_own[offset]); 714 bit_mark(word, 0); 715 orig_neigh_node->bcast_own_sum[if_incoming->if_num] = 716 bit_packet_count(word); 717 spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock); 718 } 719 720 bat_dbg(DBG_BATMAN, bat_priv, "Drop packet: " 721 "originator packet from myself (via neighbor)\n"); 722 orig_node_free_ref(orig_neigh_node); 723 return; 724 } 725 726 if (is_my_oldorig) { 727 bat_dbg(DBG_BATMAN, bat_priv, 728 "Drop packet: ignoring all rebroadcast echos (sender: " 729 "%pM)\n", ethhdr->h_source); 730 return; 731 } 732 733 orig_node = get_orig_node(bat_priv, batman_packet->orig); 734 if (!orig_node) 735 return; 736 737 is_duplicate = count_real_packets(ethhdr, batman_packet, if_incoming); 738 739 if (is_duplicate == -1) { 740 bat_dbg(DBG_BATMAN, bat_priv, 741 "Drop packet: packet within seqno protection time " 742 "(sender: %pM)\n", ethhdr->h_source); 743 goto out; 744 } 745 746 if (batman_packet->tq == 0) { 747 bat_dbg(DBG_BATMAN, bat_priv, 748 "Drop packet: originator packet with tq equal 0\n"); 749 goto out; 750 } 751 752 router = orig_node_get_router(orig_node); 753 if (router) 754 router_router = orig_node_get_router(router->orig_node); 755 756 /* avoid temporary routing loops */ 757 if (router && router_router && 758 (compare_eth(router->addr, batman_packet->prev_sender)) && 759 !(compare_eth(batman_packet->orig, batman_packet->prev_sender)) && 760 (compare_eth(router->addr, router_router->addr))) { 761 bat_dbg(DBG_BATMAN, bat_priv, 762 "Drop packet: ignoring all rebroadcast packets that " 763 "may make me loop (sender: %pM)\n", ethhdr->h_source); 764 goto out; 765 } 766 767 /* if sender is a direct neighbor the sender mac equals 768 * originator mac */ 769 orig_neigh_node = (is_single_hop_neigh ? 770 orig_node : 771 get_orig_node(bat_priv, ethhdr->h_source)); 772 if (!orig_neigh_node) 773 goto out; 774 775 orig_neigh_router = orig_node_get_router(orig_neigh_node); 776 777 /* drop packet if sender is not a direct neighbor and if we 778 * don't route towards it */ 779 if (!is_single_hop_neigh && (!orig_neigh_router)) { 780 bat_dbg(DBG_BATMAN, bat_priv, 781 "Drop packet: OGM via unknown neighbor!\n"); 782 goto out_neigh; 783 } 784 785 is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node, 786 batman_packet, if_incoming); 787 788 bonding_save_primary(orig_node, orig_neigh_node, batman_packet); 789 790 /* update ranking if it is not a duplicate or has the same 791 * seqno and similar ttl as the non-duplicate */ 792 if (is_bidirectional && 793 (!is_duplicate || 794 ((orig_node->last_real_seqno == batman_packet->seqno) && 795 (orig_node->last_ttl - 3 <= batman_packet->ttl)))) 796 update_orig(bat_priv, orig_node, ethhdr, batman_packet, 797 if_incoming, tt_buff, tt_buff_len, is_duplicate); 798 799 /* is single hop (direct) neighbor */ 800 if (is_single_hop_neigh) { 801 802 /* mark direct link on incoming interface */ 803 schedule_forward_packet(orig_node, ethhdr, batman_packet, 804 1, tt_buff_len, if_incoming); 805 806 bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: " 807 "rebroadcast neighbor packet with direct link flag\n"); 808 goto out_neigh; 809 } 810 811 /* multihop originator */ 812 if (!is_bidirectional) { 813 bat_dbg(DBG_BATMAN, bat_priv, 814 "Drop packet: not received via bidirectional link\n"); 815 goto out_neigh; 816 } 817 818 if (is_duplicate) { 819 bat_dbg(DBG_BATMAN, bat_priv, 820 "Drop packet: duplicate packet received\n"); 821 goto out_neigh; 822 } 823 824 bat_dbg(DBG_BATMAN, bat_priv, 825 "Forwarding packet: rebroadcast originator packet\n"); 826 schedule_forward_packet(orig_node, ethhdr, batman_packet, 827 0, tt_buff_len, if_incoming); 828 829 out_neigh: 830 if ((orig_neigh_node) && (!is_single_hop_neigh)) 831 orig_node_free_ref(orig_neigh_node); 832 out: 833 if (router) 834 neigh_node_free_ref(router); 835 if (router_router) 836 neigh_node_free_ref(router_router); 837 if (orig_neigh_router) 838 neigh_node_free_ref(orig_neigh_router); 839 840 orig_node_free_ref(orig_node); 841 } 842 843 int recv_bat_packet(struct sk_buff *skb, struct hard_iface *hard_iface) 844 { 845 struct ethhdr *ethhdr; 846 847 /* drop packet if it has not necessary minimum size */ 848 if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet)))) 849 return NET_RX_DROP; 850 851 ethhdr = (struct ethhdr *)skb_mac_header(skb); 852 853 /* packet with broadcast indication but unicast recipient */ 854 if (!is_broadcast_ether_addr(ethhdr->h_dest)) 855 return NET_RX_DROP; 856 857 /* packet with broadcast sender address */ 858 if (is_broadcast_ether_addr(ethhdr->h_source)) 859 return NET_RX_DROP; 860 861 /* create a copy of the skb, if needed, to modify it. */ 862 if (skb_cow(skb, 0) < 0) 863 return NET_RX_DROP; 864 865 /* keep skb linear */ 866 if (skb_linearize(skb) < 0) 867 return NET_RX_DROP; 868 869 ethhdr = (struct ethhdr *)skb_mac_header(skb); 870 871 receive_aggr_bat_packet(ethhdr, 872 skb->data, 873 skb_headlen(skb), 874 hard_iface); 875 876 kfree_skb(skb); 877 return NET_RX_SUCCESS; 878 } 879 880 static int recv_my_icmp_packet(struct bat_priv *bat_priv, 881 struct sk_buff *skb, size_t icmp_len) 882 { 883 struct hard_iface *primary_if = NULL; 884 struct orig_node *orig_node = NULL; 885 struct neigh_node *router = NULL; 886 struct icmp_packet_rr *icmp_packet; 887 int ret = NET_RX_DROP; 888 889 icmp_packet = (struct icmp_packet_rr *)skb->data; 890 891 /* add data to device queue */ 892 if (icmp_packet->msg_type != ECHO_REQUEST) { 893 bat_socket_receive_packet(icmp_packet, icmp_len); 894 goto out; 895 } 896 897 primary_if = primary_if_get_selected(bat_priv); 898 if (!primary_if) 899 goto out; 900 901 /* answer echo request (ping) */ 902 /* get routing information */ 903 orig_node = orig_hash_find(bat_priv, icmp_packet->orig); 904 if (!orig_node) 905 goto out; 906 907 router = orig_node_get_router(orig_node); 908 if (!router) 909 goto out; 910 911 /* create a copy of the skb, if needed, to modify it. */ 912 if (skb_cow(skb, sizeof(struct ethhdr)) < 0) 913 goto out; 914 915 icmp_packet = (struct icmp_packet_rr *)skb->data; 916 917 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); 918 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); 919 icmp_packet->msg_type = ECHO_REPLY; 920 icmp_packet->ttl = TTL; 921 922 send_skb_packet(skb, router->if_incoming, router->addr); 923 ret = NET_RX_SUCCESS; 924 925 out: 926 if (primary_if) 927 hardif_free_ref(primary_if); 928 if (router) 929 neigh_node_free_ref(router); 930 if (orig_node) 931 orig_node_free_ref(orig_node); 932 return ret; 933 } 934 935 static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, 936 struct sk_buff *skb) 937 { 938 struct hard_iface *primary_if = NULL; 939 struct orig_node *orig_node = NULL; 940 struct neigh_node *router = NULL; 941 struct icmp_packet *icmp_packet; 942 int ret = NET_RX_DROP; 943 944 icmp_packet = (struct icmp_packet *)skb->data; 945 946 /* send TTL exceeded if packet is an echo request (traceroute) */ 947 if (icmp_packet->msg_type != ECHO_REQUEST) { 948 pr_debug("Warning - can't forward icmp packet from %pM to " 949 "%pM: ttl exceeded\n", icmp_packet->orig, 950 icmp_packet->dst); 951 goto out; 952 } 953 954 primary_if = primary_if_get_selected(bat_priv); 955 if (!primary_if) 956 goto out; 957 958 /* get routing information */ 959 orig_node = orig_hash_find(bat_priv, icmp_packet->orig); 960 if (!orig_node) 961 goto out; 962 963 router = orig_node_get_router(orig_node); 964 if (!router) 965 goto out; 966 967 /* create a copy of the skb, if needed, to modify it. */ 968 if (skb_cow(skb, sizeof(struct ethhdr)) < 0) 969 goto out; 970 971 icmp_packet = (struct icmp_packet *)skb->data; 972 973 memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); 974 memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); 975 icmp_packet->msg_type = TTL_EXCEEDED; 976 icmp_packet->ttl = TTL; 977 978 send_skb_packet(skb, router->if_incoming, router->addr); 979 ret = NET_RX_SUCCESS; 980 981 out: 982 if (primary_if) 983 hardif_free_ref(primary_if); 984 if (router) 985 neigh_node_free_ref(router); 986 if (orig_node) 987 orig_node_free_ref(orig_node); 988 return ret; 989 } 990 991 992 int recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) 993 { 994 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 995 struct icmp_packet_rr *icmp_packet; 996 struct ethhdr *ethhdr; 997 struct orig_node *orig_node = NULL; 998 struct neigh_node *router = NULL; 999 int hdr_size = sizeof(struct icmp_packet); 1000 int ret = NET_RX_DROP; 1001 1002 /** 1003 * we truncate all incoming icmp packets if they don't match our size 1004 */ 1005 if (skb->len >= sizeof(struct icmp_packet_rr)) 1006 hdr_size = sizeof(struct icmp_packet_rr); 1007 1008 /* drop packet if it has not necessary minimum size */ 1009 if (unlikely(!pskb_may_pull(skb, hdr_size))) 1010 goto out; 1011 1012 ethhdr = (struct ethhdr *)skb_mac_header(skb); 1013 1014 /* packet with unicast indication but broadcast recipient */ 1015 if (is_broadcast_ether_addr(ethhdr->h_dest)) 1016 goto out; 1017 1018 /* packet with broadcast sender address */ 1019 if (is_broadcast_ether_addr(ethhdr->h_source)) 1020 goto out; 1021 1022 /* not for me */ 1023 if (!is_my_mac(ethhdr->h_dest)) 1024 goto out; 1025 1026 icmp_packet = (struct icmp_packet_rr *)skb->data; 1027 1028 /* add record route information if not full */ 1029 if ((hdr_size == sizeof(struct icmp_packet_rr)) && 1030 (icmp_packet->rr_cur < BAT_RR_LEN)) { 1031 memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]), 1032 ethhdr->h_dest, ETH_ALEN); 1033 icmp_packet->rr_cur++; 1034 } 1035 1036 /* packet for me */ 1037 if (is_my_mac(icmp_packet->dst)) 1038 return recv_my_icmp_packet(bat_priv, skb, hdr_size); 1039 1040 /* TTL exceeded */ 1041 if (icmp_packet->ttl < 2) 1042 return recv_icmp_ttl_exceeded(bat_priv, skb); 1043 1044 /* get routing information */ 1045 orig_node = orig_hash_find(bat_priv, icmp_packet->dst); 1046 if (!orig_node) 1047 goto out; 1048 1049 router = orig_node_get_router(orig_node); 1050 if (!router) 1051 goto out; 1052 1053 /* create a copy of the skb, if needed, to modify it. */ 1054 if (skb_cow(skb, sizeof(struct ethhdr)) < 0) 1055 goto out; 1056 1057 icmp_packet = (struct icmp_packet_rr *)skb->data; 1058 1059 /* decrement ttl */ 1060 icmp_packet->ttl--; 1061 1062 /* route it */ 1063 send_skb_packet(skb, router->if_incoming, router->addr); 1064 ret = NET_RX_SUCCESS; 1065 1066 out: 1067 if (router) 1068 neigh_node_free_ref(router); 1069 if (orig_node) 1070 orig_node_free_ref(orig_node); 1071 return ret; 1072 } 1073 1074 /* In the bonding case, send the packets in a round 1075 * robin fashion over the remaining interfaces. 1076 * 1077 * This method rotates the bonding list and increases the 1078 * returned router's refcount. */ 1079 static struct neigh_node *find_bond_router(struct orig_node *primary_orig, 1080 struct hard_iface *recv_if) 1081 { 1082 struct neigh_node *tmp_neigh_node; 1083 struct neigh_node *router = NULL, *first_candidate = NULL; 1084 1085 rcu_read_lock(); 1086 list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list, 1087 bonding_list) { 1088 if (!first_candidate) 1089 first_candidate = tmp_neigh_node; 1090 1091 /* recv_if == NULL on the first node. */ 1092 if (tmp_neigh_node->if_incoming == recv_if) 1093 continue; 1094 1095 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount)) 1096 continue; 1097 1098 router = tmp_neigh_node; 1099 break; 1100 } 1101 1102 /* use the first candidate if nothing was found. */ 1103 if (!router && first_candidate && 1104 atomic_inc_not_zero(&first_candidate->refcount)) 1105 router = first_candidate; 1106 1107 if (!router) 1108 goto out; 1109 1110 /* selected should point to the next element 1111 * after the current router */ 1112 spin_lock_bh(&primary_orig->neigh_list_lock); 1113 /* this is a list_move(), which unfortunately 1114 * does not exist as rcu version */ 1115 list_del_rcu(&primary_orig->bond_list); 1116 list_add_rcu(&primary_orig->bond_list, 1117 &router->bonding_list); 1118 spin_unlock_bh(&primary_orig->neigh_list_lock); 1119 1120 out: 1121 rcu_read_unlock(); 1122 return router; 1123 } 1124 1125 /* Interface Alternating: Use the best of the 1126 * remaining candidates which are not using 1127 * this interface. 1128 * 1129 * Increases the returned router's refcount */ 1130 static struct neigh_node *find_ifalter_router(struct orig_node *primary_orig, 1131 struct hard_iface *recv_if) 1132 { 1133 struct neigh_node *tmp_neigh_node; 1134 struct neigh_node *router = NULL, *first_candidate = NULL; 1135 1136 rcu_read_lock(); 1137 list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list, 1138 bonding_list) { 1139 if (!first_candidate) 1140 first_candidate = tmp_neigh_node; 1141 1142 /* recv_if == NULL on the first node. */ 1143 if (tmp_neigh_node->if_incoming == recv_if) 1144 continue; 1145 1146 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount)) 1147 continue; 1148 1149 /* if we don't have a router yet 1150 * or this one is better, choose it. */ 1151 if ((!router) || 1152 (tmp_neigh_node->tq_avg > router->tq_avg)) { 1153 /* decrement refcount of 1154 * previously selected router */ 1155 if (router) 1156 neigh_node_free_ref(router); 1157 1158 router = tmp_neigh_node; 1159 atomic_inc_not_zero(&router->refcount); 1160 } 1161 1162 neigh_node_free_ref(tmp_neigh_node); 1163 } 1164 1165 /* use the first candidate if nothing was found. */ 1166 if (!router && first_candidate && 1167 atomic_inc_not_zero(&first_candidate->refcount)) 1168 router = first_candidate; 1169 1170 rcu_read_unlock(); 1171 return router; 1172 } 1173 1174 /* find a suitable router for this originator, and use 1175 * bonding if possible. increases the found neighbors 1176 * refcount.*/ 1177 struct neigh_node *find_router(struct bat_priv *bat_priv, 1178 struct orig_node *orig_node, 1179 struct hard_iface *recv_if) 1180 { 1181 struct orig_node *primary_orig_node; 1182 struct orig_node *router_orig; 1183 struct neigh_node *router; 1184 static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0}; 1185 int bonding_enabled; 1186 1187 if (!orig_node) 1188 return NULL; 1189 1190 router = orig_node_get_router(orig_node); 1191 if (!router) 1192 goto err; 1193 1194 /* without bonding, the first node should 1195 * always choose the default router. */ 1196 bonding_enabled = atomic_read(&bat_priv->bonding); 1197 1198 rcu_read_lock(); 1199 /* select default router to output */ 1200 router_orig = router->orig_node; 1201 if (!router_orig) 1202 goto err_unlock; 1203 1204 if ((!recv_if) && (!bonding_enabled)) 1205 goto return_router; 1206 1207 /* if we have something in the primary_addr, we can search 1208 * for a potential bonding candidate. */ 1209 if (compare_eth(router_orig->primary_addr, zero_mac)) 1210 goto return_router; 1211 1212 /* find the orig_node which has the primary interface. might 1213 * even be the same as our router_orig in many cases */ 1214 1215 if (compare_eth(router_orig->primary_addr, router_orig->orig)) { 1216 primary_orig_node = router_orig; 1217 } else { 1218 primary_orig_node = orig_hash_find(bat_priv, 1219 router_orig->primary_addr); 1220 if (!primary_orig_node) 1221 goto return_router; 1222 1223 orig_node_free_ref(primary_orig_node); 1224 } 1225 1226 /* with less than 2 candidates, we can't do any 1227 * bonding and prefer the original router. */ 1228 if (atomic_read(&primary_orig_node->bond_candidates) < 2) 1229 goto return_router; 1230 1231 /* all nodes between should choose a candidate which 1232 * is is not on the interface where the packet came 1233 * in. */ 1234 1235 neigh_node_free_ref(router); 1236 1237 if (bonding_enabled) 1238 router = find_bond_router(primary_orig_node, recv_if); 1239 else 1240 router = find_ifalter_router(primary_orig_node, recv_if); 1241 1242 return_router: 1243 rcu_read_unlock(); 1244 return router; 1245 err_unlock: 1246 rcu_read_unlock(); 1247 err: 1248 if (router) 1249 neigh_node_free_ref(router); 1250 return NULL; 1251 } 1252 1253 static int check_unicast_packet(struct sk_buff *skb, int hdr_size) 1254 { 1255 struct ethhdr *ethhdr; 1256 1257 /* drop packet if it has not necessary minimum size */ 1258 if (unlikely(!pskb_may_pull(skb, hdr_size))) 1259 return -1; 1260 1261 ethhdr = (struct ethhdr *)skb_mac_header(skb); 1262 1263 /* packet with unicast indication but broadcast recipient */ 1264 if (is_broadcast_ether_addr(ethhdr->h_dest)) 1265 return -1; 1266 1267 /* packet with broadcast sender address */ 1268 if (is_broadcast_ether_addr(ethhdr->h_source)) 1269 return -1; 1270 1271 /* not for me */ 1272 if (!is_my_mac(ethhdr->h_dest)) 1273 return -1; 1274 1275 return 0; 1276 } 1277 1278 int route_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1279 { 1280 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1281 struct orig_node *orig_node = NULL; 1282 struct neigh_node *neigh_node = NULL; 1283 struct unicast_packet *unicast_packet; 1284 struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb); 1285 int ret = NET_RX_DROP; 1286 struct sk_buff *new_skb; 1287 1288 unicast_packet = (struct unicast_packet *)skb->data; 1289 1290 /* TTL exceeded */ 1291 if (unicast_packet->ttl < 2) { 1292 pr_debug("Warning - can't forward unicast packet from %pM to " 1293 "%pM: ttl exceeded\n", ethhdr->h_source, 1294 unicast_packet->dest); 1295 goto out; 1296 } 1297 1298 /* get routing information */ 1299 orig_node = orig_hash_find(bat_priv, unicast_packet->dest); 1300 1301 if (!orig_node) 1302 goto out; 1303 1304 /* find_router() increases neigh_nodes refcount if found. */ 1305 neigh_node = find_router(bat_priv, orig_node, recv_if); 1306 1307 if (!neigh_node) 1308 goto out; 1309 1310 /* create a copy of the skb, if needed, to modify it. */ 1311 if (skb_cow(skb, sizeof(struct ethhdr)) < 0) 1312 goto out; 1313 1314 unicast_packet = (struct unicast_packet *)skb->data; 1315 1316 if (unicast_packet->packet_type == BAT_UNICAST && 1317 atomic_read(&bat_priv->fragmentation) && 1318 skb->len > neigh_node->if_incoming->net_dev->mtu) { 1319 ret = frag_send_skb(skb, bat_priv, 1320 neigh_node->if_incoming, neigh_node->addr); 1321 goto out; 1322 } 1323 1324 if (unicast_packet->packet_type == BAT_UNICAST_FRAG && 1325 frag_can_reassemble(skb, neigh_node->if_incoming->net_dev->mtu)) { 1326 1327 ret = frag_reassemble_skb(skb, bat_priv, &new_skb); 1328 1329 if (ret == NET_RX_DROP) 1330 goto out; 1331 1332 /* packet was buffered for late merge */ 1333 if (!new_skb) { 1334 ret = NET_RX_SUCCESS; 1335 goto out; 1336 } 1337 1338 skb = new_skb; 1339 unicast_packet = (struct unicast_packet *)skb->data; 1340 } 1341 1342 /* decrement ttl */ 1343 unicast_packet->ttl--; 1344 1345 /* route it */ 1346 send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); 1347 ret = NET_RX_SUCCESS; 1348 1349 out: 1350 if (neigh_node) 1351 neigh_node_free_ref(neigh_node); 1352 if (orig_node) 1353 orig_node_free_ref(orig_node); 1354 return ret; 1355 } 1356 1357 int recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1358 { 1359 struct unicast_packet *unicast_packet; 1360 int hdr_size = sizeof(struct unicast_packet); 1361 1362 if (check_unicast_packet(skb, hdr_size) < 0) 1363 return NET_RX_DROP; 1364 1365 unicast_packet = (struct unicast_packet *)skb->data; 1366 1367 /* packet for me */ 1368 if (is_my_mac(unicast_packet->dest)) { 1369 interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); 1370 return NET_RX_SUCCESS; 1371 } 1372 1373 return route_unicast_packet(skb, recv_if); 1374 } 1375 1376 int recv_ucast_frag_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1377 { 1378 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1379 struct unicast_frag_packet *unicast_packet; 1380 int hdr_size = sizeof(struct unicast_frag_packet); 1381 struct sk_buff *new_skb = NULL; 1382 int ret; 1383 1384 if (check_unicast_packet(skb, hdr_size) < 0) 1385 return NET_RX_DROP; 1386 1387 unicast_packet = (struct unicast_frag_packet *)skb->data; 1388 1389 /* packet for me */ 1390 if (is_my_mac(unicast_packet->dest)) { 1391 1392 ret = frag_reassemble_skb(skb, bat_priv, &new_skb); 1393 1394 if (ret == NET_RX_DROP) 1395 return NET_RX_DROP; 1396 1397 /* packet was buffered for late merge */ 1398 if (!new_skb) 1399 return NET_RX_SUCCESS; 1400 1401 interface_rx(recv_if->soft_iface, new_skb, recv_if, 1402 sizeof(struct unicast_packet)); 1403 return NET_RX_SUCCESS; 1404 } 1405 1406 return route_unicast_packet(skb, recv_if); 1407 } 1408 1409 1410 int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1411 { 1412 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1413 struct orig_node *orig_node = NULL; 1414 struct bcast_packet *bcast_packet; 1415 struct ethhdr *ethhdr; 1416 int hdr_size = sizeof(struct bcast_packet); 1417 int ret = NET_RX_DROP; 1418 int32_t seq_diff; 1419 1420 /* drop packet if it has not necessary minimum size */ 1421 if (unlikely(!pskb_may_pull(skb, hdr_size))) 1422 goto out; 1423 1424 ethhdr = (struct ethhdr *)skb_mac_header(skb); 1425 1426 /* packet with broadcast indication but unicast recipient */ 1427 if (!is_broadcast_ether_addr(ethhdr->h_dest)) 1428 goto out; 1429 1430 /* packet with broadcast sender address */ 1431 if (is_broadcast_ether_addr(ethhdr->h_source)) 1432 goto out; 1433 1434 /* ignore broadcasts sent by myself */ 1435 if (is_my_mac(ethhdr->h_source)) 1436 goto out; 1437 1438 bcast_packet = (struct bcast_packet *)skb->data; 1439 1440 /* ignore broadcasts originated by myself */ 1441 if (is_my_mac(bcast_packet->orig)) 1442 goto out; 1443 1444 if (bcast_packet->ttl < 2) 1445 goto out; 1446 1447 orig_node = orig_hash_find(bat_priv, bcast_packet->orig); 1448 1449 if (!orig_node) 1450 goto out; 1451 1452 spin_lock_bh(&orig_node->bcast_seqno_lock); 1453 1454 /* check whether the packet is a duplicate */ 1455 if (get_bit_status(orig_node->bcast_bits, orig_node->last_bcast_seqno, 1456 ntohl(bcast_packet->seqno))) 1457 goto spin_unlock; 1458 1459 seq_diff = ntohl(bcast_packet->seqno) - orig_node->last_bcast_seqno; 1460 1461 /* check whether the packet is old and the host just restarted. */ 1462 if (window_protected(bat_priv, seq_diff, 1463 &orig_node->bcast_seqno_reset)) 1464 goto spin_unlock; 1465 1466 /* mark broadcast in flood history, update window position 1467 * if required. */ 1468 if (bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1)) 1469 orig_node->last_bcast_seqno = ntohl(bcast_packet->seqno); 1470 1471 spin_unlock_bh(&orig_node->bcast_seqno_lock); 1472 1473 /* rebroadcast packet */ 1474 add_bcast_packet_to_list(bat_priv, skb); 1475 1476 /* broadcast for me */ 1477 interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); 1478 ret = NET_RX_SUCCESS; 1479 goto out; 1480 1481 spin_unlock: 1482 spin_unlock_bh(&orig_node->bcast_seqno_lock); 1483 out: 1484 if (orig_node) 1485 orig_node_free_ref(orig_node); 1486 return ret; 1487 } 1488 1489 int recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if) 1490 { 1491 struct vis_packet *vis_packet; 1492 struct ethhdr *ethhdr; 1493 struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); 1494 int hdr_size = sizeof(struct vis_packet); 1495 1496 /* keep skb linear */ 1497 if (skb_linearize(skb) < 0) 1498 return NET_RX_DROP; 1499 1500 if (unlikely(!pskb_may_pull(skb, hdr_size))) 1501 return NET_RX_DROP; 1502 1503 vis_packet = (struct vis_packet *)skb->data; 1504 ethhdr = (struct ethhdr *)skb_mac_header(skb); 1505 1506 /* not for me */ 1507 if (!is_my_mac(ethhdr->h_dest)) 1508 return NET_RX_DROP; 1509 1510 /* ignore own packets */ 1511 if (is_my_mac(vis_packet->vis_orig)) 1512 return NET_RX_DROP; 1513 1514 if (is_my_mac(vis_packet->sender_orig)) 1515 return NET_RX_DROP; 1516 1517 switch (vis_packet->vis_type) { 1518 case VIS_TYPE_SERVER_SYNC: 1519 receive_server_sync_packet(bat_priv, vis_packet, 1520 skb_headlen(skb)); 1521 break; 1522 1523 case VIS_TYPE_CLIENT_UPDATE: 1524 receive_client_update_packet(bat_priv, vis_packet, 1525 skb_headlen(skb)); 1526 break; 1527 1528 default: /* ignore unknown packet */ 1529 break; 1530 } 1531 1532 /* We take a copy of the data in the packet, so we should 1533 always free the skbuf. */ 1534 return NET_RX_DROP; 1535 } 1536