linux/net/batman-adv/network-coding.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright (C) B.A.T.M.A.N. contributors:
   3 *
   4 * Martin Hundeb\xC3\xB8ll, Jeppe Ledet-Pedersen
   5 */
   6
   7#include "network-coding.h"
   8#include "main.h"
   9
  10#include <linux/atomic.h>
  11#include <linux/bitops.h>
  12#include <linux/byteorder/generic.h>
  13#include <linux/compiler.h>
  14#include <linux/errno.h>
  15#include <linux/etherdevice.h>
  16#include <linux/gfp.h>
  17#include <linux/if_ether.h>
  18#include <linux/if_packet.h>
  19#include <linux/init.h>
  20#include <linux/jhash.h>
  21#include <linux/jiffies.h>
  22#include <linux/kernel.h>
  23#include <linux/kref.h>
  24#include <linux/list.h>
  25#include <linux/lockdep.h>
  26#include <linux/net.h>
  27#include <linux/netdevice.h>
  28#include <linux/prandom.h>
  29#include <linux/printk.h>
  30#include <linux/rculist.h>
  31#include <linux/rcupdate.h>
  32#include <linux/skbuff.h>
  33#include <linux/slab.h>
  34#include <linux/spinlock.h>
  35#include <linux/stddef.h>
  36#include <linux/string.h>
  37#include <linux/workqueue.h>
  38#include <uapi/linux/batadv_packet.h>
  39
  40#include "hash.h"
  41#include "log.h"
  42#include "originator.h"
  43#include "routing.h"
  44#include "send.h"
  45#include "tvlv.h"
  46
  47static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
  48static struct lock_class_key batadv_nc_decoding_hash_lock_class_key;
  49
  50static void batadv_nc_worker(struct work_struct *work);
  51static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
  52                                       struct batadv_hard_iface *recv_if);
  53
  54/**
  55 * batadv_nc_init() - one-time initialization for network coding
  56 *
  57 * Return: 0 on success or negative error number in case of failure
  58 */
  59int __init batadv_nc_init(void)
  60{
  61        int ret;
  62
  63        /* Register our packet type */
  64        ret = batadv_recv_handler_register(BATADV_CODED,
  65                                           batadv_nc_recv_coded_packet);
  66
  67        return ret;
  68}
  69
  70/**
  71 * batadv_nc_start_timer() - initialise the nc periodic worker
  72 * @bat_priv: the bat priv with all the soft interface information
  73 */
  74static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
  75{
  76        queue_delayed_work(batadv_event_workqueue, &bat_priv->nc.work,
  77                           msecs_to_jiffies(10));
  78}
  79
  80/**
  81 * batadv_nc_tvlv_container_update() - update the network coding tvlv container
  82 *  after network coding setting change
  83 * @bat_priv: the bat priv with all the soft interface information
  84 */
  85static void batadv_nc_tvlv_container_update(struct batadv_priv *bat_priv)
  86{
  87        char nc_mode;
  88
  89        nc_mode = atomic_read(&bat_priv->network_coding);
  90
  91        switch (nc_mode) {
  92        case 0:
  93                batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_NC, 1);
  94                break;
  95        case 1:
  96                batadv_tvlv_container_register(bat_priv, BATADV_TVLV_NC, 1,
  97                                               NULL, 0);
  98                break;
  99        }
 100}
 101
 102/**
 103 * batadv_nc_status_update() - update the network coding tvlv container after
 104 *  network coding setting change
 105 * @net_dev: the soft interface net device
 106 */
 107void batadv_nc_status_update(struct net_device *net_dev)
 108{
 109        struct batadv_priv *bat_priv = netdev_priv(net_dev);
 110
 111        batadv_nc_tvlv_container_update(bat_priv);
 112}
 113
 114/**
 115 * batadv_nc_tvlv_ogm_handler_v1() - process incoming nc tvlv container
 116 * @bat_priv: the bat priv with all the soft interface information
 117 * @orig: the orig_node of the ogm
 118 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
 119 * @tvlv_value: tvlv buffer containing the gateway data
 120 * @tvlv_value_len: tvlv buffer length
 121 */
 122static void batadv_nc_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
 123                                          struct batadv_orig_node *orig,
 124                                          u8 flags,
 125                                          void *tvlv_value, u16 tvlv_value_len)
 126{
 127        if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
 128                clear_bit(BATADV_ORIG_CAPA_HAS_NC, &orig->capabilities);
 129        else
 130                set_bit(BATADV_ORIG_CAPA_HAS_NC, &orig->capabilities);
 131}
 132
 133/**
 134 * batadv_nc_mesh_init() - initialise coding hash table and start housekeeping
 135 * @bat_priv: the bat priv with all the soft interface information
 136 *
 137 * Return: 0 on success or negative error number in case of failure
 138 */
 139int batadv_nc_mesh_init(struct batadv_priv *bat_priv)
 140{
 141        bat_priv->nc.timestamp_fwd_flush = jiffies;
 142        bat_priv->nc.timestamp_sniffed_purge = jiffies;
 143
 144        if (bat_priv->nc.coding_hash || bat_priv->nc.decoding_hash)
 145                return 0;
 146
 147        bat_priv->nc.coding_hash = batadv_hash_new(128);
 148        if (!bat_priv->nc.coding_hash)
 149                goto err;
 150
 151        batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
 152                                   &batadv_nc_coding_hash_lock_class_key);
 153
 154        bat_priv->nc.decoding_hash = batadv_hash_new(128);
 155        if (!bat_priv->nc.decoding_hash)
 156                goto err;
 157
 158        batadv_hash_set_lock_class(bat_priv->nc.decoding_hash,
 159                                   &batadv_nc_decoding_hash_lock_class_key);
 160
 161        INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
 162        batadv_nc_start_timer(bat_priv);
 163
 164        batadv_tvlv_handler_register(bat_priv, batadv_nc_tvlv_ogm_handler_v1,
 165                                     NULL, BATADV_TVLV_NC, 1,
 166                                     BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
 167        batadv_nc_tvlv_container_update(bat_priv);
 168        return 0;
 169
 170err:
 171        return -ENOMEM;
 172}
 173
 174/**
 175 * batadv_nc_init_bat_priv() - initialise the nc specific bat_priv variables
 176 * @bat_priv: the bat priv with all the soft interface information
 177 */
 178void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
 179{
 180        atomic_set(&bat_priv->network_coding, 0);
 181        bat_priv->nc.min_tq = 200;
 182        bat_priv->nc.max_fwd_delay = 10;
 183        bat_priv->nc.max_buffer_time = 200;
 184}
 185
 186/**
 187 * batadv_nc_init_orig() - initialise the nc fields of an orig_node
 188 * @orig_node: the orig_node which is going to be initialised
 189 */
 190void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
 191{
 192        INIT_LIST_HEAD(&orig_node->in_coding_list);
 193        INIT_LIST_HEAD(&orig_node->out_coding_list);
 194        spin_lock_init(&orig_node->in_coding_list_lock);
 195        spin_lock_init(&orig_node->out_coding_list_lock);
 196}
 197
 198/**
 199 * batadv_nc_node_release() - release nc_node from lists and queue for free
 200 *  after rcu grace period
 201 * @ref: kref pointer of the nc_node
 202 */
 203static void batadv_nc_node_release(struct kref *ref)
 204{
 205        struct batadv_nc_node *nc_node;
 206
 207        nc_node = container_of(ref, struct batadv_nc_node, refcount);
 208
 209        batadv_orig_node_put(nc_node->orig_node);
 210        kfree_rcu(nc_node, rcu);
 211}
 212
 213/**
 214 * batadv_nc_node_put() - decrement the nc_node refcounter and possibly
 215 *  release it
 216 * @nc_node: nc_node to be free'd
 217 */
 218static void batadv_nc_node_put(struct batadv_nc_node *nc_node)
 219{
 220        kref_put(&nc_node->refcount, batadv_nc_node_release);
 221}
 222
 223/**
 224 * batadv_nc_path_release() - release nc_path from lists and queue for free
 225 *  after rcu grace period
 226 * @ref: kref pointer of the nc_path
 227 */
 228static void batadv_nc_path_release(struct kref *ref)
 229{
 230        struct batadv_nc_path *nc_path;
 231
 232        nc_path = container_of(ref, struct batadv_nc_path, refcount);
 233
 234        kfree_rcu(nc_path, rcu);
 235}
 236
 237/**
 238 * batadv_nc_path_put() - decrement the nc_path refcounter and possibly
 239 *  release it
 240 * @nc_path: nc_path to be free'd
 241 */
 242static void batadv_nc_path_put(struct batadv_nc_path *nc_path)
 243{
 244        kref_put(&nc_path->refcount, batadv_nc_path_release);
 245}
 246
 247/**
 248 * batadv_nc_packet_free() - frees nc packet
 249 * @nc_packet: the nc packet to free
 250 * @dropped: whether the packet is freed because is dropped
 251 */
 252static void batadv_nc_packet_free(struct batadv_nc_packet *nc_packet,
 253                                  bool dropped)
 254{
 255        if (dropped)
 256                kfree_skb(nc_packet->skb);
 257        else
 258                consume_skb(nc_packet->skb);
 259
 260        batadv_nc_path_put(nc_packet->nc_path);
 261        kfree(nc_packet);
 262}
 263
 264/**
 265 * batadv_nc_to_purge_nc_node() - checks whether an nc node has to be purged
 266 * @bat_priv: the bat priv with all the soft interface information
 267 * @nc_node: the nc node to check
 268 *
 269 * Return: true if the entry has to be purged now, false otherwise
 270 */
 271static bool batadv_nc_to_purge_nc_node(struct batadv_priv *bat_priv,
 272                                       struct batadv_nc_node *nc_node)
 273{
 274        if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 275                return true;
 276
 277        return batadv_has_timed_out(nc_node->last_seen, BATADV_NC_NODE_TIMEOUT);
 278}
 279
 280/**
 281 * batadv_nc_to_purge_nc_path_coding() - checks whether an nc path has timed out
 282 * @bat_priv: the bat priv with all the soft interface information
 283 * @nc_path: the nc path to check
 284 *
 285 * Return: true if the entry has to be purged now, false otherwise
 286 */
 287static bool batadv_nc_to_purge_nc_path_coding(struct batadv_priv *bat_priv,
 288                                              struct batadv_nc_path *nc_path)
 289{
 290        if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 291                return true;
 292
 293        /* purge the path when no packets has been added for 10 times the
 294         * max_fwd_delay time
 295         */
 296        return batadv_has_timed_out(nc_path->last_valid,
 297                                    bat_priv->nc.max_fwd_delay * 10);
 298}
 299
 300/**
 301 * batadv_nc_to_purge_nc_path_decoding() - checks whether an nc path has timed
 302 *  out
 303 * @bat_priv: the bat priv with all the soft interface information
 304 * @nc_path: the nc path to check
 305 *
 306 * Return: true if the entry has to be purged now, false otherwise
 307 */
 308static bool batadv_nc_to_purge_nc_path_decoding(struct batadv_priv *bat_priv,
 309                                                struct batadv_nc_path *nc_path)
 310{
 311        if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 312                return true;
 313
 314        /* purge the path when no packets has been added for 10 times the
 315         * max_buffer time
 316         */
 317        return batadv_has_timed_out(nc_path->last_valid,
 318                                    bat_priv->nc.max_buffer_time * 10);
 319}
 320
 321/**
 322 * batadv_nc_purge_orig_nc_nodes() - go through list of nc nodes and purge stale
 323 *  entries
 324 * @bat_priv: the bat priv with all the soft interface information
 325 * @list: list of nc nodes
 326 * @lock: nc node list lock
 327 * @to_purge: function in charge to decide whether an entry has to be purged or
 328 *            not. This function takes the nc node as argument and has to return
 329 *            a boolean value: true if the entry has to be deleted, false
 330 *            otherwise
 331 */
 332static void
 333batadv_nc_purge_orig_nc_nodes(struct batadv_priv *bat_priv,
 334                              struct list_head *list,
 335                              spinlock_t *lock,
 336                              bool (*to_purge)(struct batadv_priv *,
 337                                               struct batadv_nc_node *))
 338{
 339        struct batadv_nc_node *nc_node, *nc_node_tmp;
 340
 341        /* For each nc_node in list */
 342        spin_lock_bh(lock);
 343        list_for_each_entry_safe(nc_node, nc_node_tmp, list, list) {
 344                /* if an helper function has been passed as parameter,
 345                 * ask it if the entry has to be purged or not
 346                 */
 347                if (to_purge && !to_purge(bat_priv, nc_node))
 348                        continue;
 349
 350                batadv_dbg(BATADV_DBG_NC, bat_priv,
 351                           "Removing nc_node %pM -> %pM\n",
 352                           nc_node->addr, nc_node->orig_node->orig);
 353                list_del_rcu(&nc_node->list);
 354                batadv_nc_node_put(nc_node);
 355        }
 356        spin_unlock_bh(lock);
 357}
 358
 359/**
 360 * batadv_nc_purge_orig() - purges all nc node data attached of the given
 361 *  originator
 362 * @bat_priv: the bat priv with all the soft interface information
 363 * @orig_node: orig_node with the nc node entries to be purged
 364 * @to_purge: function in charge to decide whether an entry has to be purged or
 365 *            not. This function takes the nc node as argument and has to return
 366 *            a boolean value: true is the entry has to be deleted, false
 367 *            otherwise
 368 */
 369void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
 370                          struct batadv_orig_node *orig_node,
 371                          bool (*to_purge)(struct batadv_priv *,
 372                                           struct batadv_nc_node *))
 373{
 374        /* Check ingoing nc_node's of this orig_node */
 375        batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->in_coding_list,
 376                                      &orig_node->in_coding_list_lock,
 377                                      to_purge);
 378
 379        /* Check outgoing nc_node's of this orig_node */
 380        batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->out_coding_list,
 381                                      &orig_node->out_coding_list_lock,
 382                                      to_purge);
 383}
 384
 385/**
 386 * batadv_nc_purge_orig_hash() - traverse entire originator hash to check if
 387 *  they have timed out nc nodes
 388 * @bat_priv: the bat priv with all the soft interface information
 389 */
 390static void batadv_nc_purge_orig_hash(struct batadv_priv *bat_priv)
 391{
 392        struct batadv_hashtable *hash = bat_priv->orig_hash;
 393        struct hlist_head *head;
 394        struct batadv_orig_node *orig_node;
 395        u32 i;
 396
 397        if (!hash)
 398                return;
 399
 400        /* For each orig_node */
 401        for (i = 0; i < hash->size; i++) {
 402                head = &hash->table[i];
 403
 404                rcu_read_lock();
 405                hlist_for_each_entry_rcu(orig_node, head, hash_entry)
 406                        batadv_nc_purge_orig(bat_priv, orig_node,
 407                                             batadv_nc_to_purge_nc_node);
 408                rcu_read_unlock();
 409        }
 410}
 411
 412/**
 413 * batadv_nc_purge_paths() - traverse all nc paths part of the hash and remove
 414 *  unused ones
 415 * @bat_priv: the bat priv with all the soft interface information
 416 * @hash: hash table containing the nc paths to check
 417 * @to_purge: function in charge to decide whether an entry has to be purged or
 418 *            not. This function takes the nc node as argument and has to return
 419 *            a boolean value: true is the entry has to be deleted, false
 420 *            otherwise
 421 */
 422static void batadv_nc_purge_paths(struct batadv_priv *bat_priv,
 423                                  struct batadv_hashtable *hash,
 424                                  bool (*to_purge)(struct batadv_priv *,
 425                                                   struct batadv_nc_path *))
 426{
 427        struct hlist_head *head;
 428        struct hlist_node *node_tmp;
 429        struct batadv_nc_path *nc_path;
 430        spinlock_t *lock; /* Protects lists in hash */
 431        u32 i;
 432
 433        for (i = 0; i < hash->size; i++) {
 434                head = &hash->table[i];
 435                lock = &hash->list_locks[i];
 436
 437                /* For each nc_path in this bin */
 438                spin_lock_bh(lock);
 439                hlist_for_each_entry_safe(nc_path, node_tmp, head, hash_entry) {
 440                        /* if an helper function has been passed as parameter,
 441                         * ask it if the entry has to be purged or not
 442                         */
 443                        if (to_purge && !to_purge(bat_priv, nc_path))
 444                                continue;
 445
 446                        /* purging an non-empty nc_path should never happen, but
 447                         * is observed under high CPU load. Delay the purging
 448                         * until next iteration to allow the packet_list to be
 449                         * emptied first.
 450                         */
 451                        if (!unlikely(list_empty(&nc_path->packet_list))) {
 452                                net_ratelimited_function(printk,
 453                                                         KERN_WARNING
 454                                                         "Skipping free of non-empty nc_path (%pM -> %pM)!\n",
 455                                                         nc_path->prev_hop,
 456                                                         nc_path->next_hop);
 457                                continue;
 458                        }
 459
 460                        /* nc_path is unused, so remove it */
 461                        batadv_dbg(BATADV_DBG_NC, bat_priv,
 462                                   "Remove nc_path %pM -> %pM\n",
 463                                   nc_path->prev_hop, nc_path->next_hop);
 464                        hlist_del_rcu(&nc_path->hash_entry);
 465                        batadv_nc_path_put(nc_path);
 466                }
 467                spin_unlock_bh(lock);
 468        }
 469}
 470
 471/**
 472 * batadv_nc_hash_key_gen() - computes the nc_path hash key
 473 * @key: buffer to hold the final hash key
 474 * @src: source ethernet mac address going into the hash key
 475 * @dst: destination ethernet mac address going into the hash key
 476 */
 477static void batadv_nc_hash_key_gen(struct batadv_nc_path *key, const char *src,
 478                                   const char *dst)
 479{
 480        memcpy(key->prev_hop, src, sizeof(key->prev_hop));
 481        memcpy(key->next_hop, dst, sizeof(key->next_hop));
 482}
 483
 484/**
 485 * batadv_nc_hash_choose() - compute the hash value for an nc path
 486 * @data: data to hash
 487 * @size: size of the hash table
 488 *
 489 * Return: the selected index in the hash table for the given data.
 490 */
 491static u32 batadv_nc_hash_choose(const void *data, u32 size)
 492{
 493        const struct batadv_nc_path *nc_path = data;
 494        u32 hash = 0;
 495
 496        hash = jhash(&nc_path->prev_hop, sizeof(nc_path->prev_hop), hash);
 497        hash = jhash(&nc_path->next_hop, sizeof(nc_path->next_hop), hash);
 498
 499        return hash % size;
 500}
 501
 502/**
 503 * batadv_nc_hash_compare() - comparing function used in the network coding hash
 504 *  tables
 505 * @node: node in the local table
 506 * @data2: second object to compare the node to
 507 *
 508 * Return: true if the two entry are the same, false otherwise
 509 */
 510static bool batadv_nc_hash_compare(const struct hlist_node *node,
 511                                   const void *data2)
 512{
 513        const struct batadv_nc_path *nc_path1, *nc_path2;
 514
 515        nc_path1 = container_of(node, struct batadv_nc_path, hash_entry);
 516        nc_path2 = data2;
 517
 518        /* Return 1 if the two keys are identical */
 519        if (!batadv_compare_eth(nc_path1->prev_hop, nc_path2->prev_hop))
 520                return false;
 521
 522        if (!batadv_compare_eth(nc_path1->next_hop, nc_path2->next_hop))
 523                return false;
 524
 525        return true;
 526}
 527
 528/**
 529 * batadv_nc_hash_find() - search for an existing nc path and return it
 530 * @hash: hash table containing the nc path
 531 * @data: search key
 532 *
 533 * Return: the nc_path if found, NULL otherwise.
 534 */
 535static struct batadv_nc_path *
 536batadv_nc_hash_find(struct batadv_hashtable *hash,
 537                    void *data)
 538{
 539        struct hlist_head *head;
 540        struct batadv_nc_path *nc_path, *nc_path_tmp = NULL;
 541        int index;
 542
 543        if (!hash)
 544                return NULL;
 545
 546        index = batadv_nc_hash_choose(data, hash->size);
 547        head = &hash->table[index];
 548
 549        rcu_read_lock();
 550        hlist_for_each_entry_rcu(nc_path, head, hash_entry) {
 551                if (!batadv_nc_hash_compare(&nc_path->hash_entry, data))
 552                        continue;
 553
 554                if (!kref_get_unless_zero(&nc_path->refcount))
 555                        continue;
 556
 557                nc_path_tmp = nc_path;
 558                break;
 559        }
 560        rcu_read_unlock();
 561
 562        return nc_path_tmp;
 563}
 564
 565/**
 566 * batadv_nc_send_packet() - send non-coded packet and free nc_packet struct
 567 * @nc_packet: the nc packet to send
 568 */
 569static void batadv_nc_send_packet(struct batadv_nc_packet *nc_packet)
 570{
 571        batadv_send_unicast_skb(nc_packet->skb, nc_packet->neigh_node);
 572        nc_packet->skb = NULL;
 573        batadv_nc_packet_free(nc_packet, false);
 574}
 575
 576/**
 577 * batadv_nc_sniffed_purge() - Checks timestamp of given sniffed nc_packet.
 578 * @bat_priv: the bat priv with all the soft interface information
 579 * @nc_path: the nc path the packet belongs to
 580 * @nc_packet: the nc packet to be checked
 581 *
 582 * Checks whether the given sniffed (overheard) nc_packet has hit its buffering
 583 * timeout. If so, the packet is no longer kept and the entry deleted from the
 584 * queue. Has to be called with the appropriate locks.
 585 *
 586 * Return: false as soon as the entry in the fifo queue has not been timed out
 587 * yet and true otherwise.
 588 */
 589static bool batadv_nc_sniffed_purge(struct batadv_priv *bat_priv,
 590                                    struct batadv_nc_path *nc_path,
 591                                    struct batadv_nc_packet *nc_packet)
 592{
 593        unsigned long timeout = bat_priv->nc.max_buffer_time;
 594        bool res = false;
 595
 596        lockdep_assert_held(&nc_path->packet_list_lock);
 597
 598        /* Packets are added to tail, so the remaining packets did not time
 599         * out and we can stop processing the current queue
 600         */
 601        if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
 602            !batadv_has_timed_out(nc_packet->timestamp, timeout))
 603                goto out;
 604
 605        /* purge nc packet */
 606        list_del(&nc_packet->list);
 607        batadv_nc_packet_free(nc_packet, true);
 608
 609        res = true;
 610
 611out:
 612        return res;
 613}
 614
 615/**
 616 * batadv_nc_fwd_flush() - Checks the timestamp of the given nc packet.
 617 * @bat_priv: the bat priv with all the soft interface information
 618 * @nc_path: the nc path the packet belongs to
 619 * @nc_packet: the nc packet to be checked
 620 *
 621 * Checks whether the given nc packet has hit its forward timeout. If so, the
 622 * packet is no longer delayed, immediately sent and the entry deleted from the
 623 * queue. Has to be called with the appropriate locks.
 624 *
 625 * Return: false as soon as the entry in the fifo queue has not been timed out
 626 * yet and true otherwise.
 627 */
 628static bool batadv_nc_fwd_flush(struct batadv_priv *bat_priv,
 629                                struct batadv_nc_path *nc_path,
 630                                struct batadv_nc_packet *nc_packet)
 631{
 632        unsigned long timeout = bat_priv->nc.max_fwd_delay;
 633
 634        lockdep_assert_held(&nc_path->packet_list_lock);
 635
 636        /* Packets are added to tail, so the remaining packets did not time
 637         * out and we can stop processing the current queue
 638         */
 639        if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
 640            !batadv_has_timed_out(nc_packet->timestamp, timeout))
 641                return false;
 642
 643        /* Send packet */
 644        batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
 645        batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
 646                           nc_packet->skb->len + ETH_HLEN);
 647        list_del(&nc_packet->list);
 648        batadv_nc_send_packet(nc_packet);
 649
 650        return true;
 651}
 652
 653/**
 654 * batadv_nc_process_nc_paths() - traverse given nc packet pool and free timed
 655 *  out nc packets
 656 * @bat_priv: the bat priv with all the soft interface information
 657 * @hash: to be processed hash table
 658 * @process_fn: Function called to process given nc packet. Should return true
 659 *              to encourage this function to proceed with the next packet.
 660 *              Otherwise the rest of the current queue is skipped.
 661 */
 662static void
 663batadv_nc_process_nc_paths(struct batadv_priv *bat_priv,
 664                           struct batadv_hashtable *hash,
 665                           bool (*process_fn)(struct batadv_priv *,
 666                                              struct batadv_nc_path *,
 667                                              struct batadv_nc_packet *))
 668{
 669        struct hlist_head *head;
 670        struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
 671        struct batadv_nc_path *nc_path;
 672        bool ret;
 673        int i;
 674
 675        if (!hash)
 676                return;
 677
 678        /* Loop hash table bins */
 679        for (i = 0; i < hash->size; i++) {
 680                head = &hash->table[i];
 681
 682                /* Loop coding paths */
 683                rcu_read_lock();
 684                hlist_for_each_entry_rcu(nc_path, head, hash_entry) {
 685                        /* Loop packets */
 686                        spin_lock_bh(&nc_path->packet_list_lock);
 687                        list_for_each_entry_safe(nc_packet, nc_packet_tmp,
 688                                                 &nc_path->packet_list, list) {
 689                                ret = process_fn(bat_priv, nc_path, nc_packet);
 690                                if (!ret)
 691                                        break;
 692                        }
 693                        spin_unlock_bh(&nc_path->packet_list_lock);
 694                }
 695                rcu_read_unlock();
 696        }
 697}
 698
 699/**
 700 * batadv_nc_worker() - periodic task for housekeeping related to network
 701 *  coding
 702 * @work: kernel work struct
 703 */
 704static void batadv_nc_worker(struct work_struct *work)
 705{
 706        struct delayed_work *delayed_work;
 707        struct batadv_priv_nc *priv_nc;
 708        struct batadv_priv *bat_priv;
 709        unsigned long timeout;
 710
 711        delayed_work = to_delayed_work(work);
 712        priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
 713        bat_priv = container_of(priv_nc, struct batadv_priv, nc);
 714
 715        batadv_nc_purge_orig_hash(bat_priv);
 716        batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash,
 717                              batadv_nc_to_purge_nc_path_coding);
 718        batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash,
 719                              batadv_nc_to_purge_nc_path_decoding);
 720
 721        timeout = bat_priv->nc.max_fwd_delay;
 722
 723        if (batadv_has_timed_out(bat_priv->nc.timestamp_fwd_flush, timeout)) {
 724                batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.coding_hash,
 725                                           batadv_nc_fwd_flush);
 726                bat_priv->nc.timestamp_fwd_flush = jiffies;
 727        }
 728
 729        if (batadv_has_timed_out(bat_priv->nc.timestamp_sniffed_purge,
 730                                 bat_priv->nc.max_buffer_time)) {
 731                batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.decoding_hash,
 732                                           batadv_nc_sniffed_purge);
 733                bat_priv->nc.timestamp_sniffed_purge = jiffies;
 734        }
 735
 736        /* Schedule a new check */
 737        batadv_nc_start_timer(bat_priv);
 738}
 739
 740/**
 741 * batadv_can_nc_with_orig() - checks whether the given orig node is suitable
 742 *  for coding or not
 743 * @bat_priv: the bat priv with all the soft interface information
 744 * @orig_node: neighboring orig node which may be used as nc candidate
 745 * @ogm_packet: incoming ogm packet also used for the checks
 746 *
 747 * Return: true if:
 748 *  1) The OGM must have the most recent sequence number.
 749 *  2) The TTL must be decremented by one and only one.
 750 *  3) The OGM must be received from the first hop from orig_node.
 751 *  4) The TQ value of the OGM must be above bat_priv->nc.min_tq.
 752 */
 753static bool batadv_can_nc_with_orig(struct batadv_priv *bat_priv,
 754                                    struct batadv_orig_node *orig_node,
 755                                    struct batadv_ogm_packet *ogm_packet)
 756{
 757        struct batadv_orig_ifinfo *orig_ifinfo;
 758        u32 last_real_seqno;
 759        u8 last_ttl;
 760
 761        orig_ifinfo = batadv_orig_ifinfo_get(orig_node, BATADV_IF_DEFAULT);
 762        if (!orig_ifinfo)
 763                return false;
 764
 765        last_ttl = orig_ifinfo->last_ttl;
 766        last_real_seqno = orig_ifinfo->last_real_seqno;
 767        batadv_orig_ifinfo_put(orig_ifinfo);
 768
 769        if (last_real_seqno != ntohl(ogm_packet->seqno))
 770                return false;
 771        if (last_ttl != ogm_packet->ttl + 1)
 772                return false;
 773        if (!batadv_compare_eth(ogm_packet->orig, ogm_packet->prev_sender))
 774                return false;
 775        if (ogm_packet->tq < bat_priv->nc.min_tq)
 776                return false;
 777
 778        return true;
 779}
 780
 781/**
 782 * batadv_nc_find_nc_node() - search for an existing nc node and return it
 783 * @orig_node: orig node originating the ogm packet
 784 * @orig_neigh_node: neighboring orig node from which we received the ogm packet
 785 *  (can be equal to orig_node)
 786 * @in_coding: traverse incoming or outgoing network coding list
 787 *
 788 * Return: the nc_node if found, NULL otherwise.
 789 */
 790static struct batadv_nc_node *
 791batadv_nc_find_nc_node(struct batadv_orig_node *orig_node,
 792                       struct batadv_orig_node *orig_neigh_node,
 793                       bool in_coding)
 794{
 795        struct batadv_nc_node *nc_node, *nc_node_out = NULL;
 796        struct list_head *list;
 797
 798        if (in_coding)
 799                list = &orig_neigh_node->in_coding_list;
 800        else
 801                list = &orig_neigh_node->out_coding_list;
 802
 803        /* Traverse list of nc_nodes to orig_node */
 804        rcu_read_lock();
 805        list_for_each_entry_rcu(nc_node, list, list) {
 806                if (!batadv_compare_eth(nc_node->addr, orig_node->orig))
 807                        continue;
 808
 809                if (!kref_get_unless_zero(&nc_node->refcount))
 810                        continue;
 811
 812                /* Found a match */
 813                nc_node_out = nc_node;
 814                break;
 815        }
 816        rcu_read_unlock();
 817
 818        return nc_node_out;
 819}
 820
 821/**
 822 * batadv_nc_get_nc_node() - retrieves an nc node or creates the entry if it was
 823 *  not found
 824 * @bat_priv: the bat priv with all the soft interface information
 825 * @orig_node: orig node originating the ogm packet
 826 * @orig_neigh_node: neighboring orig node from which we received the ogm packet
 827 *  (can be equal to orig_node)
 828 * @in_coding: traverse incoming or outgoing network coding list
 829 *
 830 * Return: the nc_node if found or created, NULL in case of an error.
 831 */
 832static struct batadv_nc_node *
 833batadv_nc_get_nc_node(struct batadv_priv *bat_priv,
 834                      struct batadv_orig_node *orig_node,
 835                      struct batadv_orig_node *orig_neigh_node,
 836                      bool in_coding)
 837{
 838        struct batadv_nc_node *nc_node;
 839        spinlock_t *lock; /* Used to lock list selected by "int in_coding" */
 840        struct list_head *list;
 841
 842        /* Select ingoing or outgoing coding node */
 843        if (in_coding) {
 844                lock = &orig_neigh_node->in_coding_list_lock;
 845                list = &orig_neigh_node->in_coding_list;
 846        } else {
 847                lock = &orig_neigh_node->out_coding_list_lock;
 848                list = &orig_neigh_node->out_coding_list;
 849        }
 850
 851        spin_lock_bh(lock);
 852
 853        /* Check if nc_node is already added */
 854        nc_node = batadv_nc_find_nc_node(orig_node, orig_neigh_node, in_coding);
 855
 856        /* Node found */
 857        if (nc_node)
 858                goto unlock;
 859
 860        nc_node = kzalloc(sizeof(*nc_node), GFP_ATOMIC);
 861        if (!nc_node)
 862                goto unlock;
 863
 864        /* Initialize nc_node */
 865        INIT_LIST_HEAD(&nc_node->list);
 866        kref_init(&nc_node->refcount);
 867        ether_addr_copy(nc_node->addr, orig_node->orig);
 868        kref_get(&orig_neigh_node->refcount);
 869        nc_node->orig_node = orig_neigh_node;
 870
 871        batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_node %pM -> %pM\n",
 872                   nc_node->addr, nc_node->orig_node->orig);
 873
 874        /* Add nc_node to orig_node */
 875        kref_get(&nc_node->refcount);
 876        list_add_tail_rcu(&nc_node->list, list);
 877
 878unlock:
 879        spin_unlock_bh(lock);
 880
 881        return nc_node;
 882}
 883
 884/**
 885 * batadv_nc_update_nc_node() - updates stored incoming and outgoing nc node
 886 *  structs (best called on incoming OGMs)
 887 * @bat_priv: the bat priv with all the soft interface information
 888 * @orig_node: orig node originating the ogm packet
 889 * @orig_neigh_node: neighboring orig node from which we received the ogm packet
 890 *  (can be equal to orig_node)
 891 * @ogm_packet: incoming ogm packet
 892 * @is_single_hop_neigh: orig_node is a single hop neighbor
 893 */
 894void batadv_nc_update_nc_node(struct batadv_priv *bat_priv,
 895                              struct batadv_orig_node *orig_node,
 896                              struct batadv_orig_node *orig_neigh_node,
 897                              struct batadv_ogm_packet *ogm_packet,
 898                              int is_single_hop_neigh)
 899{
 900        struct batadv_nc_node *in_nc_node = NULL;
 901        struct batadv_nc_node *out_nc_node = NULL;
 902
 903        /* Check if network coding is enabled */
 904        if (!atomic_read(&bat_priv->network_coding))
 905                goto out;
 906
 907        /* check if orig node is network coding enabled */
 908        if (!test_bit(BATADV_ORIG_CAPA_HAS_NC, &orig_node->capabilities))
 909                goto out;
 910
 911        /* accept ogms from 'good' neighbors and single hop neighbors */
 912        if (!batadv_can_nc_with_orig(bat_priv, orig_node, ogm_packet) &&
 913            !is_single_hop_neigh)
 914                goto out;
 915
 916        /* Add orig_node as in_nc_node on hop */
 917        in_nc_node = batadv_nc_get_nc_node(bat_priv, orig_node,
 918                                           orig_neigh_node, true);
 919        if (!in_nc_node)
 920                goto out;
 921
 922        in_nc_node->last_seen = jiffies;
 923
 924        /* Add hop as out_nc_node on orig_node */
 925        out_nc_node = batadv_nc_get_nc_node(bat_priv, orig_neigh_node,
 926                                            orig_node, false);
 927        if (!out_nc_node)
 928                goto out;
 929
 930        out_nc_node->last_seen = jiffies;
 931
 932out:
 933        if (in_nc_node)
 934                batadv_nc_node_put(in_nc_node);
 935        if (out_nc_node)
 936                batadv_nc_node_put(out_nc_node);
 937}
 938
 939/**
 940 * batadv_nc_get_path() - get existing nc_path or allocate a new one
 941 * @bat_priv: the bat priv with all the soft interface information
 942 * @hash: hash table containing the nc path
 943 * @src: ethernet source address - first half of the nc path search key
 944 * @dst: ethernet destination address - second half of the nc path search key
 945 *
 946 * Return: pointer to nc_path if the path was found or created, returns NULL
 947 * on error.
 948 */
 949static struct batadv_nc_path *batadv_nc_get_path(struct batadv_priv *bat_priv,
 950                                                 struct batadv_hashtable *hash,
 951                                                 u8 *src,
 952                                                 u8 *dst)
 953{
 954        int hash_added;
 955        struct batadv_nc_path *nc_path, nc_path_key;
 956
 957        batadv_nc_hash_key_gen(&nc_path_key, src, dst);
 958
 959        /* Search for existing nc_path */
 960        nc_path = batadv_nc_hash_find(hash, (void *)&nc_path_key);
 961
 962        if (nc_path) {
 963                /* Set timestamp to delay removal of nc_path */
 964                nc_path->last_valid = jiffies;
 965                return nc_path;
 966        }
 967
 968        /* No existing nc_path was found; create a new */
 969        nc_path = kzalloc(sizeof(*nc_path), GFP_ATOMIC);
 970
 971        if (!nc_path)
 972                return NULL;
 973
 974        /* Initialize nc_path */
 975        INIT_LIST_HEAD(&nc_path->packet_list);
 976        spin_lock_init(&nc_path->packet_list_lock);
 977        kref_init(&nc_path->refcount);
 978        nc_path->last_valid = jiffies;
 979        ether_addr_copy(nc_path->next_hop, dst);
 980        ether_addr_copy(nc_path->prev_hop, src);
 981
 982        batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_path %pM -> %pM\n",
 983                   nc_path->prev_hop,
 984                   nc_path->next_hop);
 985
 986        /* Add nc_path to hash table */
 987        kref_get(&nc_path->refcount);
 988        hash_added = batadv_hash_add(hash, batadv_nc_hash_compare,
 989                                     batadv_nc_hash_choose, &nc_path_key,
 990                                     &nc_path->hash_entry);
 991
 992        if (hash_added < 0) {
 993                kfree(nc_path);
 994                return NULL;
 995        }
 996
 997        return nc_path;
 998}
 999
1000/**
1001 * batadv_nc_random_weight_tq() - scale the receivers TQ-value to avoid unfair
1002 *  selection of a receiver with slightly lower TQ than the other
1003 * @tq: to be weighted tq value
1004 *
1005 * Return: scaled tq value
1006 */
1007static u8 batadv_nc_random_weight_tq(u8 tq)
1008{
1009        /* randomize the estimated packet loss (max TQ - estimated TQ) */
1010        u8 rand_tq = prandom_u32_max(BATADV_TQ_MAX_VALUE + 1 - tq);
1011
1012        /* convert to (randomized) estimated tq again */
1013        return BATADV_TQ_MAX_VALUE - rand_tq;
1014}
1015
1016/**
1017 * batadv_nc_memxor() - XOR destination with source
1018 * @dst: byte array to XOR into
1019 * @src: byte array to XOR from
1020 * @len: length of destination array
1021 */
1022static void batadv_nc_memxor(char *dst, const char *src, unsigned int len)
1023{
1024        unsigned int i;
1025
1026        for (i = 0; i < len; ++i)
1027                dst[i] ^= src[i];
1028}
1029
1030/**
1031 * batadv_nc_code_packets() - code a received unicast_packet with an nc packet
1032 *  into a coded_packet and send it
1033 * @bat_priv: the bat priv with all the soft interface information
1034 * @skb: data skb to forward
1035 * @ethhdr: pointer to the ethernet header inside the skb
1036 * @nc_packet: structure containing the packet to the skb can be coded with
1037 * @neigh_node: next hop to forward packet to
1038 *
1039 * Return: true if both packets are consumed, false otherwise.
1040 */
1041static bool batadv_nc_code_packets(struct batadv_priv *bat_priv,
1042                                   struct sk_buff *skb,
1043                                   struct ethhdr *ethhdr,
1044                                   struct batadv_nc_packet *nc_packet,
1045                                   struct batadv_neigh_node *neigh_node)
1046{
1047        u8 tq_weighted_neigh, tq_weighted_coding, tq_tmp;
1048        struct sk_buff *skb_dest, *skb_src;
1049        struct batadv_unicast_packet *packet1;
1050        struct batadv_unicast_packet *packet2;
1051        struct batadv_coded_packet *coded_packet;
1052        struct batadv_neigh_node *neigh_tmp, *router_neigh, *first_dest;
1053        struct batadv_neigh_node *router_coding = NULL, *second_dest;
1054        struct batadv_neigh_ifinfo *router_neigh_ifinfo = NULL;
1055        struct batadv_neigh_ifinfo *router_coding_ifinfo = NULL;
1056        u8 *first_source, *second_source;
1057        __be32 packet_id1, packet_id2;
1058        size_t count;
1059        bool res = false;
1060        int coding_len;
1061        int unicast_size = sizeof(*packet1);
1062        int coded_size = sizeof(*coded_packet);
1063        int header_add = coded_size - unicast_size;
1064
1065        /* TODO: do we need to consider the outgoing interface for
1066         * coded packets?
1067         */
1068        router_neigh = batadv_orig_router_get(neigh_node->orig_node,
1069                                              BATADV_IF_DEFAULT);
1070        if (!router_neigh)
1071                goto out;
1072
1073        router_neigh_ifinfo = batadv_neigh_ifinfo_get(router_neigh,
1074                                                      BATADV_IF_DEFAULT);
1075        if (!router_neigh_ifinfo)
1076                goto out;
1077
1078        neigh_tmp = nc_packet->neigh_node;
1079        router_coding = batadv_orig_router_get(neigh_tmp->orig_node,
1080                                               BATADV_IF_DEFAULT);
1081        if (!router_coding)
1082                goto out;
1083
1084        router_coding_ifinfo = batadv_neigh_ifinfo_get(router_coding,
1085                                                       BATADV_IF_DEFAULT);
1086        if (!router_coding_ifinfo)
1087                goto out;
1088
1089        tq_tmp = router_neigh_ifinfo->bat_iv.tq_avg;
1090        tq_weighted_neigh = batadv_nc_random_weight_tq(tq_tmp);
1091        tq_tmp = router_coding_ifinfo->bat_iv.tq_avg;
1092        tq_weighted_coding = batadv_nc_random_weight_tq(tq_tmp);
1093
1094        /* Select one destination for the MAC-header dst-field based on
1095         * weighted TQ-values.
1096         */
1097        if (tq_weighted_neigh >= tq_weighted_coding) {
1098                /* Destination from nc_packet is selected for MAC-header */
1099                first_dest = nc_packet->neigh_node;
1100                first_source = nc_packet->nc_path->prev_hop;
1101                second_dest = neigh_node;
1102                second_source = ethhdr->h_source;
1103                packet1 = (struct batadv_unicast_packet *)nc_packet->skb->data;
1104                packet2 = (struct batadv_unicast_packet *)skb->data;
1105                packet_id1 = nc_packet->packet_id;
1106                packet_id2 = batadv_skb_crc32(skb,
1107                                              skb->data + sizeof(*packet2));
1108        } else {
1109                /* Destination for skb is selected for MAC-header */
1110                first_dest = neigh_node;
1111                first_source = ethhdr->h_source;
1112                second_dest = nc_packet->neigh_node;
1113                second_source = nc_packet->nc_path->prev_hop;
1114                packet1 = (struct batadv_unicast_packet *)skb->data;
1115                packet2 = (struct batadv_unicast_packet *)nc_packet->skb->data;
1116                packet_id1 = batadv_skb_crc32(skb,
1117                                              skb->data + sizeof(*packet1));
1118                packet_id2 = nc_packet->packet_id;
1119        }
1120
1121        /* Instead of zero padding the smallest data buffer, we
1122         * code into the largest.
1123         */
1124        if (skb->len <= nc_packet->skb->len) {
1125                skb_dest = nc_packet->skb;
1126                skb_src = skb;
1127        } else {
1128                skb_dest = skb;
1129                skb_src = nc_packet->skb;
1130        }
1131
1132        /* coding_len is used when decoding the packet shorter packet */
1133        coding_len = skb_src->len - unicast_size;
1134
1135        if (skb_linearize(skb_dest) < 0 || skb_linearize(skb_src) < 0)
1136                goto out;
1137
1138        skb_push(skb_dest, header_add);
1139
1140        coded_packet = (struct batadv_coded_packet *)skb_dest->data;
1141        skb_reset_mac_header(skb_dest);
1142
1143        coded_packet->packet_type = BATADV_CODED;
1144        coded_packet->version = BATADV_COMPAT_VERSION;
1145        coded_packet->ttl = packet1->ttl;
1146
1147        /* Info about first unicast packet */
1148        ether_addr_copy(coded_packet->first_source, first_source);
1149        ether_addr_copy(coded_packet->first_orig_dest, packet1->dest);
1150        coded_packet->first_crc = packet_id1;
1151        coded_packet->first_ttvn = packet1->ttvn;
1152
1153        /* Info about second unicast packet */
1154        ether_addr_copy(coded_packet->second_dest, second_dest->addr);
1155        ether_addr_copy(coded_packet->second_source, second_source);
1156        ether_addr_copy(coded_packet->second_orig_dest, packet2->dest);
1157        coded_packet->second_crc = packet_id2;
1158        coded_packet->second_ttl = packet2->ttl;
1159        coded_packet->second_ttvn = packet2->ttvn;
1160        coded_packet->coded_len = htons(coding_len);
1161
1162        /* This is where the magic happens: Code skb_src into skb_dest */
1163        batadv_nc_memxor(skb_dest->data + coded_size,
1164                         skb_src->data + unicast_size, coding_len);
1165
1166        /* Update counters accordingly */
1167        if (BATADV_SKB_CB(skb_src)->decoded &&
1168            BATADV_SKB_CB(skb_dest)->decoded) {
1169                /* Both packets are recoded */
1170                count = skb_src->len + ETH_HLEN;
1171                count += skb_dest->len + ETH_HLEN;
1172                batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE, 2);
1173                batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES, count);
1174        } else if (!BATADV_SKB_CB(skb_src)->decoded &&
1175                   !BATADV_SKB_CB(skb_dest)->decoded) {
1176                /* Both packets are newly coded */
1177                count = skb_src->len + ETH_HLEN;
1178                count += skb_dest->len + ETH_HLEN;
1179                batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE, 2);
1180                batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES, count);
1181        } else if (BATADV_SKB_CB(skb_src)->decoded &&
1182                   !BATADV_SKB_CB(skb_dest)->decoded) {
1183                /* skb_src recoded and skb_dest is newly coded */
1184                batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
1185                batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
1186                                   skb_src->len + ETH_HLEN);
1187                batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
1188                batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
1189                                   skb_dest->len + ETH_HLEN);
1190        } else if (!BATADV_SKB_CB(skb_src)->decoded &&
1191                   BATADV_SKB_CB(skb_dest)->decoded) {
1192                /* skb_src is newly coded and skb_dest is recoded */
1193                batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
1194                batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
1195                                   skb_src->len + ETH_HLEN);
1196                batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
1197                batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
1198                                   skb_dest->len + ETH_HLEN);
1199        }
1200
1201        /* skb_src is now coded into skb_dest, so free it */
1202        consume_skb(skb_src);
1203
1204        /* avoid duplicate free of skb from nc_packet */
1205        nc_packet->skb = NULL;
1206        batadv_nc_packet_free(nc_packet, false);
1207
1208        /* Send the coded packet and return true */
1209        batadv_send_unicast_skb(skb_dest, first_dest);
1210        res = true;
1211out:
1212        if (router_neigh)
1213                batadv_neigh_node_put(router_neigh);
1214        if (router_coding)
1215                batadv_neigh_node_put(router_coding);
1216        if (router_neigh_ifinfo)
1217                batadv_neigh_ifinfo_put(router_neigh_ifinfo);
1218        if (router_coding_ifinfo)
1219                batadv_neigh_ifinfo_put(router_coding_ifinfo);
1220        return res;
1221}
1222
1223/**
1224 * batadv_nc_skb_coding_possible() - true if a decoded skb is available at dst.
1225 * @skb: data skb to forward
1226 * @dst: destination mac address of the other skb to code with
1227 * @src: source mac address of skb
1228 *
1229 * Whenever we network code a packet we have to check whether we received it in
1230 * a network coded form. If so, we may not be able to use it for coding because
1231 * some neighbors may also have received (overheard) the packet in the network
1232 * coded form without being able to decode it. It is hard to know which of the
1233 * neighboring nodes was able to decode the packet, therefore we can only
1234 * re-code the packet if the source of the previous encoded packet is involved.
1235 * Since the source encoded the packet we can be certain it has all necessary
1236 * decode information.
1237 *
1238 * Return: true if coding of a decoded packet is allowed.
1239 */
1240static bool batadv_nc_skb_coding_possible(struct sk_buff *skb, u8 *dst, u8 *src)
1241{
1242        if (BATADV_SKB_CB(skb)->decoded && !batadv_compare_eth(dst, src))
1243                return false;
1244        return true;
1245}
1246
1247/**
1248 * batadv_nc_path_search() - Find the coding path matching in_nc_node and
1249 *  out_nc_node to retrieve a buffered packet that can be used for coding.
1250 * @bat_priv: the bat priv with all the soft interface information
1251 * @in_nc_node: pointer to skb next hop's neighbor nc node
1252 * @out_nc_node: pointer to skb source's neighbor nc node
1253 * @skb: data skb to forward
1254 * @eth_dst: next hop mac address of skb
1255 *
1256 * Return: true if coding of a decoded skb is allowed.
1257 */
1258static struct batadv_nc_packet *
1259batadv_nc_path_search(struct batadv_priv *bat_priv,
1260                      struct batadv_nc_node *in_nc_node,
1261                      struct batadv_nc_node *out_nc_node,
1262                      struct sk_buff *skb,
1263                      u8 *eth_dst)
1264{
1265        struct batadv_nc_path *nc_path, nc_path_key;
1266        struct batadv_nc_packet *nc_packet_out = NULL;
1267        struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
1268        struct batadv_hashtable *hash = bat_priv->nc.coding_hash;
1269        int idx;
1270
1271        if (!hash)
1272                return NULL;
1273
1274        /* Create almost path key */
1275        batadv_nc_hash_key_gen(&nc_path_key, in_nc_node->addr,
1276                               out_nc_node->addr);
1277        idx = batadv_nc_hash_choose(&nc_path_key, hash->size);
1278
1279        /* Check for coding opportunities in this nc_path */
1280        rcu_read_lock();
1281        hlist_for_each_entry_rcu(nc_path, &hash->table[idx], hash_entry) {
1282                if (!batadv_compare_eth(nc_path->prev_hop, in_nc_node->addr))
1283                        continue;
1284
1285                if (!batadv_compare_eth(nc_path->next_hop, out_nc_node->addr))
1286                        continue;
1287
1288                spin_lock_bh(&nc_path->packet_list_lock);
1289                if (list_empty(&nc_path->packet_list)) {
1290                        spin_unlock_bh(&nc_path->packet_list_lock);
1291                        continue;
1292                }
1293
1294                list_for_each_entry_safe(nc_packet, nc_packet_tmp,
1295                                         &nc_path->packet_list, list) {
1296                        if (!batadv_nc_skb_coding_possible(nc_packet->skb,
1297                                                           eth_dst,
1298                                                           in_nc_node->addr))
1299                                continue;
1300
1301                        /* Coding opportunity is found! */
1302                        list_del(&nc_packet->list);
1303                        nc_packet_out = nc_packet;
1304                        break;
1305                }
1306
1307                spin_unlock_bh(&nc_path->packet_list_lock);
1308                break;
1309        }
1310        rcu_read_unlock();
1311
1312        return nc_packet_out;
1313}
1314
1315/**
1316 * batadv_nc_skb_src_search() - Loops through the list of neighboring nodes of
1317 *  the skb's sender (may be equal to the originator).
1318 * @bat_priv: the bat priv with all the soft interface information
1319 * @skb: data skb to forward
1320 * @eth_dst: next hop mac address of skb
1321 * @eth_src: source mac address of skb
1322 * @in_nc_node: pointer to skb next hop's neighbor nc node
1323 *
1324 * Return: an nc packet if a suitable coding packet was found, NULL otherwise.
1325 */
1326static struct batadv_nc_packet *
1327batadv_nc_skb_src_search(struct batadv_priv *bat_priv,
1328                         struct sk_buff *skb,
1329                         u8 *eth_dst,
1330                         u8 *eth_src,
1331                         struct batadv_nc_node *in_nc_node)
1332{
1333        struct batadv_orig_node *orig_node;
1334        struct batadv_nc_node *out_nc_node;
1335        struct batadv_nc_packet *nc_packet = NULL;
1336
1337        orig_node = batadv_orig_hash_find(bat_priv, eth_src);
1338        if (!orig_node)
1339                return NULL;
1340
1341        rcu_read_lock();
1342        list_for_each_entry_rcu(out_nc_node,
1343                                &orig_node->out_coding_list, list) {
1344                /* Check if the skb is decoded and if recoding is possible */
1345                if (!batadv_nc_skb_coding_possible(skb,
1346                                                   out_nc_node->addr, eth_src))
1347                        continue;
1348
1349                /* Search for an opportunity in this nc_path */
1350                nc_packet = batadv_nc_path_search(bat_priv, in_nc_node,
1351                                                  out_nc_node, skb, eth_dst);
1352                if (nc_packet)
1353                        break;
1354        }
1355        rcu_read_unlock();
1356
1357        batadv_orig_node_put(orig_node);
1358        return nc_packet;
1359}
1360
1361/**
1362 * batadv_nc_skb_store_before_coding() - set the ethernet src and dst of the
1363 *  unicast skb before it is stored for use in later decoding
1364 * @bat_priv: the bat priv with all the soft interface information
1365 * @skb: data skb to store
1366 * @eth_dst_new: new destination mac address of skb
1367 */
1368static void batadv_nc_skb_store_before_coding(struct batadv_priv *bat_priv,
1369                                              struct sk_buff *skb,
1370                                              u8 *eth_dst_new)
1371{
1372        struct ethhdr *ethhdr;
1373
1374        /* Copy skb header to change the mac header */
1375        skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
1376        if (!skb)
1377                return;
1378
1379        /* Set the mac header as if we actually sent the packet uncoded */
1380        ethhdr = eth_hdr(skb);
1381        ether_addr_copy(ethhdr->h_source, ethhdr->h_dest);
1382        ether_addr_copy(ethhdr->h_dest, eth_dst_new);
1383
1384        /* Set data pointer to MAC header to mimic packets from our tx path */
1385        skb_push(skb, ETH_HLEN);
1386
1387        /* Add the packet to the decoding packet pool */
1388        batadv_nc_skb_store_for_decoding(bat_priv, skb);
1389
1390        /* batadv_nc_skb_store_for_decoding() clones the skb, so we must free
1391         * our ref
1392         */
1393        consume_skb(skb);
1394}
1395
1396/**
1397 * batadv_nc_skb_dst_search() - Loops through list of neighboring nodes to dst.
1398 * @skb: data skb to forward
1399 * @neigh_node: next hop to forward packet to
1400 * @ethhdr: pointer to the ethernet header inside the skb
1401 *
1402 * Loops through the list of neighboring nodes the next hop has a good
1403 * connection to (receives OGMs with a sufficient quality). We need to find a
1404 * neighbor of our next hop that potentially sent a packet which our next hop
1405 * also received (overheard) and has stored for later decoding.
1406 *
1407 * Return: true if the skb was consumed (encoded packet sent) or false otherwise
1408 */
1409static bool batadv_nc_skb_dst_search(struct sk_buff *skb,
1410                                     struct batadv_neigh_node *neigh_node,
1411                                     struct ethhdr *ethhdr)
1412{
1413        struct net_device *netdev = neigh_node->if_incoming->soft_iface;
1414        struct batadv_priv *bat_priv = netdev_priv(netdev);
1415        struct batadv_orig_node *orig_node = neigh_node->orig_node;
1416        struct batadv_nc_node *nc_node;
1417        struct batadv_nc_packet *nc_packet = NULL;
1418
1419        rcu_read_lock();
1420        list_for_each_entry_rcu(nc_node, &orig_node->in_coding_list, list) {
1421                /* Search for coding opportunity with this in_nc_node */
1422                nc_packet = batadv_nc_skb_src_search(bat_priv, skb,
1423                                                     neigh_node->addr,
1424                                                     ethhdr->h_source, nc_node);
1425
1426                /* Opportunity was found, so stop searching */
1427                if (nc_packet)
1428                        break;
1429        }
1430        rcu_read_unlock();
1431
1432        if (!nc_packet)
1433                return false;
1434
1435        /* Save packets for later decoding */
1436        batadv_nc_skb_store_before_coding(bat_priv, skb,
1437                                          neigh_node->addr);
1438        batadv_nc_skb_store_before_coding(bat_priv, nc_packet->skb,
1439                                          nc_packet->neigh_node->addr);
1440
1441        /* Code and send packets */
1442        if (batadv_nc_code_packets(bat_priv, skb, ethhdr, nc_packet,
1443                                   neigh_node))
1444                return true;
1445
1446        /* out of mem ? Coding failed - we have to free the buffered packet
1447         * to avoid memleaks. The skb passed as argument will be dealt with
1448         * by the calling function.
1449         */
1450        batadv_nc_send_packet(nc_packet);
1451        return false;
1452}
1453
1454/**
1455 * batadv_nc_skb_add_to_path() - buffer skb for later encoding / decoding
1456 * @skb: skb to add to path
1457 * @nc_path: path to add skb to
1458 * @neigh_node: next hop to forward packet to
1459 * @packet_id: checksum to identify packet
1460 *
1461 * Return: true if the packet was buffered or false in case of an error.
1462 */
1463static bool batadv_nc_skb_add_to_path(struct sk_buff *skb,
1464                                      struct batadv_nc_path *nc_path,
1465                                      struct batadv_neigh_node *neigh_node,
1466                                      __be32 packet_id)
1467{
1468        struct batadv_nc_packet *nc_packet;
1469
1470        nc_packet = kzalloc(sizeof(*nc_packet), GFP_ATOMIC);
1471        if (!nc_packet)
1472                return false;
1473
1474        /* Initialize nc_packet */
1475        nc_packet->timestamp = jiffies;
1476        nc_packet->packet_id = packet_id;
1477        nc_packet->skb = skb;
1478        nc_packet->neigh_node = neigh_node;
1479        nc_packet->nc_path = nc_path;
1480
1481        /* Add coding packet to list */
1482        spin_lock_bh(&nc_path->packet_list_lock);
1483        list_add_tail(&nc_packet->list, &nc_path->packet_list);
1484        spin_unlock_bh(&nc_path->packet_list_lock);
1485
1486        return true;
1487}
1488
1489/**
1490 * batadv_nc_skb_forward() - try to code a packet or add it to the coding packet
1491 *  buffer
1492 * @skb: data skb to forward
1493 * @neigh_node: next hop to forward packet to
1494 *
1495 * Return: true if the skb was consumed (encoded packet sent) or false otherwise
1496 */
1497bool batadv_nc_skb_forward(struct sk_buff *skb,
1498                           struct batadv_neigh_node *neigh_node)
1499{
1500        const struct net_device *netdev = neigh_node->if_incoming->soft_iface;
1501        struct batadv_priv *bat_priv = netdev_priv(netdev);
1502        struct batadv_unicast_packet *packet;
1503        struct batadv_nc_path *nc_path;
1504        struct ethhdr *ethhdr = eth_hdr(skb);
1505        __be32 packet_id;
1506        u8 *payload;
1507
1508        /* Check if network coding is enabled */
1509        if (!atomic_read(&bat_priv->network_coding))
1510                goto out;
1511
1512        /* We only handle unicast packets */
1513        payload = skb_network_header(skb);
1514        packet = (struct batadv_unicast_packet *)payload;
1515        if (packet->packet_type != BATADV_UNICAST)
1516                goto out;
1517
1518        /* Try to find a coding opportunity and send the skb if one is found */
1519        if (batadv_nc_skb_dst_search(skb, neigh_node, ethhdr))
1520                return true;
1521
1522        /* Find or create a nc_path for this src-dst pair */
1523        nc_path = batadv_nc_get_path(bat_priv,
1524                                     bat_priv->nc.coding_hash,
1525                                     ethhdr->h_source,
1526                                     neigh_node->addr);
1527
1528        if (!nc_path)
1529                goto out;
1530
1531        /* Add skb to nc_path */
1532        packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
1533        if (!batadv_nc_skb_add_to_path(skb, nc_path, neigh_node, packet_id))
1534                goto free_nc_path;
1535
1536        /* Packet is consumed */
1537        return true;
1538
1539free_nc_path:
1540        batadv_nc_path_put(nc_path);
1541out:
1542        /* Packet is not consumed */
1543        return false;
1544}
1545
1546/**
1547 * batadv_nc_skb_store_for_decoding() - save a clone of the skb which can be
1548 *  used when decoding coded packets
1549 * @bat_priv: the bat priv with all the soft interface information
1550 * @skb: data skb to store
1551 */
1552void batadv_nc_skb_store_for_decoding(struct batadv_priv *bat_priv,
1553                                      struct sk_buff *skb)
1554{
1555        struct batadv_unicast_packet *packet;
1556        struct batadv_nc_path *nc_path;
1557        struct ethhdr *ethhdr = eth_hdr(skb);
1558        __be32 packet_id;
1559        u8 *payload;
1560
1561        /* Check if network coding is enabled */
1562        if (!atomic_read(&bat_priv->network_coding))
1563                goto out;
1564
1565        /* Check for supported packet type */
1566        payload = skb_network_header(skb);
1567        packet = (struct batadv_unicast_packet *)payload;
1568        if (packet->packet_type != BATADV_UNICAST)
1569                goto out;
1570
1571        /* Find existing nc_path or create a new */
1572        nc_path = batadv_nc_get_path(bat_priv,
1573                                     bat_priv->nc.decoding_hash,
1574                                     ethhdr->h_source,
1575                                     ethhdr->h_dest);
1576
1577        if (!nc_path)
1578                goto out;
1579
1580        /* Clone skb and adjust skb->data to point at batman header */
1581        skb = skb_clone(skb, GFP_ATOMIC);
1582        if (unlikely(!skb))
1583                goto free_nc_path;
1584
1585        if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
1586                goto free_skb;
1587
1588        if (unlikely(!skb_pull_rcsum(skb, ETH_HLEN)))
1589                goto free_skb;
1590
1591        /* Add skb to nc_path */
1592        packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
1593        if (!batadv_nc_skb_add_to_path(skb, nc_path, NULL, packet_id))
1594                goto free_skb;
1595
1596        batadv_inc_counter(bat_priv, BATADV_CNT_NC_BUFFER);
1597        return;
1598
1599free_skb:
1600        kfree_skb(skb);
1601free_nc_path:
1602        batadv_nc_path_put(nc_path);
1603out:
1604        return;
1605}
1606
1607/**
1608 * batadv_nc_skb_store_sniffed_unicast() - check if a received unicast packet
1609 *  should be saved in the decoding buffer and, if so, store it there
1610 * @bat_priv: the bat priv with all the soft interface information
1611 * @skb: unicast skb to store
1612 */
1613void batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
1614                                         struct sk_buff *skb)
1615{
1616        struct ethhdr *ethhdr = eth_hdr(skb);
1617
1618        if (batadv_is_my_mac(bat_priv, ethhdr->h_dest))
1619                return;
1620
1621        /* Set data pointer to MAC header to mimic packets from our tx path */
1622        skb_push(skb, ETH_HLEN);
1623
1624        batadv_nc_skb_store_for_decoding(bat_priv, skb);
1625}
1626
1627/**
1628 * batadv_nc_skb_decode_packet() - decode given skb using the decode data stored
1629 *  in nc_packet
1630 * @bat_priv: the bat priv with all the soft interface information
1631 * @skb: unicast skb to decode
1632 * @nc_packet: decode data needed to decode the skb
1633 *
1634 * Return: pointer to decoded unicast packet if the packet was decoded or NULL
1635 * in case of an error.
1636 */
1637static struct batadv_unicast_packet *
1638batadv_nc_skb_decode_packet(struct batadv_priv *bat_priv, struct sk_buff *skb,
1639                            struct batadv_nc_packet *nc_packet)
1640{
1641        const int h_size = sizeof(struct batadv_unicast_packet);
1642        const int h_diff = sizeof(struct batadv_coded_packet) - h_size;
1643        struct batadv_unicast_packet *unicast_packet;
1644        struct batadv_coded_packet coded_packet_tmp;
1645        struct ethhdr *ethhdr, ethhdr_tmp;
1646        u8 *orig_dest, ttl, ttvn;
1647        unsigned int coding_len;
1648        int err;
1649
1650        /* Save headers temporarily */
1651        memcpy(&coded_packet_tmp, skb->data, sizeof(coded_packet_tmp));
1652        memcpy(&ethhdr_tmp, skb_mac_header(skb), sizeof(ethhdr_tmp));
1653
1654        if (skb_cow(skb, 0) < 0)
1655                return NULL;
1656
1657        if (unlikely(!skb_pull_rcsum(skb, h_diff)))
1658                return NULL;
1659
1660        /* Data points to batman header, so set mac header 14 bytes before
1661         * and network to data
1662         */
1663        skb_set_mac_header(skb, -ETH_HLEN);
1664        skb_reset_network_header(skb);
1665
1666        /* Reconstruct original mac header */
1667        ethhdr = eth_hdr(skb);
1668        *ethhdr = ethhdr_tmp;
1669
1670        /* Select the correct unicast header information based on the location
1671         * of our mac address in the coded_packet header
1672         */
1673        if (batadv_is_my_mac(bat_priv, coded_packet_tmp.second_dest)) {
1674                /* If we are the second destination the packet was overheard,
1675                 * so the Ethernet address must be copied to h_dest and
1676                 * pkt_type changed from PACKET_OTHERHOST to PACKET_HOST
1677                 */
1678                ether_addr_copy(ethhdr->h_dest, coded_packet_tmp.second_dest);
1679                skb->pkt_type = PACKET_HOST;
1680
1681                orig_dest = coded_packet_tmp.second_orig_dest;
1682                ttl = coded_packet_tmp.second_ttl;
1683                ttvn = coded_packet_tmp.second_ttvn;
1684        } else {
1685                orig_dest = coded_packet_tmp.first_orig_dest;
1686                ttl = coded_packet_tmp.ttl;
1687                ttvn = coded_packet_tmp.first_ttvn;
1688        }
1689
1690        coding_len = ntohs(coded_packet_tmp.coded_len);
1691
1692        if (coding_len > skb->len)
1693                return NULL;
1694
1695        /* Here the magic is reversed:
1696         *   extract the missing packet from the received coded packet
1697         */
1698        batadv_nc_memxor(skb->data + h_size,
1699                         nc_packet->skb->data + h_size,
1700                         coding_len);
1701
1702        /* Resize decoded skb if decoded with larger packet */
1703        if (nc_packet->skb->len > coding_len + h_size) {
1704                err = pskb_trim_rcsum(skb, coding_len + h_size);
1705                if (err)
1706                        return NULL;
1707        }
1708
1709        /* Create decoded unicast packet */
1710        unicast_packet = (struct batadv_unicast_packet *)skb->data;
1711        unicast_packet->packet_type = BATADV_UNICAST;
1712        unicast_packet->version = BATADV_COMPAT_VERSION;
1713        unicast_packet->ttl = ttl;
1714        ether_addr_copy(unicast_packet->dest, orig_dest);
1715        unicast_packet->ttvn = ttvn;
1716
1717        batadv_nc_packet_free(nc_packet, false);
1718        return unicast_packet;
1719}
1720
1721/**
1722 * batadv_nc_find_decoding_packet() - search through buffered decoding data to
1723 *  find the data needed to decode the coded packet
1724 * @bat_priv: the bat priv with all the soft interface information
1725 * @ethhdr: pointer to the ethernet header inside the coded packet
1726 * @coded: coded packet we try to find decode data for
1727 *
1728 * Return: pointer to nc packet if the needed data was found or NULL otherwise.
1729 */
1730static struct batadv_nc_packet *
1731batadv_nc_find_decoding_packet(struct batadv_priv *bat_priv,
1732                               struct ethhdr *ethhdr,
1733                               struct batadv_coded_packet *coded)
1734{
1735        struct batadv_hashtable *hash = bat_priv->nc.decoding_hash;
1736        struct batadv_nc_packet *tmp_nc_packet, *nc_packet = NULL;
1737        struct batadv_nc_path *nc_path, nc_path_key;
1738        u8 *dest, *source;
1739        __be32 packet_id;
1740        int index;
1741
1742        if (!hash)
1743                return NULL;
1744
1745        /* Select the correct packet id based on the location of our mac-addr */
1746        dest = ethhdr->h_source;
1747        if (!batadv_is_my_mac(bat_priv, coded->second_dest)) {
1748                source = coded->second_source;
1749                packet_id = coded->second_crc;
1750        } else {
1751                source = coded->first_source;
1752                packet_id = coded->first_crc;
1753        }
1754
1755        batadv_nc_hash_key_gen(&nc_path_key, source, dest);
1756        index = batadv_nc_hash_choose(&nc_path_key, hash->size);
1757
1758        /* Search for matching coding path */
1759        rcu_read_lock();
1760        hlist_for_each_entry_rcu(nc_path, &hash->table[index], hash_entry) {
1761                /* Find matching nc_packet */
1762                spin_lock_bh(&nc_path->packet_list_lock);
1763                list_for_each_entry(tmp_nc_packet,
1764                                    &nc_path->packet_list, list) {
1765                        if (packet_id == tmp_nc_packet->packet_id) {
1766                                list_del(&tmp_nc_packet->list);
1767
1768                                nc_packet = tmp_nc_packet;
1769                                break;
1770                        }
1771                }
1772                spin_unlock_bh(&nc_path->packet_list_lock);
1773
1774                if (nc_packet)
1775                        break;
1776        }
1777        rcu_read_unlock();
1778
1779        if (!nc_packet)
1780                batadv_dbg(BATADV_DBG_NC, bat_priv,
1781                           "No decoding packet found for %u\n", packet_id);
1782
1783        return nc_packet;
1784}
1785
1786/**
1787 * batadv_nc_recv_coded_packet() - try to decode coded packet and enqueue the
1788 *  resulting unicast packet
1789 * @skb: incoming coded packet
1790 * @recv_if: pointer to interface this packet was received on
1791 *
1792 * Return: NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
1793 * otherwise.
1794 */
1795static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
1796                                       struct batadv_hard_iface *recv_if)
1797{
1798        struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1799        struct batadv_unicast_packet *unicast_packet;
1800        struct batadv_coded_packet *coded_packet;
1801        struct batadv_nc_packet *nc_packet;
1802        struct ethhdr *ethhdr;
1803        int hdr_size = sizeof(*coded_packet);
1804
1805        /* Check if network coding is enabled */
1806        if (!atomic_read(&bat_priv->network_coding))
1807                goto free_skb;
1808
1809        /* Make sure we can access (and remove) header */
1810        if (unlikely(!pskb_may_pull(skb, hdr_size)))
1811                goto free_skb;
1812
1813        coded_packet = (struct batadv_coded_packet *)skb->data;
1814        ethhdr = eth_hdr(skb);
1815
1816        /* Verify frame is destined for us */
1817        if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest) &&
1818            !batadv_is_my_mac(bat_priv, coded_packet->second_dest))
1819                goto free_skb;
1820
1821        /* Update stat counter */
1822        if (batadv_is_my_mac(bat_priv, coded_packet->second_dest))
1823                batadv_inc_counter(bat_priv, BATADV_CNT_NC_SNIFFED);
1824
1825        nc_packet = batadv_nc_find_decoding_packet(bat_priv, ethhdr,
1826                                                   coded_packet);
1827        if (!nc_packet) {
1828                batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
1829                goto free_skb;
1830        }
1831
1832        /* Make skb's linear, because decoding accesses the entire buffer */
1833        if (skb_linearize(skb) < 0)
1834                goto free_nc_packet;
1835
1836        if (skb_linearize(nc_packet->skb) < 0)
1837                goto free_nc_packet;
1838
1839        /* Decode the packet */
1840        unicast_packet = batadv_nc_skb_decode_packet(bat_priv, skb, nc_packet);
1841        if (!unicast_packet) {
1842                batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
1843                goto free_nc_packet;
1844        }
1845
1846        /* Mark packet as decoded to do correct recoding when forwarding */
1847        BATADV_SKB_CB(skb)->decoded = true;
1848        batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE);
1849        batadv_add_counter(bat_priv, BATADV_CNT_NC_DECODE_BYTES,
1850                           skb->len + ETH_HLEN);
1851        return batadv_recv_unicast_packet(skb, recv_if);
1852
1853free_nc_packet:
1854        batadv_nc_packet_free(nc_packet, true);
1855free_skb:
1856        kfree_skb(skb);
1857
1858        return NET_RX_DROP;
1859}
1860
1861/**
1862 * batadv_nc_mesh_free() - clean up network coding memory
1863 * @bat_priv: the bat priv with all the soft interface information
1864 */
1865void batadv_nc_mesh_free(struct batadv_priv *bat_priv)
1866{
1867        batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_NC, 1);
1868        batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_NC, 1);
1869        cancel_delayed_work_sync(&bat_priv->nc.work);
1870
1871        batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
1872        batadv_hash_destroy(bat_priv->nc.coding_hash);
1873        batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash, NULL);
1874        batadv_hash_destroy(bat_priv->nc.decoding_hash);
1875}
1876