net/batman-adv/distributed-arp-table.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) B.A.T.M.A.N. contributors:
   3  *
   4  * Antonio Quartulli
   5  */
   6
   7 #include "distributed-arp-table.h"
   8 #include "main.h"
   9
  10 #include <asm/unaligned.h>
  11 #include <linux/atomic.h>
  12 #include <linux/bitops.h>
  13 #include <linux/byteorder/generic.h>
  14 #include <linux/errno.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/gfp.h>
  17 #include <linux/if_arp.h>
  18 #include <linux/if_ether.h>
  19 #include <linux/if_vlan.h>
  20 #include <linux/in.h>
  21 #include <linux/ip.h>
  22 #include <linux/jiffies.h>
  23 #include <linux/kernel.h>
  24 #include <linux/kref.h>
  25 #include <linux/list.h>
  26 #include <linux/netlink.h>
  27 #include <linux/rculist.h>
  28 #include <linux/rcupdate.h>
  29 #include <linux/skbuff.h>
  30 #include <linux/slab.h>
  31 #include <linux/spinlock.h>
  32 #include <linux/stddef.h>
  33 #include <linux/string.h>
  34 #include <linux/udp.h>
  35 #include <linux/workqueue.h>
  36 #include <net/arp.h>
  37 #include <net/genetlink.h>
  38 #include <net/netlink.h>
  39 #include <net/sock.h>
  40 #include <uapi/linux/batman_adv.h>
  41
  42 #include "bridge_loop_avoidance.h"
  43 #include "hard-interface.h"
  44 #include "hash.h"
  45 #include "log.h"
  46 #include "netlink.h"
  47 #include "originator.h"
  48 #include "send.h"
  49 #include "soft-interface.h"
  50 #include "translation-table.h"
  51 #include "tvlv.h"
  52
  53 enum batadv_bootpop {
  54         BATADV_BOOTREPLY        = 2,
  55 };
  56
  57 enum batadv_boothtype {
  58         BATADV_HTYPE_ETHERNET   = 1,
  59 };
  60
  61 enum batadv_dhcpoptioncode {
  62         BATADV_DHCP_OPT_PAD             = 0,
  63         BATADV_DHCP_OPT_MSG_TYPE        = 53,
  64         BATADV_DHCP_OPT_END             = 255,
  65 };
  66
  67 enum batadv_dhcptype {
  68         BATADV_DHCPACK          = 5,
  69 };
  70
  71 /* { 99, 130, 83, 99 } */
  72 #define BATADV_DHCP_MAGIC 1669485411
  73
  74 struct batadv_dhcp_packet {
  75         __u8 op;
  76         __u8 htype;
  77         __u8 hlen;
  78         __u8 hops;
  79         __be32 xid;
  80         __be16 secs;
  81         __be16 flags;
  82         __be32 ciaddr;
  83         __be32 yiaddr;
  84         __be32 siaddr;
  85         __be32 giaddr;
  86         __u8 chaddr[16];
  87         __u8 sname[64];
  88         __u8 file[128];
  89         __be32 magic;
  90         /* __u8 options[]; */
  91 };
  92
  93 #define BATADV_DHCP_YIADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->yiaddr)
  94 #define BATADV_DHCP_CHADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->chaddr)
  95
  96 static void batadv_dat_purge(struct work_struct *work);
  97
  98 /**
  99  * batadv_dat_start_timer() - initialise the DAT periodic worker
 100  * @bat_priv: the bat priv with all the soft interface information
 101  */
 102 static void batadv_dat_start_timer(struct batadv_priv *bat_priv)
 103 {
 104         INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge);
 105         queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work,
 106                            msecs_to_jiffies(10000));
 107 }
 108
 109 /**
 110  * batadv_dat_entry_release() - release dat_entry from lists and queue for free
 111  *  after rcu grace period
 112  * @ref: kref pointer of the dat_entry
 113  */
 114 static void batadv_dat_entry_release(struct kref *ref)
 115 {
 116         struct batadv_dat_entry *dat_entry;
 117
 118         dat_entry = container_of(ref, struct batadv_dat_entry, refcount);
 119
 120         kfree_rcu(dat_entry, rcu);
 121 }
 122
 123 /**
 124  * batadv_dat_entry_put() - decrement the dat_entry refcounter and possibly
 125  *  release it
 126  * @dat_entry: dat_entry to be free'd
 127  */
 128 static void batadv_dat_entry_put(struct batadv_dat_entry *dat_entry)
 129 {
 130         if (!dat_entry)
 131                 return;
 132
 133         kref_put(&dat_entry->refcount, batadv_dat_entry_release);
 134 }
 135
 136 /**
 137  * batadv_dat_to_purge() - check whether a dat_entry has to be purged or not
 138  * @dat_entry: the entry to check
 139  *
 140  * Return: true if the entry has to be purged now, false otherwise.
 141  */
 142 static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry)
 143 {
 144         return batadv_has_timed_out(dat_entry->last_update,
 145                                     BATADV_DAT_ENTRY_TIMEOUT);
 146 }
 147
 148 /**
 149  * __batadv_dat_purge() - delete entries from the DAT local storage
 150  * @bat_priv: the bat priv with all the soft interface information
 151  * @to_purge: function in charge to decide whether an entry has to be purged or
 152  *            not. This function takes the dat_entry as argument and has to
 153  *            returns a boolean value: true is the entry has to be deleted,
 154  *            false otherwise
 155  *
 156  * Loops over each entry in the DAT local storage and deletes it if and only if
 157  * the to_purge function passed as argument returns true.
 158  */
 159 static void __batadv_dat_purge(struct batadv_priv *bat_priv,
 160                                bool (*to_purge)(struct batadv_dat_entry *))
 161 {
 162         spinlock_t *list_lock; /* protects write access to the hash lists */
 163         struct batadv_dat_entry *dat_entry;
 164         struct hlist_node *node_tmp;
 165         struct hlist_head *head;
 166         u32 i;
 167
 168         if (!bat_priv->dat.hash)
 169                 return;
 170
 171         for (i = 0; i < bat_priv->dat.hash->size; i++) {
 172                 head = &bat_priv->dat.hash->table[i];
 173                 list_lock = &bat_priv->dat.hash->list_locks[i];
 174
 175                 spin_lock_bh(list_lock);
 176                 hlist_for_each_entry_safe(dat_entry, node_tmp, head,
 177                                           hash_entry) {
 178                         /* if a helper function has been passed as parameter,
 179                          * ask it if the entry has to be purged or not
 180                          */
 181                         if (to_purge && !to_purge(dat_entry))
 182                                 continue;
 183
 184                         hlist_del_rcu(&dat_entry->hash_entry);
 185                         batadv_dat_entry_put(dat_entry);
 186                 }
 187                 spin_unlock_bh(list_lock);
 188         }
 189 }
 190
 191 /**
 192  * batadv_dat_purge() - periodic task that deletes old entries from the local
 193  *  DAT hash table
 194  * @work: kernel work struct
 195  */
 196 static void batadv_dat_purge(struct work_struct *work)
 197 {
 198         struct delayed_work *delayed_work;
 199         struct batadv_priv_dat *priv_dat;
 200         struct batadv_priv *bat_priv;
 201
 202         delayed_work = to_delayed_work(work);
 203         priv_dat = container_of(delayed_work, struct batadv_priv_dat, work);
 204         bat_priv = container_of(priv_dat, struct batadv_priv, dat);
 205
 206         __batadv_dat_purge(bat_priv, batadv_dat_to_purge);
 207         batadv_dat_start_timer(bat_priv);
 208 }
 209
 210 /**
 211  * batadv_compare_dat() - comparing function used in the local DAT hash table
 212  * @node: node in the local table
 213  * @data2: second object to compare the node to
 214  *
 215  * Return: true if the two entries are the same, false otherwise.
 216  */
 217 static bool batadv_compare_dat(const struct hlist_node *node, const void *data2)
 218 {
 219         const void *data1 = container_of(node, struct batadv_dat_entry,
 220                                          hash_entry);
 221
 222         return memcmp(data1, data2, sizeof(__be32)) == 0;
 223 }
 224
 225 /**
 226  * batadv_arp_hw_src() - extract the hw_src field from an ARP packet
 227  * @skb: ARP packet
 228  * @hdr_size: size of the possible header before the ARP packet
 229  *
 230  * Return: the value of the hw_src field in the ARP packet.
 231  */
 232 static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)
 233 {
 234         u8 *addr;
 235
 236         addr = (u8 *)(skb->data + hdr_size);
 237         addr += ETH_HLEN + sizeof(struct arphdr);
 238
 239         return addr;
 240 }
 241
 242 /**
 243  * batadv_arp_ip_src() - extract the ip_src field from an ARP packet
 244  * @skb: ARP packet
 245  * @hdr_size: size of the possible header before the ARP packet
 246  *
 247  * Return: the value of the ip_src field in the ARP packet.
 248  */
 249 static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
 250 {
 251         return *(__force __be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
 252 }
 253
 254 /**
 255  * batadv_arp_hw_dst() - extract the hw_dst field from an ARP packet
 256  * @skb: ARP packet
 257  * @hdr_size: size of the possible header before the ARP packet
 258  *
 259  * Return: the value of the hw_dst field in the ARP packet.
 260  */
 261 static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)
 262 {
 263         return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4;
 264 }
 265
 266 /**
 267  * batadv_arp_ip_dst() - extract the ip_dst field from an ARP packet
 268  * @skb: ARP packet
 269  * @hdr_size: size of the possible header before the ARP packet
 270  *
 271  * Return: the value of the ip_dst field in the ARP packet.
 272  */
 273 static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
 274 {
 275         u8 *dst = batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4;
 276
 277         return *(__force __be32 *)dst;
 278 }
 279
 280 /**
 281  * batadv_hash_dat() - compute the hash value for an IP address
 282  * @data: data to hash
 283  * @size: size of the hash table
 284  *
 285  * Return: the selected index in the hash table for the given data.
 286  */
 287 static u32 batadv_hash_dat(const void *data, u32 size)
 288 {
 289         u32 hash = 0;
 290         const struct batadv_dat_entry *dat = data;
 291         const unsigned char *key;
 292         __be16 vid;
 293         u32 i;
 294
 295         key = (__force const unsigned char *)&dat->ip;
 296         for (i = 0; i < sizeof(dat->ip); i++) {
 297                 hash += key[i];
 298                 hash += (hash << 10);
 299                 hash ^= (hash >> 6);
 300         }
 301
 302         vid = htons(dat->vid);
 303         key = (__force const unsigned char *)&vid;
 304         for (i = 0; i < sizeof(dat->vid); i++) {
 305                 hash += key[i];
 306                 hash += (hash << 10);
 307                 hash ^= (hash >> 6);
 308         }
 309
 310         hash += (hash << 3);
 311         hash ^= (hash >> 11);
 312         hash += (hash << 15);
 313
 314         return hash % size;
 315 }
 316
 317 /**
 318  * batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash
 319  * table
 320  * @bat_priv: the bat priv with all the soft interface information
 321  * @ip: search key
 322  * @vid: VLAN identifier
 323  *
 324  * Return: the dat_entry if found, NULL otherwise.
 325  */
 326 static struct batadv_dat_entry *
 327 batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip,
 328                            unsigned short vid)
 329 {
 330         struct hlist_head *head;
 331         struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL;
 332         struct batadv_hashtable *hash = bat_priv->dat.hash;
 333         u32 index;
 334
 335         if (!hash)
 336                 return NULL;
 337
 338         to_find.ip = ip;
 339         to_find.vid = vid;
 340
 341         index = batadv_hash_dat(&to_find, hash->size);
 342         head = &hash->table[index];
 343
 344         rcu_read_lock();
 345         hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
 346                 if (dat_entry->ip != ip)
 347                         continue;
 348
 349                 if (!kref_get_unless_zero(&dat_entry->refcount))
 350                         continue;
 351
 352                 dat_entry_tmp = dat_entry;
 353                 break;
 354         }
 355         rcu_read_unlock();
 356
 357         return dat_entry_tmp;
 358 }
 359
 360 /**
 361  * batadv_dat_entry_add() - add a new dat entry or update it if already exists
 362  * @bat_priv: the bat priv with all the soft interface information
 363  * @ip: ipv4 to add/edit
 364  * @mac_addr: mac address to assign to the given ipv4
 365  * @vid: VLAN identifier
 366  */
 367 static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
 368                                  u8 *mac_addr, unsigned short vid)
 369 {
 370         struct batadv_dat_entry *dat_entry;
 371         int hash_added;
 372
 373         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid);
 374         /* if this entry is already known, just update it */
 375         if (dat_entry) {
 376                 if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr))
 377                         ether_addr_copy(dat_entry->mac_addr, mac_addr);
 378                 dat_entry->last_update = jiffies;
 379                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 380                            "Entry updated: %pI4 %pM (vid: %d)\n",
 381                            &dat_entry->ip, dat_entry->mac_addr,
 382                            batadv_print_vid(vid));
 383                 goto out;
 384         }
 385
 386         dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC);
 387         if (!dat_entry)
 388                 goto out;
 389
 390         dat_entry->ip = ip;
 391         dat_entry->vid = vid;
 392         ether_addr_copy(dat_entry->mac_addr, mac_addr);
 393         dat_entry->last_update = jiffies;
 394         kref_init(&dat_entry->refcount);
 395
 396         kref_get(&dat_entry->refcount);
 397         hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat,
 398                                      batadv_hash_dat, dat_entry,
 399                                      &dat_entry->hash_entry);
 400
 401         if (unlikely(hash_added != 0)) {
 402                 /* remove the reference for the hash */
 403                 batadv_dat_entry_put(dat_entry);
 404                 goto out;
 405         }
 406
 407         batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n",
 408                    &dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid));
 409
 410 out:
 411         batadv_dat_entry_put(dat_entry);
 412 }
 413
 414 #ifdef CONFIG_BATMAN_ADV_DEBUG
 415
 416 /**
 417  * batadv_dbg_arp() - print a debug message containing all the ARP packet
 418  *  details
 419  * @bat_priv: the bat priv with all the soft interface information
 420  * @skb: ARP packet
 421  * @hdr_size: size of the possible header before the ARP packet
 422  * @msg: message to print together with the debugging information
 423  */
 424 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
 425                            int hdr_size, char *msg)
 426 {
 427         struct batadv_unicast_4addr_packet *unicast_4addr_packet;
 428         struct batadv_bcast_packet *bcast_pkt;
 429         u8 *orig_addr;
 430         __be32 ip_src, ip_dst;
 431
 432         if (msg)
 433                 batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
 434
 435         ip_src = batadv_arp_ip_src(skb, hdr_size);
 436         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 437         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 438                    "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
 439                    batadv_arp_hw_src(skb, hdr_size), &ip_src,
 440                    batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
 441
 442         if (hdr_size < sizeof(struct batadv_unicast_packet))
 443                 return;
 444
 445         unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
 446
 447         switch (unicast_4addr_packet->u.packet_type) {
 448         case BATADV_UNICAST:
 449                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 450                            "* encapsulated within a UNICAST packet\n");
 451                 break;
 452         case BATADV_UNICAST_4ADDR:
 453                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 454                            "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
 455                            unicast_4addr_packet->src);
 456                 switch (unicast_4addr_packet->subtype) {
 457                 case BATADV_P_DAT_DHT_PUT:
 458                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
 459                         break;
 460                 case BATADV_P_DAT_DHT_GET:
 461                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
 462                         break;
 463                 case BATADV_P_DAT_CACHE_REPLY:
 464                         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 465                                    "* type: DAT_CACHE_REPLY\n");
 466                         break;
 467                 case BATADV_P_DATA:
 468                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n");
 469                         break;
 470                 default:
 471                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n",
 472                                    unicast_4addr_packet->u.packet_type);
 473                 }
 474                 break;
 475         case BATADV_BCAST:
 476                 bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet;
 477                 orig_addr = bcast_pkt->orig;
 478                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 479                            "* encapsulated within a BCAST packet (src: %pM)\n",
 480                            orig_addr);
 481                 break;
 482         default:
 483                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 484                            "* encapsulated within an unknown packet type (0x%x)\n",
 485                            unicast_4addr_packet->u.packet_type);
 486         }
 487 }
 488
 489 #else
 490
 491 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
 492                            int hdr_size, char *msg)
 493 {
 494 }
 495
 496 #endif /* CONFIG_BATMAN_ADV_DEBUG */
 497
 498 /**
 499  * batadv_is_orig_node_eligible() - check whether a node can be a DHT candidate
 500  * @res: the array with the already selected candidates
 501  * @select: number of already selected candidates
 502  * @tmp_max: address of the currently evaluated node
 503  * @max: current round max address
 504  * @last_max: address of the last selected candidate
 505  * @candidate: orig_node under evaluation
 506  * @max_orig_node: last selected candidate
 507  *
 508  * Return: true if the node has been elected as next candidate or false
 509  * otherwise.
 510  */
 511 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res,
 512                                          int select, batadv_dat_addr_t tmp_max,
 513                                          batadv_dat_addr_t max,
 514                                          batadv_dat_addr_t last_max,
 515                                          struct batadv_orig_node *candidate,
 516                                          struct batadv_orig_node *max_orig_node)
 517 {
 518         bool ret = false;
 519         int j;
 520
 521         /* check if orig node candidate is running DAT */
 522         if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities))
 523                 goto out;
 524
 525         /* Check if this node has already been selected... */
 526         for (j = 0; j < select; j++)
 527                 if (res[j].orig_node == candidate)
 528                         break;
 529         /* ..and possibly skip it */
 530         if (j < select)
 531                 goto out;
 532         /* sanity check: has it already been selected? This should not happen */
 533         if (tmp_max > last_max)
 534                 goto out;
 535         /* check if during this iteration an originator with a closer dht
 536          * address has already been found
 537          */
 538         if (tmp_max < max)
 539                 goto out;
 540         /* this is an hash collision with the temporary selected node. Choose
 541          * the one with the lowest address
 542          */
 543         if (tmp_max == max && max_orig_node &&
 544             batadv_compare_eth(candidate->orig, max_orig_node->orig))
 545                 goto out;
 546
 547         ret = true;
 548 out:
 549         return ret;
 550 }
 551
 552 /**
 553  * batadv_choose_next_candidate() - select the next DHT candidate
 554  * @bat_priv: the bat priv with all the soft interface information
 555  * @cands: candidates array
 556  * @select: number of candidates already present in the array
 557  * @ip_key: key to look up in the DHT
 558  * @last_max: pointer where the address of the selected candidate will be saved
 559  */
 560 static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
 561                                          struct batadv_dat_candidate *cands,
 562                                          int select, batadv_dat_addr_t ip_key,
 563                                          batadv_dat_addr_t *last_max)
 564 {
 565         batadv_dat_addr_t max = 0;
 566         batadv_dat_addr_t tmp_max = 0;
 567         struct batadv_orig_node *orig_node, *max_orig_node = NULL;
 568         struct batadv_hashtable *hash = bat_priv->orig_hash;
 569         struct hlist_head *head;
 570         int i;
 571
 572         /* if no node is eligible as candidate, leave the candidate type as
 573          * NOT_FOUND
 574          */
 575         cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
 576
 577         /* iterate over the originator list and find the node with the closest
 578          * dat_address which has not been selected yet
 579          */
 580         for (i = 0; i < hash->size; i++) {
 581                 head = &hash->table[i];
 582
 583                 rcu_read_lock();
 584                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
 585                         /* the dht space is a ring using unsigned addresses */
 586                         tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
 587                                   ip_key;
 588
 589                         if (!batadv_is_orig_node_eligible(cands, select,
 590                                                           tmp_max, max,
 591                                                           *last_max, orig_node,
 592                                                           max_orig_node))
 593                                 continue;
 594
 595                         if (!kref_get_unless_zero(&orig_node->refcount))
 596                                 continue;
 597
 598                         max = tmp_max;
 599                         batadv_orig_node_put(max_orig_node);
 600                         max_orig_node = orig_node;
 601                 }
 602                 rcu_read_unlock();
 603         }
 604         if (max_orig_node) {
 605                 cands[select].type = BATADV_DAT_CANDIDATE_ORIG;
 606                 cands[select].orig_node = max_orig_node;
 607                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 608                            "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
 609                            select, max_orig_node->orig, max_orig_node->dat_addr,
 610                            max);
 611         }
 612         *last_max = max;
 613 }
 614
 615 /**
 616  * batadv_dat_select_candidates() - select the nodes which the DHT message has
 617  *  to be sent to
 618  * @bat_priv: the bat priv with all the soft interface information
 619  * @ip_dst: ipv4 to look up in the DHT
 620  * @vid: VLAN identifier
 621  *
 622  * An originator O is selected if and only if its DHT_ID value is one of three
 623  * closest values (from the LEFT, with wrap around if needed) then the hash
 624  * value of the key. ip_dst is the key.
 625  *
 626  * Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM.
 627  */
 628 static struct batadv_dat_candidate *
 629 batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst,
 630                              unsigned short vid)
 631 {
 632         int select;
 633         batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key;
 634         struct batadv_dat_candidate *res;
 635         struct batadv_dat_entry dat;
 636
 637         if (!bat_priv->orig_hash)
 638                 return NULL;
 639
 640         res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res),
 641                             GFP_ATOMIC);
 642         if (!res)
 643                 return NULL;
 644
 645         dat.ip = ip_dst;
 646         dat.vid = vid;
 647         ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat,
 648                                                     BATADV_DAT_ADDR_MAX);
 649
 650         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 651                    "%s(): IP=%pI4 hash(IP)=%u\n", __func__, &ip_dst,
 652                    ip_key);
 653
 654         for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
 655                 batadv_choose_next_candidate(bat_priv, res, select, ip_key,
 656                                              &last_max);
 657
 658         return res;
 659 }
 660
 661 /**
 662  * batadv_dat_forward_data() - copy and send payload to the selected candidates
 663  * @bat_priv: the bat priv with all the soft interface information
 664  * @skb: payload to send
 665  * @ip: the DHT key
 666  * @vid: VLAN identifier
 667  * @packet_subtype: unicast4addr packet subtype to use
 668  *
 669  * This function copies the skb with pskb_copy() and is sent as a unicast packet
 670  * to each of the selected candidates.
 671  *
 672  * Return: true if the packet is sent to at least one candidate, false
 673  * otherwise.
 674  */
 675 static bool batadv_dat_forward_data(struct batadv_priv *bat_priv,
 676                                     struct sk_buff *skb, __be32 ip,
 677                                     unsigned short vid, int packet_subtype)
 678 {
 679         int i;
 680         bool ret = false;
 681         int send_status;
 682         struct batadv_neigh_node *neigh_node = NULL;
 683         struct sk_buff *tmp_skb;
 684         struct batadv_dat_candidate *cand;
 685
 686         cand = batadv_dat_select_candidates(bat_priv, ip, vid);
 687         if (!cand)
 688                 goto out;
 689
 690         batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
 691
 692         for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
 693                 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
 694                         continue;
 695
 696                 neigh_node = batadv_orig_router_get(cand[i].orig_node,
 697                                                     BATADV_IF_DEFAULT);
 698                 if (!neigh_node)
 699                         goto free_orig;
 700
 701                 tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
 702                 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
 703                                                            cand[i].orig_node,
 704                                                            packet_subtype)) {
 705                         kfree_skb(tmp_skb);
 706                         goto free_neigh;
 707                 }
 708
 709                 send_status = batadv_send_unicast_skb(tmp_skb, neigh_node);
 710                 if (send_status == NET_XMIT_SUCCESS) {
 711                         /* count the sent packet */
 712                         switch (packet_subtype) {
 713                         case BATADV_P_DAT_DHT_GET:
 714                                 batadv_inc_counter(bat_priv,
 715                                                    BATADV_CNT_DAT_GET_TX);
 716                                 break;
 717                         case BATADV_P_DAT_DHT_PUT:
 718                                 batadv_inc_counter(bat_priv,
 719                                                    BATADV_CNT_DAT_PUT_TX);
 720                                 break;
 721                         }
 722
 723                         /* packet sent to a candidate: return true */
 724                         ret = true;
 725                 }
 726 free_neigh:
 727                 batadv_neigh_node_put(neigh_node);
 728 free_orig:
 729                 batadv_orig_node_put(cand[i].orig_node);
 730         }
 731
 732 out:
 733         kfree(cand);
 734         return ret;
 735 }
 736
 737 /**
 738  * batadv_dat_tvlv_container_update() - update the dat tvlv container after dat
 739  *  setting change
 740  * @bat_priv: the bat priv with all the soft interface information
 741  */
 742 static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
 743 {
 744         char dat_mode;
 745
 746         dat_mode = atomic_read(&bat_priv->distributed_arp_table);
 747
 748         switch (dat_mode) {
 749         case 0:
 750                 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 751                 break;
 752         case 1:
 753                 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
 754                                                NULL, 0);
 755                 break;
 756         }
 757 }
 758
 759 /**
 760  * batadv_dat_status_update() - update the dat tvlv container after dat
 761  *  setting change
 762  * @net_dev: the soft interface net device
 763  */
 764 void batadv_dat_status_update(struct net_device *net_dev)
 765 {
 766         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 767
 768         batadv_dat_tvlv_container_update(bat_priv);
 769 }
 770
 771 /**
 772  * batadv_dat_tvlv_ogm_handler_v1() - process incoming dat tvlv container
 773  * @bat_priv: the bat priv with all the soft interface information
 774  * @orig: the orig_node of the ogm
 775  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
 776  * @tvlv_value: tvlv buffer containing the gateway data
 777  * @tvlv_value_len: tvlv buffer length
 778  */
 779 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
 780                                            struct batadv_orig_node *orig,
 781                                            u8 flags,
 782                                            void *tvlv_value, u16 tvlv_value_len)
 783 {
 784         if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
 785                 clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
 786         else
 787                 set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities);
 788 }
 789
 790 /**
 791  * batadv_dat_hash_free() - free the local DAT hash table
 792  * @bat_priv: the bat priv with all the soft interface information
 793  */
 794 static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
 795 {
 796         if (!bat_priv->dat.hash)
 797                 return;
 798
 799         __batadv_dat_purge(bat_priv, NULL);
 800
 801         batadv_hash_destroy(bat_priv->dat.hash);
 802
 803         bat_priv->dat.hash = NULL;
 804 }
 805
 806 /**
 807  * batadv_dat_init() - initialise the DAT internals
 808  * @bat_priv: the bat priv with all the soft interface information
 809  *
 810  * Return: 0 in case of success, a negative error code otherwise
 811  */
 812 int batadv_dat_init(struct batadv_priv *bat_priv)
 813 {
 814         if (bat_priv->dat.hash)
 815                 return 0;
 816
 817         bat_priv->dat.hash = batadv_hash_new(1024);
 818
 819         if (!bat_priv->dat.hash)
 820                 return -ENOMEM;
 821
 822         batadv_dat_start_timer(bat_priv);
 823
 824         batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
 825                                      NULL, BATADV_TVLV_DAT, 1,
 826                                      BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
 827         batadv_dat_tvlv_container_update(bat_priv);
 828         return 0;
 829 }
 830
 831 /**
 832  * batadv_dat_free() - free the DAT internals
 833  * @bat_priv: the bat priv with all the soft interface information
 834  */
 835 void batadv_dat_free(struct batadv_priv *bat_priv)
 836 {
 837         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 838         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 839
 840         cancel_delayed_work_sync(&bat_priv->dat.work);
 841
 842         batadv_dat_hash_free(bat_priv);
 843 }
 844
 845 /**
 846  * batadv_dat_cache_dump_entry() - dump one entry of the DAT cache table to a
 847  *  netlink socket
 848  * @msg: buffer for the message
 849  * @portid: netlink port
 850  * @cb: Control block containing additional options
 851  * @dat_entry: entry to dump
 852  *
 853  * Return: 0 or error code.
 854  */
 855 static int
 856 batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid,
 857                             struct netlink_callback *cb,
 858                             struct batadv_dat_entry *dat_entry)
 859 {
 860         int msecs;
 861         void *hdr;
 862
 863         hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
 864                           &batadv_netlink_family, NLM_F_MULTI,
 865                           BATADV_CMD_GET_DAT_CACHE);
 866         if (!hdr)
 867                 return -ENOBUFS;
 868
 869         genl_dump_check_consistent(cb, hdr);
 870
 871         msecs = jiffies_to_msecs(jiffies - dat_entry->last_update);
 872
 873         if (nla_put_in_addr(msg, BATADV_ATTR_DAT_CACHE_IP4ADDRESS,
 874                             dat_entry->ip) ||
 875             nla_put(msg, BATADV_ATTR_DAT_CACHE_HWADDRESS, ETH_ALEN,
 876                     dat_entry->mac_addr) ||
 877             nla_put_u16(msg, BATADV_ATTR_DAT_CACHE_VID, dat_entry->vid) ||
 878             nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
 879                 genlmsg_cancel(msg, hdr);
 880                 return -EMSGSIZE;
 881         }
 882
 883         genlmsg_end(msg, hdr);
 884         return 0;
 885 }
 886
 887 /**
 888  * batadv_dat_cache_dump_bucket() - dump one bucket of the DAT cache table to
 889  *  a netlink socket
 890  * @msg: buffer for the message
 891  * @portid: netlink port
 892  * @cb: Control block containing additional options
 893  * @hash: hash to dump
 894  * @bucket: bucket index to dump
 895  * @idx_skip: How many entries to skip
 896  *
 897  * Return: 0 or error code.
 898  */
 899 static int
 900 batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid,
 901                              struct netlink_callback *cb,
 902                              struct batadv_hashtable *hash, unsigned int bucket,
 903                              int *idx_skip)
 904 {
 905         struct batadv_dat_entry *dat_entry;
 906         int idx = 0;
 907
 908         spin_lock_bh(&hash->list_locks[bucket]);
 909         cb->seq = atomic_read(&hash->generation) << 1 | 1;
 910
 911         hlist_for_each_entry(dat_entry, &hash->table[bucket], hash_entry) {
 912                 if (idx < *idx_skip)
 913                         goto skip;
 914
 915                 if (batadv_dat_cache_dump_entry(msg, portid, cb, dat_entry)) {
 916                         spin_unlock_bh(&hash->list_locks[bucket]);
 917                         *idx_skip = idx;
 918
 919                         return -EMSGSIZE;
 920                 }
 921
 922 skip:
 923                 idx++;
 924         }
 925         spin_unlock_bh(&hash->list_locks[bucket]);
 926
 927         return 0;
 928 }
 929
 930 /**
 931  * batadv_dat_cache_dump() - dump DAT cache table to a netlink socket
 932  * @msg: buffer for the message
 933  * @cb: callback structure containing arguments
 934  *
 935  * Return: message length.
 936  */
 937 int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb)
 938 {
 939         struct batadv_hard_iface *primary_if = NULL;
 940         int portid = NETLINK_CB(cb->skb).portid;
 941         struct net *net = sock_net(cb->skb->sk);
 942         struct net_device *soft_iface;
 943         struct batadv_hashtable *hash;
 944         struct batadv_priv *bat_priv;
 945         int bucket = cb->args[0];
 946         int idx = cb->args[1];
 947         int ifindex;
 948         int ret = 0;
 949
 950         ifindex = batadv_netlink_get_ifindex(cb->nlh,
 951                                              BATADV_ATTR_MESH_IFINDEX);
 952         if (!ifindex)
 953                 return -EINVAL;
 954
 955         soft_iface = dev_get_by_index(net, ifindex);
 956         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
 957                 ret = -ENODEV;
 958                 goto out;
 959         }
 960
 961         bat_priv = netdev_priv(soft_iface);
 962         hash = bat_priv->dat.hash;
 963
 964         primary_if = batadv_primary_if_get_selected(bat_priv);
 965         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
 966                 ret = -ENOENT;
 967                 goto out;
 968         }
 969
 970         while (bucket < hash->size) {
 971                 if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket,
 972                                                  &idx))
 973                         break;
 974
 975                 bucket++;
 976                 idx = 0;
 977         }
 978
 979         cb->args[0] = bucket;
 980         cb->args[1] = idx;
 981
 982         ret = msg->len;
 983
 984 out:
 985         batadv_hardif_put(primary_if);
 986
 987         dev_put(soft_iface);
 988
 989         return ret;
 990 }
 991
 992 /**
 993  * batadv_arp_get_type() - parse an ARP packet and gets the type
 994  * @bat_priv: the bat priv with all the soft interface information
 995  * @skb: packet to analyse
 996  * @hdr_size: size of the possible header before the ARP packet in the skb
 997  *
 998  * Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise.
 999  */
1000 static u16 batadv_arp_get_type(struct batadv_priv *bat_priv,
1001                                struct sk_buff *skb, int hdr_size)
1002 {
1003         struct arphdr *arphdr;
1004         struct ethhdr *ethhdr;
1005         __be32 ip_src, ip_dst;
1006         u8 *hw_src, *hw_dst;
1007         u16 type = 0;
1008
1009         /* pull the ethernet header */
1010         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
1011                 goto out;
1012
1013         ethhdr = (struct ethhdr *)(skb->data + hdr_size);
1014
1015         if (ethhdr->h_proto != htons(ETH_P_ARP))
1016                 goto out;
1017
1018         /* pull the ARP payload */
1019         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
1020                                     arp_hdr_len(skb->dev))))
1021                 goto out;
1022
1023         arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
1024
1025         /* check whether the ARP packet carries a valid IP information */
1026         if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
1027                 goto out;
1028
1029         if (arphdr->ar_pro != htons(ETH_P_IP))
1030                 goto out;
1031
1032         if (arphdr->ar_hln != ETH_ALEN)
1033                 goto out;
1034
1035         if (arphdr->ar_pln != 4)
1036                 goto out;
1037
1038         /* Check for bad reply/request. If the ARP message is not sane, DAT
1039          * will simply ignore it
1040          */
1041         ip_src = batadv_arp_ip_src(skb, hdr_size);
1042         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1043         if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
1044             ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
1045             ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
1046             ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
1047                 goto out;
1048
1049         hw_src = batadv_arp_hw_src(skb, hdr_size);
1050         if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
1051                 goto out;
1052
1053         /* don't care about the destination MAC address in ARP requests */
1054         if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
1055                 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1056                 if (is_zero_ether_addr(hw_dst) ||
1057                     is_multicast_ether_addr(hw_dst))
1058                         goto out;
1059         }
1060
1061         type = ntohs(arphdr->ar_op);
1062 out:
1063         return type;
1064 }
1065
1066 /**
1067  * batadv_dat_get_vid() - extract the VLAN identifier from skb if any
1068  * @skb: the buffer containing the packet to extract the VID from
1069  * @hdr_size: the size of the batman-adv header encapsulating the packet
1070  *
1071  * Return: If the packet embedded in the skb is vlan tagged this function
1072  * returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS
1073  * is returned.
1074  */
1075 static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
1076 {
1077         unsigned short vid;
1078
1079         vid = batadv_get_vid(skb, *hdr_size);
1080
1081         /* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
1082          * If the header contained in the packet is a VLAN one (which is longer)
1083          * hdr_size is updated so that the functions will still skip the
1084          * correct amount of bytes.
1085          */
1086         if (vid & BATADV_VLAN_HAS_TAG)
1087                 *hdr_size += VLAN_HLEN;
1088
1089         return vid;
1090 }
1091
1092 /**
1093  * batadv_dat_arp_create_reply() - create an ARP Reply
1094  * @bat_priv: the bat priv with all the soft interface information
1095  * @ip_src: ARP sender IP
1096  * @ip_dst: ARP target IP
1097  * @hw_src: Ethernet source and ARP sender MAC
1098  * @hw_dst: Ethernet destination and ARP target MAC
1099  * @vid: VLAN identifier (optional, set to zero otherwise)
1100  *
1101  * Creates an ARP Reply from the given values, optionally encapsulated in a
1102  * VLAN header.
1103  *
1104  * Return: An skb containing an ARP Reply.
1105  */
1106 static struct sk_buff *
1107 batadv_dat_arp_create_reply(struct batadv_priv *bat_priv, __be32 ip_src,
1108                             __be32 ip_dst, u8 *hw_src, u8 *hw_dst,
1109                             unsigned short vid)
1110 {
1111         struct sk_buff *skb;
1112
1113         skb = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_dst, bat_priv->soft_iface,
1114                          ip_src, hw_dst, hw_src, hw_dst);
1115         if (!skb)
1116                 return NULL;
1117
1118         skb_reset_mac_header(skb);
1119
1120         if (vid & BATADV_VLAN_HAS_TAG)
1121                 skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
1122                                       vid & VLAN_VID_MASK);
1123
1124         return skb;
1125 }
1126
1127 /**
1128  * batadv_dat_snoop_outgoing_arp_request() - snoop the ARP request and try to
1129  * answer using DAT
1130  * @bat_priv: the bat priv with all the soft interface information
1131  * @skb: packet to check
1132  *
1133  * Return: true if the message has been sent to the dht candidates, false
1134  * otherwise. In case of a positive return value the message has to be enqueued
1135  * to permit the fallback.
1136  */
1137 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
1138                                            struct sk_buff *skb)
1139 {
1140         u16 type = 0;
1141         __be32 ip_dst, ip_src;
1142         u8 *hw_src;
1143         bool ret = false;
1144         struct batadv_dat_entry *dat_entry = NULL;
1145         struct sk_buff *skb_new;
1146         struct net_device *soft_iface = bat_priv->soft_iface;
1147         int hdr_size = 0;
1148         unsigned short vid;
1149
1150         if (!atomic_read(&bat_priv->distributed_arp_table))
1151                 goto out;
1152
1153         vid = batadv_dat_get_vid(skb, &hdr_size);
1154
1155         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1156         /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
1157          * message to the selected DHT candidates
1158          */
1159         if (type != ARPOP_REQUEST)
1160                 goto out;
1161
1162         batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REQUEST");
1163
1164         ip_src = batadv_arp_ip_src(skb, hdr_size);
1165         hw_src = batadv_arp_hw_src(skb, hdr_size);
1166         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1167
1168         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1169
1170         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1171         if (dat_entry) {
1172                 /* If the ARP request is destined for a local client the local
1173                  * client will answer itself. DAT would only generate a
1174                  * duplicate packet.
1175                  *
1176                  * Moreover, if the soft-interface is enslaved into a bridge, an
1177                  * additional DAT answer may trigger kernel warnings about
1178                  * a packet coming from the wrong port.
1179                  */
1180                 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
1181                         ret = true;
1182                         goto out;
1183                 }
1184
1185                 /* If BLA is enabled, only send ARP replies if we have claimed
1186                  * the destination for the ARP request or if no one else of
1187                  * the backbone gws belonging to our backbone has claimed the
1188                  * destination.
1189                  */
1190                 if (!batadv_bla_check_claim(bat_priv,
1191                                             dat_entry->mac_addr, vid)) {
1192                         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1193                                    "Device %pM claimed by another backbone gw. Don't send ARP reply!",
1194                                    dat_entry->mac_addr);
1195                         ret = true;
1196                         goto out;
1197                 }
1198
1199                 skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
1200                                                       dat_entry->mac_addr,
1201                                                       hw_src, vid);
1202                 if (!skb_new)
1203                         goto out;
1204
1205                 skb_new->protocol = eth_type_trans(skb_new, soft_iface);
1206
1207                 batadv_inc_counter(bat_priv, BATADV_CNT_RX);
1208                 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
1209                                    skb->len + ETH_HLEN + hdr_size);
1210
1211                 netif_rx(skb_new);
1212                 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
1213                 ret = true;
1214         } else {
1215                 /* Send the request to the DHT */
1216                 ret = batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1217                                               BATADV_P_DAT_DHT_GET);
1218         }
1219 out:
1220         batadv_dat_entry_put(dat_entry);
1221         return ret;
1222 }
1223
1224 /**
1225  * batadv_dat_snoop_incoming_arp_request() - snoop the ARP request and try to
1226  * answer using the local DAT storage
1227  * @bat_priv: the bat priv with all the soft interface information
1228  * @skb: packet to check
1229  * @hdr_size: size of the encapsulation header
1230  *
1231  * Return: true if the request has been answered, false otherwise.
1232  */
1233 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
1234                                            struct sk_buff *skb, int hdr_size)
1235 {
1236         u16 type;
1237         __be32 ip_src, ip_dst;
1238         u8 *hw_src;
1239         struct sk_buff *skb_new;
1240         struct batadv_dat_entry *dat_entry = NULL;
1241         bool ret = false;
1242         unsigned short vid;
1243         int err;
1244
1245         if (!atomic_read(&bat_priv->distributed_arp_table))
1246                 goto out;
1247
1248         vid = batadv_dat_get_vid(skb, &hdr_size);
1249
1250         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1251         if (type != ARPOP_REQUEST)
1252                 goto out;
1253
1254         hw_src = batadv_arp_hw_src(skb, hdr_size);
1255         ip_src = batadv_arp_ip_src(skb, hdr_size);
1256         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1257
1258         batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST");
1259
1260         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1261
1262         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1263         if (!dat_entry)
1264                 goto out;
1265
1266         skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
1267                                               dat_entry->mac_addr, hw_src, vid);
1268         if (!skb_new)
1269                 goto out;
1270
1271         /* To preserve backwards compatibility, the node has choose the outgoing
1272          * format based on the incoming request packet type. The assumption is
1273          * that a node not using the 4addr packet format doesn't support it.
1274          */
1275         if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
1276                 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
1277                                                    BATADV_P_DAT_CACHE_REPLY,
1278                                                    NULL, vid);
1279         else
1280                 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
1281
1282         if (err != NET_XMIT_DROP) {
1283                 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
1284                 ret = true;
1285         }
1286 out:
1287         batadv_dat_entry_put(dat_entry);
1288         if (ret)
1289                 kfree_skb(skb);
1290         return ret;
1291 }
1292
1293 /**
1294  * batadv_dat_snoop_outgoing_arp_reply() - snoop the ARP reply and fill the DHT
1295  * @bat_priv: the bat priv with all the soft interface information
1296  * @skb: packet to check
1297  */
1298 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
1299                                          struct sk_buff *skb)
1300 {
1301         u16 type;
1302         __be32 ip_src, ip_dst;
1303         u8 *hw_src, *hw_dst;
1304         int hdr_size = 0;
1305         unsigned short vid;
1306
1307         if (!atomic_read(&bat_priv->distributed_arp_table))
1308                 return;
1309
1310         vid = batadv_dat_get_vid(skb, &hdr_size);
1311
1312         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1313         if (type != ARPOP_REPLY)
1314                 return;
1315
1316         batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REPLY");
1317
1318         hw_src = batadv_arp_hw_src(skb, hdr_size);
1319         ip_src = batadv_arp_ip_src(skb, hdr_size);
1320         hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1321         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1322
1323         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1324         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1325
1326         /* Send the ARP reply to the candidates for both the IP addresses that
1327          * the node obtained from the ARP reply
1328          */
1329         batadv_dat_forward_data(bat_priv, skb, ip_src, vid,
1330                                 BATADV_P_DAT_DHT_PUT);
1331         batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1332                                 BATADV_P_DAT_DHT_PUT);
1333 }
1334
1335 /**
1336  * batadv_dat_snoop_incoming_arp_reply() - snoop the ARP reply and fill the
1337  *  local DAT storage only
1338  * @bat_priv: the bat priv with all the soft interface information
1339  * @skb: packet to check
1340  * @hdr_size: size of the encapsulation header
1341  *
1342  * Return: true if the packet was snooped and consumed by DAT. False if the
1343  * packet has to be delivered to the interface
1344  */
1345 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
1346                                          struct sk_buff *skb, int hdr_size)
1347 {
1348         struct batadv_dat_entry *dat_entry = NULL;
1349         u16 type;
1350         __be32 ip_src, ip_dst;
1351         u8 *hw_src, *hw_dst;
1352         bool dropped = false;
1353         unsigned short vid;
1354
1355         if (!atomic_read(&bat_priv->distributed_arp_table))
1356                 goto out;
1357
1358         vid = batadv_dat_get_vid(skb, &hdr_size);
1359
1360         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1361         if (type != ARPOP_REPLY)
1362                 goto out;
1363
1364         batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REPLY");
1365
1366         hw_src = batadv_arp_hw_src(skb, hdr_size);
1367         ip_src = batadv_arp_ip_src(skb, hdr_size);
1368         hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1369         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1370
1371         /* If ip_dst is already in cache and has the right mac address,
1372          * drop this frame if this ARP reply is destined for us because it's
1373          * most probably an ARP reply generated by another node of the DHT.
1374          * We have most probably received already a reply earlier. Delivering
1375          * this frame would lead to doubled receive of an ARP reply.
1376          */
1377         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid);
1378         if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) {
1379                 batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n",
1380                            hw_src, &ip_src, hw_dst, &ip_dst,
1381                            dat_entry->mac_addr, &dat_entry->ip);
1382                 dropped = true;
1383         }
1384
1385         /* Update our internal cache with both the IP addresses the node got
1386          * within the ARP reply
1387          */
1388         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1389         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1390
1391         if (dropped)
1392                 goto out;
1393
1394         /* If BLA is enabled, only forward ARP replies if we have claimed the
1395          * source of the ARP reply or if no one else of the same backbone has
1396          * already claimed that client. This prevents that different gateways
1397          * to the same backbone all forward the ARP reply leading to multiple
1398          * replies in the backbone.
1399          */
1400         if (!batadv_bla_check_claim(bat_priv, hw_src, vid)) {
1401                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1402                            "Device %pM claimed by another backbone gw. Drop ARP reply.\n",
1403                            hw_src);
1404                 dropped = true;
1405                 goto out;
1406         }
1407
1408         /* if this REPLY is directed to a client of mine, let's deliver the
1409          * packet to the interface
1410          */
1411         dropped = !batadv_is_my_client(bat_priv, hw_dst, vid);
1412
1413         /* if this REPLY is sent on behalf of a client of mine, let's drop the
1414          * packet because the client will reply by itself
1415          */
1416         dropped |= batadv_is_my_client(bat_priv, hw_src, vid);
1417 out:
1418         if (dropped)
1419                 kfree_skb(skb);
1420         batadv_dat_entry_put(dat_entry);
1421         /* if dropped == false -> deliver to the interface */
1422         return dropped;
1423 }
1424
1425 /**
1426  * batadv_dat_check_dhcp_ipudp() - check skb for IP+UDP headers valid for DHCP
1427  * @skb: the packet to check
1428  * @ip_src: a buffer to store the IPv4 source address in
1429  *
1430  * Checks whether the given skb has an IP and UDP header valid for a DHCP
1431  * message from a DHCP server. And if so, stores the IPv4 source address in
1432  * the provided buffer.
1433  *
1434  * Return: True if valid, false otherwise.
1435  */
1436 static bool
1437 batadv_dat_check_dhcp_ipudp(struct sk_buff *skb, __be32 *ip_src)
1438 {
1439         unsigned int offset = skb_network_offset(skb);
1440         struct udphdr *udphdr, _udphdr;
1441         struct iphdr *iphdr, _iphdr;
1442
1443         iphdr = skb_header_pointer(skb, offset, sizeof(_iphdr), &_iphdr);
1444         if (!iphdr || iphdr->version != 4 || iphdr->ihl * 4 < sizeof(_iphdr))
1445                 return false;
1446
1447         if (iphdr->protocol != IPPROTO_UDP)
1448                 return false;
1449
1450         offset += iphdr->ihl * 4;
1451         skb_set_transport_header(skb, offset);
1452
1453         udphdr = skb_header_pointer(skb, offset, sizeof(_udphdr), &_udphdr);
1454         if (!udphdr || udphdr->source != htons(67))
1455                 return false;
1456
1457         *ip_src = get_unaligned(&iphdr->saddr);
1458
1459         return true;
1460 }
1461
1462 /**
1463  * batadv_dat_check_dhcp() - examine packet for valid DHCP message
1464  * @skb: the packet to check
1465  * @proto: ethernet protocol hint (behind a potential vlan)
1466  * @ip_src: a buffer to store the IPv4 source address in
1467  *
1468  * Checks whether the given skb is a valid DHCP packet. And if so, stores the
1469  * IPv4 source address in the provided buffer.
1470  *
1471  * Caller needs to ensure that the skb network header is set correctly.
1472  *
1473  * Return: If skb is a valid DHCP packet, then returns its op code
1474  * (e.g. BOOTREPLY vs. BOOTREQUEST). Otherwise returns -EINVAL.
1475  */
1476 static int
1477 batadv_dat_check_dhcp(struct sk_buff *skb, __be16 proto, __be32 *ip_src)
1478 {
1479         __be32 *magic, _magic;
1480         unsigned int offset;
1481         struct {
1482                 __u8 op;
1483                 __u8 htype;
1484                 __u8 hlen;
1485                 __u8 hops;
1486         } *dhcp_h, _dhcp_h;
1487
1488         if (proto != htons(ETH_P_IP))
1489                 return -EINVAL;
1490
1491         if (!batadv_dat_check_dhcp_ipudp(skb, ip_src))
1492                 return -EINVAL;
1493
1494         offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1495         if (skb->len < offset + sizeof(struct batadv_dhcp_packet))
1496                 return -EINVAL;
1497
1498         dhcp_h = skb_header_pointer(skb, offset, sizeof(_dhcp_h), &_dhcp_h);
1499         if (!dhcp_h || dhcp_h->htype != BATADV_HTYPE_ETHERNET ||
1500             dhcp_h->hlen != ETH_ALEN)
1501                 return -EINVAL;
1502
1503         offset += offsetof(struct batadv_dhcp_packet, magic);
1504
1505         magic = skb_header_pointer(skb, offset, sizeof(_magic), &_magic);
1506         if (!magic || get_unaligned(magic) != htonl(BATADV_DHCP_MAGIC))
1507                 return -EINVAL;
1508
1509         return dhcp_h->op;
1510 }
1511
1512 /**
1513  * batadv_dat_get_dhcp_message_type() - get message type of a DHCP packet
1514  * @skb: the DHCP packet to parse
1515  *
1516  * Iterates over the DHCP options of the given DHCP packet to find a
1517  * DHCP Message Type option and parse it.
1518  *
1519  * Caller needs to ensure that the given skb is a valid DHCP packet and
1520  * that the skb transport header is set correctly.
1521  *
1522  * Return: The found DHCP message type value, if found. -EINVAL otherwise.
1523  */
1524 static int batadv_dat_get_dhcp_message_type(struct sk_buff *skb)
1525 {
1526         unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1527         u8 *type, _type;
1528         struct {
1529                 u8 type;
1530                 u8 len;
1531         } *tl, _tl;
1532
1533         offset += sizeof(struct batadv_dhcp_packet);
1534
1535         while ((tl = skb_header_pointer(skb, offset, sizeof(_tl), &_tl))) {
1536                 if (tl->type == BATADV_DHCP_OPT_MSG_TYPE)
1537                         break;
1538
1539                 if (tl->type == BATADV_DHCP_OPT_END)
1540                         break;
1541
1542                 if (tl->type == BATADV_DHCP_OPT_PAD)
1543                         offset++;
1544                 else
1545                         offset += tl->len + sizeof(_tl);
1546         }
1547
1548         /* Option Overload Code not supported */
1549         if (!tl || tl->type != BATADV_DHCP_OPT_MSG_TYPE ||
1550             tl->len != sizeof(_type))
1551                 return -EINVAL;
1552
1553         offset += sizeof(_tl);
1554
1555         type = skb_header_pointer(skb, offset, sizeof(_type), &_type);
1556         if (!type)
1557                 return -EINVAL;
1558
1559         return *type;
1560 }
1561
1562 /**
1563  * batadv_dat_dhcp_get_yiaddr() - get yiaddr from a DHCP packet
1564  * @skb: the DHCP packet to parse
1565  * @buf: a buffer to store the yiaddr in
1566  *
1567  * Caller needs to ensure that the given skb is a valid DHCP packet and
1568  * that the skb transport header is set correctly.
1569  *
1570  * Return: True on success, false otherwise.
1571  */
1572 static bool batadv_dat_dhcp_get_yiaddr(struct sk_buff *skb, __be32 *buf)
1573 {
1574         unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1575         __be32 *yiaddr;
1576
1577         offset += offsetof(struct batadv_dhcp_packet, yiaddr);
1578         yiaddr = skb_header_pointer(skb, offset, BATADV_DHCP_YIADDR_LEN, buf);
1579
1580         if (!yiaddr)
1581                 return false;
1582
1583         if (yiaddr != buf)
1584                 *buf = get_unaligned(yiaddr);
1585
1586         return true;
1587 }
1588
1589 /**
1590  * batadv_dat_get_dhcp_chaddr() - get chaddr from a DHCP packet
1591  * @skb: the DHCP packet to parse
1592  * @buf: a buffer to store the chaddr in
1593  *
1594  * Caller needs to ensure that the given skb is a valid DHCP packet and
1595  * that the skb transport header is set correctly.
1596  *
1597  * Return: True on success, false otherwise
1598  */
1599 static bool batadv_dat_get_dhcp_chaddr(struct sk_buff *skb, u8 *buf)
1600 {
1601         unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr);
1602         u8 *chaddr;
1603
1604         offset += offsetof(struct batadv_dhcp_packet, chaddr);
1605         chaddr = skb_header_pointer(skb, offset, BATADV_DHCP_CHADDR_LEN, buf);
1606
1607         if (!chaddr)
1608                 return false;
1609
1610         if (chaddr != buf)
1611                 memcpy(buf, chaddr, BATADV_DHCP_CHADDR_LEN);
1612
1613         return true;
1614 }
1615
1616 /**
1617  * batadv_dat_put_dhcp() - puts addresses from a DHCP packet into the DHT and
1618  *  DAT cache
1619  * @bat_priv: the bat priv with all the soft interface information
1620  * @chaddr: the DHCP client MAC address
1621  * @yiaddr: the DHCP client IP address
1622  * @hw_dst: the DHCP server MAC address
1623  * @ip_dst: the DHCP server IP address
1624  * @vid: VLAN identifier
1625  *
1626  * Adds given MAC/IP pairs to the local DAT cache and propagates them further
1627  * into the DHT.
1628  *
1629  * For the DHT propagation, client MAC + IP will appear as the ARP Reply
1630  * transmitter (and hw_dst/ip_dst as the target).
1631  */
1632 static void batadv_dat_put_dhcp(struct batadv_priv *bat_priv, u8 *chaddr,
1633                                 __be32 yiaddr, u8 *hw_dst, __be32 ip_dst,
1634                                 unsigned short vid)
1635 {
1636         struct sk_buff *skb;
1637
1638         skb = batadv_dat_arp_create_reply(bat_priv, yiaddr, ip_dst, chaddr,
1639                                           hw_dst, vid);
1640         if (!skb)
1641                 return;
1642
1643         skb_set_network_header(skb, ETH_HLEN);
1644
1645         batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid);
1646         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1647
1648         batadv_dat_forward_data(bat_priv, skb, yiaddr, vid,
1649                                 BATADV_P_DAT_DHT_PUT);
1650         batadv_dat_forward_data(bat_priv, skb, ip_dst, vid,
1651                                 BATADV_P_DAT_DHT_PUT);
1652
1653         consume_skb(skb);
1654
1655         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1656                    "Snooped from outgoing DHCPACK (server address): %pI4, %pM (vid: %i)\n",
1657                    &ip_dst, hw_dst, batadv_print_vid(vid));
1658         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1659                    "Snooped from outgoing DHCPACK (client address): %pI4, %pM (vid: %i)\n",
1660                    &yiaddr, chaddr, batadv_print_vid(vid));
1661 }
1662
1663 /**
1664  * batadv_dat_check_dhcp_ack() - examine packet for valid DHCP message
1665  * @skb: the packet to check
1666  * @proto: ethernet protocol hint (behind a potential vlan)
1667  * @ip_src: a buffer to store the IPv4 source address in
1668  * @chaddr: a buffer to store the DHCP Client Hardware Address in
1669  * @yiaddr: a buffer to store the DHCP Your IP Address in
1670  *
1671  * Checks whether the given skb is a valid DHCPACK. And if so, stores the
1672  * IPv4 server source address (ip_src), client MAC address (chaddr) and client
1673  * IPv4 address (yiaddr) in the provided buffers.
1674  *
1675  * Caller needs to ensure that the skb network header is set correctly.
1676  *
1677  * Return: True if the skb is a valid DHCPACK. False otherwise.
1678  */
1679 static bool
1680 batadv_dat_check_dhcp_ack(struct sk_buff *skb, __be16 proto, __be32 *ip_src,
1681                           u8 *chaddr, __be32 *yiaddr)
1682 {
1683         int type;
1684
1685         type = batadv_dat_check_dhcp(skb, proto, ip_src);
1686         if (type != BATADV_BOOTREPLY)
1687                 return false;
1688
1689         type = batadv_dat_get_dhcp_message_type(skb);
1690         if (type != BATADV_DHCPACK)
1691                 return false;
1692
1693         if (!batadv_dat_dhcp_get_yiaddr(skb, yiaddr))
1694                 return false;
1695
1696         if (!batadv_dat_get_dhcp_chaddr(skb, chaddr))
1697                 return false;
1698
1699         return true;
1700 }
1701
1702 /**
1703  * batadv_dat_snoop_outgoing_dhcp_ack() - snoop DHCPACK and fill DAT with it
1704  * @bat_priv: the bat priv with all the soft interface information
1705  * @skb: the packet to snoop
1706  * @proto: ethernet protocol hint (behind a potential vlan)
1707  * @vid: VLAN identifier
1708  *
1709  * This function first checks whether the given skb is a valid DHCPACK. If
1710  * so then its source MAC and IP as well as its DHCP Client Hardware Address
1711  * field and DHCP Your IP Address field are added to the local DAT cache and
1712  * propagated into the DHT.
1713  *
1714  * Caller needs to ensure that the skb mac and network headers are set
1715  * correctly.
1716  */
1717 void batadv_dat_snoop_outgoing_dhcp_ack(struct batadv_priv *bat_priv,
1718                                         struct sk_buff *skb,
1719                                         __be16 proto,
1720                                         unsigned short vid)
1721 {
1722         u8 chaddr[BATADV_DHCP_CHADDR_LEN];
1723         __be32 ip_src, yiaddr;
1724
1725         if (!atomic_read(&bat_priv->distributed_arp_table))
1726                 return;
1727
1728         if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr))
1729                 return;
1730
1731         batadv_dat_put_dhcp(bat_priv, chaddr, yiaddr, eth_hdr(skb)->h_source,
1732                             ip_src, vid);
1733 }
1734
1735 /**
1736  * batadv_dat_snoop_incoming_dhcp_ack() - snoop DHCPACK and fill DAT cache
1737  * @bat_priv: the bat priv with all the soft interface information
1738  * @skb: the packet to snoop
1739  * @hdr_size: header size, up to the tail of the batman-adv header
1740  *
1741  * This function first checks whether the given skb is a valid DHCPACK. If
1742  * so then its source MAC and IP as well as its DHCP Client Hardware Address
1743  * field and DHCP Your IP Address field are added to the local DAT cache.
1744  */
1745 void batadv_dat_snoop_incoming_dhcp_ack(struct batadv_priv *bat_priv,
1746                                         struct sk_buff *skb, int hdr_size)
1747 {
1748         u8 chaddr[BATADV_DHCP_CHADDR_LEN];
1749         struct ethhdr *ethhdr;
1750         __be32 ip_src, yiaddr;
1751         unsigned short vid;
1752         __be16 proto;
1753         u8 *hw_src;
1754
1755         if (!atomic_read(&bat_priv->distributed_arp_table))
1756                 return;
1757
1758         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
1759                 return;
1760
1761         ethhdr = (struct ethhdr *)(skb->data + hdr_size);
1762         skb_set_network_header(skb, hdr_size + ETH_HLEN);
1763         proto = ethhdr->h_proto;
1764
1765         if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr))
1766                 return;
1767
1768         hw_src = ethhdr->h_source;
1769         vid = batadv_dat_get_vid(skb, &hdr_size);
1770
1771         batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid);
1772         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1773
1774         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1775                    "Snooped from incoming DHCPACK (server address): %pI4, %pM (vid: %i)\n",
1776                    &ip_src, hw_src, batadv_print_vid(vid));
1777         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1778                    "Snooped from incoming DHCPACK (client address): %pI4, %pM (vid: %i)\n",
1779                    &yiaddr, chaddr, batadv_print_vid(vid));
1780 }
1781
1782 /**
1783  * batadv_dat_drop_broadcast_packet() - check if an ARP request has to be
1784  *  dropped (because the node has already obtained the reply via DAT) or not
1785  * @bat_priv: the bat priv with all the soft interface information
1786  * @forw_packet: the broadcast packet
1787  *
1788  * Return: true if the node can drop the packet, false otherwise.
1789  */
1790 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
1791                                       struct batadv_forw_packet *forw_packet)
1792 {
1793         u16 type;
1794         __be32 ip_dst;
1795         struct batadv_dat_entry *dat_entry = NULL;
1796         bool ret = false;
1797         int hdr_size = sizeof(struct batadv_bcast_packet);
1798         unsigned short vid;
1799
1800         if (!atomic_read(&bat_priv->distributed_arp_table))
1801                 goto out;
1802
1803         /* If this packet is an ARP_REQUEST and the node already has the
1804          * information that it is going to ask, then the packet can be dropped
1805          */
1806         if (batadv_forw_packet_is_rebroadcast(forw_packet))
1807                 goto out;
1808
1809         vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
1810
1811         type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
1812         if (type != ARPOP_REQUEST)
1813                 goto out;
1814
1815         ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
1816         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1817         /* check if the node already got this entry */
1818         if (!dat_entry) {
1819                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1820                            "ARP Request for %pI4: fallback\n", &ip_dst);
1821                 goto out;
1822         }
1823
1824         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1825                    "ARP Request for %pI4: fallback prevented\n", &ip_dst);
1826         ret = true;
1827
1828 out:
1829         batadv_dat_entry_put(dat_entry);
1830         return ret;
1831 }