net/batman-adv/routing.c

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