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

   1 /* Copyright (C) 2011-2014 B.A.T.M.A.N. contributors:
   2  *
   3  * Antonio Quartulli
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of version 2 of the GNU General Public
   7  * License as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include <linux/if_ether.h>
  19 #include <linux/if_arp.h>
  20 #include <linux/if_vlan.h>
  21 #include <net/arp.h>
  22
  23 #include "main.h"
  24 #include "hash.h"
  25 #include "distributed-arp-table.h"
  26 #include "hard-interface.h"
  27 #include "originator.h"
  28 #include "send.h"
  29 #include "types.h"
  30 #include "translation-table.h"
  31
  32 static void batadv_dat_purge(struct work_struct *work);
  33
  34 /**
  35  * batadv_dat_start_timer - initialise the DAT periodic worker
  36  * @bat_priv: the bat priv with all the soft interface information
  37  */
  38 static void batadv_dat_start_timer(struct batadv_priv *bat_priv)
  39 {
  40         INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge);
  41         queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work,
  42                            msecs_to_jiffies(10000));
  43 }
  44
  45 /**
  46  * batadv_dat_entry_free_ref - decrement the dat_entry refcounter and possibly
  47  * free it
  48  * @dat_entry: the entry to free
  49  */
  50 static void batadv_dat_entry_free_ref(struct batadv_dat_entry *dat_entry)
  51 {
  52         if (atomic_dec_and_test(&dat_entry->refcount))
  53                 kfree_rcu(dat_entry, rcu);
  54 }
  55
  56 /**
  57  * batadv_dat_to_purge - check whether a dat_entry has to be purged or not
  58  * @dat_entry: the entry to check
  59  *
  60  * Returns true if the entry has to be purged now, false otherwise.
  61  */
  62 static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry)
  63 {
  64         return batadv_has_timed_out(dat_entry->last_update,
  65                                     BATADV_DAT_ENTRY_TIMEOUT);
  66 }
  67
  68 /**
  69  * __batadv_dat_purge - delete entries from the DAT local storage
  70  * @bat_priv: the bat priv with all the soft interface information
  71  * @to_purge: function in charge to decide whether an entry has to be purged or
  72  *            not. This function takes the dat_entry as argument and has to
  73  *            returns a boolean value: true is the entry has to be deleted,
  74  *            false otherwise
  75  *
  76  * Loops over each entry in the DAT local storage and deletes it if and only if
  77  * the to_purge function passed as argument returns true.
  78  */
  79 static void __batadv_dat_purge(struct batadv_priv *bat_priv,
  80                                bool (*to_purge)(struct batadv_dat_entry *))
  81 {
  82         spinlock_t *list_lock; /* protects write access to the hash lists */
  83         struct batadv_dat_entry *dat_entry;
  84         struct hlist_node *node_tmp;
  85         struct hlist_head *head;
  86         uint32_t i;
  87
  88         if (!bat_priv->dat.hash)
  89                 return;
  90
  91         for (i = 0; i < bat_priv->dat.hash->size; i++) {
  92                 head = &bat_priv->dat.hash->table[i];
  93                 list_lock = &bat_priv->dat.hash->list_locks[i];
  94
  95                 spin_lock_bh(list_lock);
  96                 hlist_for_each_entry_safe(dat_entry, node_tmp, head,
  97                                           hash_entry) {
  98                         /* if a helper function has been passed as parameter,
  99                          * ask it if the entry has to be purged or not
 100                          */
 101                         if (to_purge && !to_purge(dat_entry))
 102                                 continue;
 103
 104                         hlist_del_rcu(&dat_entry->hash_entry);
 105                         batadv_dat_entry_free_ref(dat_entry);
 106                 }
 107                 spin_unlock_bh(list_lock);
 108         }
 109 }
 110
 111 /**
 112  * batadv_dat_purge - periodic task that deletes old entries from the local DAT
 113  * hash table
 114  * @work: kernel work struct
 115  */
 116 static void batadv_dat_purge(struct work_struct *work)
 117 {
 118         struct delayed_work *delayed_work;
 119         struct batadv_priv_dat *priv_dat;
 120         struct batadv_priv *bat_priv;
 121
 122         delayed_work = container_of(work, struct delayed_work, work);
 123         priv_dat = container_of(delayed_work, struct batadv_priv_dat, work);
 124         bat_priv = container_of(priv_dat, struct batadv_priv, dat);
 125
 126         __batadv_dat_purge(bat_priv, batadv_dat_to_purge);
 127         batadv_dat_start_timer(bat_priv);
 128 }
 129
 130 /**
 131  * batadv_compare_dat - comparing function used in the local DAT hash table
 132  * @node: node in the local table
 133  * @data2: second object to compare the node to
 134  *
 135  * Returns 1 if the two entries are the same, 0 otherwise.
 136  */
 137 static int batadv_compare_dat(const struct hlist_node *node, const void *data2)
 138 {
 139         const void *data1 = container_of(node, struct batadv_dat_entry,
 140                                          hash_entry);
 141
 142         return memcmp(data1, data2, sizeof(__be32)) == 0 ? 1 : 0;
 143 }
 144
 145 /**
 146  * batadv_arp_hw_src - extract the hw_src field from an ARP packet
 147  * @skb: ARP packet
 148  * @hdr_size: size of the possible header before the ARP packet
 149  *
 150  * Returns the value of the hw_src field in the ARP packet.
 151  */
 152 static uint8_t *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size)
 153 {
 154         uint8_t *addr;
 155
 156         addr = (uint8_t *)(skb->data + hdr_size);
 157         addr += ETH_HLEN + sizeof(struct arphdr);
 158
 159         return addr;
 160 }
 161
 162 /**
 163  * batadv_arp_ip_src - extract the ip_src field from an ARP packet
 164  * @skb: ARP packet
 165  * @hdr_size: size of the possible header before the ARP packet
 166  *
 167  * Returns the value of the ip_src field in the ARP packet.
 168  */
 169 static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size)
 170 {
 171         return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN);
 172 }
 173
 174 /**
 175  * batadv_arp_hw_dst - extract the hw_dst field from an ARP packet
 176  * @skb: ARP packet
 177  * @hdr_size: size of the possible header before the ARP packet
 178  *
 179  * Returns the value of the hw_dst field in the ARP packet.
 180  */
 181 static uint8_t *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size)
 182 {
 183         return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4;
 184 }
 185
 186 /**
 187  * batadv_arp_ip_dst - extract the ip_dst field from an ARP packet
 188  * @skb: ARP packet
 189  * @hdr_size: size of the possible header before the ARP packet
 190  *
 191  * Returns the value of the ip_dst field in the ARP packet.
 192  */
 193 static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size)
 194 {
 195         return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4);
 196 }
 197
 198 /**
 199  * batadv_hash_dat - compute the hash value for an IP address
 200  * @data: data to hash
 201  * @size: size of the hash table
 202  *
 203  * Returns the selected index in the hash table for the given data.
 204  */
 205 static uint32_t batadv_hash_dat(const void *data, uint32_t size)
 206 {
 207         uint32_t hash = 0;
 208         const struct batadv_dat_entry *dat = data;
 209
 210         hash = batadv_hash_bytes(hash, &dat->ip, sizeof(dat->ip));
 211         hash = batadv_hash_bytes(hash, &dat->vid, sizeof(dat->vid));
 212
 213         hash += (hash << 3);
 214         hash ^= (hash >> 11);
 215         hash += (hash << 15);
 216
 217         return hash % size;
 218 }
 219
 220 /**
 221  * batadv_dat_entry_hash_find - look for a given dat_entry in the local hash
 222  * table
 223  * @bat_priv: the bat priv with all the soft interface information
 224  * @ip: search key
 225  * @vid: VLAN identifier
 226  *
 227  * Returns the dat_entry if found, NULL otherwise.
 228  */
 229 static struct batadv_dat_entry *
 230 batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip,
 231                            unsigned short vid)
 232 {
 233         struct hlist_head *head;
 234         struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL;
 235         struct batadv_hashtable *hash = bat_priv->dat.hash;
 236         uint32_t index;
 237
 238         if (!hash)
 239                 return NULL;
 240
 241         to_find.ip = ip;
 242         to_find.vid = vid;
 243
 244         index = batadv_hash_dat(&to_find, hash->size);
 245         head = &hash->table[index];
 246
 247         rcu_read_lock();
 248         hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
 249                 if (dat_entry->ip != ip)
 250                         continue;
 251
 252                 if (!atomic_inc_not_zero(&dat_entry->refcount))
 253                         continue;
 254
 255                 dat_entry_tmp = dat_entry;
 256                 break;
 257         }
 258         rcu_read_unlock();
 259
 260         return dat_entry_tmp;
 261 }
 262
 263 /**
 264  * batadv_dat_entry_add - add a new dat entry or update it if already exists
 265  * @bat_priv: the bat priv with all the soft interface information
 266  * @ip: ipv4 to add/edit
 267  * @mac_addr: mac address to assign to the given ipv4
 268  * @vid: VLAN identifier
 269  */
 270 static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
 271                                  uint8_t *mac_addr, unsigned short vid)
 272 {
 273         struct batadv_dat_entry *dat_entry;
 274         int hash_added;
 275
 276         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid);
 277         /* if this entry is already known, just update it */
 278         if (dat_entry) {
 279                 if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr))
 280                         ether_addr_copy(dat_entry->mac_addr, mac_addr);
 281                 dat_entry->last_update = jiffies;
 282                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 283                            "Entry updated: %pI4 %pM (vid: %d)\n",
 284                            &dat_entry->ip, dat_entry->mac_addr,
 285                            BATADV_PRINT_VID(vid));
 286                 goto out;
 287         }
 288
 289         dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC);
 290         if (!dat_entry)
 291                 goto out;
 292
 293         dat_entry->ip = ip;
 294         dat_entry->vid = vid;
 295         ether_addr_copy(dat_entry->mac_addr, mac_addr);
 296         dat_entry->last_update = jiffies;
 297         atomic_set(&dat_entry->refcount, 2);
 298
 299         hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat,
 300                                      batadv_hash_dat, dat_entry,
 301                                      &dat_entry->hash_entry);
 302
 303         if (unlikely(hash_added != 0)) {
 304                 /* remove the reference for the hash */
 305                 batadv_dat_entry_free_ref(dat_entry);
 306                 goto out;
 307         }
 308
 309         batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n",
 310                    &dat_entry->ip, dat_entry->mac_addr, BATADV_PRINT_VID(vid));
 311
 312 out:
 313         if (dat_entry)
 314                 batadv_dat_entry_free_ref(dat_entry);
 315 }
 316
 317 #ifdef CONFIG_BATMAN_ADV_DEBUG
 318
 319 /**
 320  * batadv_dbg_arp - print a debug message containing all the ARP packet details
 321  * @bat_priv: the bat priv with all the soft interface information
 322  * @skb: ARP packet
 323  * @type: ARP type
 324  * @hdr_size: size of the possible header before the ARP packet
 325  * @msg: message to print together with the debugging information
 326  */
 327 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
 328                            uint16_t type, int hdr_size, char *msg)
 329 {
 330         struct batadv_unicast_4addr_packet *unicast_4addr_packet;
 331         struct batadv_bcast_packet *bcast_pkt;
 332         uint8_t *orig_addr;
 333         __be32 ip_src, ip_dst;
 334
 335         if (msg)
 336                 batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg);
 337
 338         ip_src = batadv_arp_ip_src(skb, hdr_size);
 339         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 340         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 341                    "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
 342                    batadv_arp_hw_src(skb, hdr_size), &ip_src,
 343                    batadv_arp_hw_dst(skb, hdr_size), &ip_dst);
 344
 345         if (hdr_size == 0)
 346                 return;
 347
 348         unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
 349
 350         switch (unicast_4addr_packet->u.packet_type) {
 351         case BATADV_UNICAST:
 352                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 353                            "* encapsulated within a UNICAST packet\n");
 354                 break;
 355         case BATADV_UNICAST_4ADDR:
 356                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 357                            "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
 358                            unicast_4addr_packet->src);
 359                 switch (unicast_4addr_packet->subtype) {
 360                 case BATADV_P_DAT_DHT_PUT:
 361                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n");
 362                         break;
 363                 case BATADV_P_DAT_DHT_GET:
 364                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n");
 365                         break;
 366                 case BATADV_P_DAT_CACHE_REPLY:
 367                         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 368                                    "* type: DAT_CACHE_REPLY\n");
 369                         break;
 370                 case BATADV_P_DATA:
 371                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n");
 372                         break;
 373                 default:
 374                         batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n",
 375                                    unicast_4addr_packet->u.packet_type);
 376                 }
 377                 break;
 378         case BATADV_BCAST:
 379                 bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet;
 380                 orig_addr = bcast_pkt->orig;
 381                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 382                            "* encapsulated within a BCAST packet (src: %pM)\n",
 383                            orig_addr);
 384                 break;
 385         default:
 386                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 387                            "* encapsulated within an unknown packet type (0x%x)\n",
 388                            unicast_4addr_packet->u.packet_type);
 389         }
 390 }
 391
 392 #else
 393
 394 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb,
 395                            uint16_t type, int hdr_size, char *msg)
 396 {
 397 }
 398
 399 #endif /* CONFIG_BATMAN_ADV_DEBUG */
 400
 401 /**
 402  * batadv_is_orig_node_eligible - check whether a node can be a DHT candidate
 403  * @res: the array with the already selected candidates
 404  * @select: number of already selected candidates
 405  * @tmp_max: address of the currently evaluated node
 406  * @max: current round max address
 407  * @last_max: address of the last selected candidate
 408  * @candidate: orig_node under evaluation
 409  * @max_orig_node: last selected candidate
 410  *
 411  * Returns true if the node has been elected as next candidate or false
 412  * otherwise.
 413  */
 414 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res,
 415                                          int select, batadv_dat_addr_t tmp_max,
 416                                          batadv_dat_addr_t max,
 417                                          batadv_dat_addr_t last_max,
 418                                          struct batadv_orig_node *candidate,
 419                                          struct batadv_orig_node *max_orig_node)
 420 {
 421         bool ret = false;
 422         int j;
 423
 424         /* check if orig node candidate is running DAT */
 425         if (!(candidate->capabilities & BATADV_ORIG_CAPA_HAS_DAT))
 426                 goto out;
 427
 428         /* Check if this node has already been selected... */
 429         for (j = 0; j < select; j++)
 430                 if (res[j].orig_node == candidate)
 431                         break;
 432         /* ..and possibly skip it */
 433         if (j < select)
 434                 goto out;
 435         /* sanity check: has it already been selected? This should not happen */
 436         if (tmp_max > last_max)
 437                 goto out;
 438         /* check if during this iteration an originator with a closer dht
 439          * address has already been found
 440          */
 441         if (tmp_max < max)
 442                 goto out;
 443         /* this is an hash collision with the temporary selected node. Choose
 444          * the one with the lowest address
 445          */
 446         if ((tmp_max == max) && max_orig_node &&
 447             (batadv_compare_eth(candidate->orig, max_orig_node->orig) > 0))
 448                 goto out;
 449
 450         ret = true;
 451 out:
 452         return ret;
 453 }
 454
 455 /**
 456  * batadv_choose_next_candidate - select the next DHT candidate
 457  * @bat_priv: the bat priv with all the soft interface information
 458  * @cands: candidates array
 459  * @select: number of candidates already present in the array
 460  * @ip_key: key to look up in the DHT
 461  * @last_max: pointer where the address of the selected candidate will be saved
 462  */
 463 static void batadv_choose_next_candidate(struct batadv_priv *bat_priv,
 464                                          struct batadv_dat_candidate *cands,
 465                                          int select, batadv_dat_addr_t ip_key,
 466                                          batadv_dat_addr_t *last_max)
 467 {
 468         batadv_dat_addr_t max = 0, tmp_max = 0;
 469         struct batadv_orig_node *orig_node, *max_orig_node = NULL;
 470         struct batadv_hashtable *hash = bat_priv->orig_hash;
 471         struct hlist_head *head;
 472         int i;
 473
 474         /* if no node is eligible as candidate, leave the candidate type as
 475          * NOT_FOUND
 476          */
 477         cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND;
 478
 479         /* iterate over the originator list and find the node with the closest
 480          * dat_address which has not been selected yet
 481          */
 482         for (i = 0; i < hash->size; i++) {
 483                 head = &hash->table[i];
 484
 485                 rcu_read_lock();
 486                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
 487                         /* the dht space is a ring using unsigned addresses */
 488                         tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr +
 489                                   ip_key;
 490
 491                         if (!batadv_is_orig_node_eligible(cands, select,
 492                                                           tmp_max, max,
 493                                                           *last_max, orig_node,
 494                                                           max_orig_node))
 495                                 continue;
 496
 497                         if (!atomic_inc_not_zero(&orig_node->refcount))
 498                                 continue;
 499
 500                         max = tmp_max;
 501                         if (max_orig_node)
 502                                 batadv_orig_node_free_ref(max_orig_node);
 503                         max_orig_node = orig_node;
 504                 }
 505                 rcu_read_unlock();
 506         }
 507         if (max_orig_node) {
 508                 cands[select].type = BATADV_DAT_CANDIDATE_ORIG;
 509                 cands[select].orig_node = max_orig_node;
 510                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
 511                            "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
 512                            select, max_orig_node->orig, max_orig_node->dat_addr,
 513                            max);
 514         }
 515         *last_max = max;
 516 }
 517
 518 /**
 519  * batadv_dat_select_candidates - select the nodes which the DHT message has to
 520  * be sent to
 521  * @bat_priv: the bat priv with all the soft interface information
 522  * @ip_dst: ipv4 to look up in the DHT
 523  *
 524  * An originator O is selected if and only if its DHT_ID value is one of three
 525  * closest values (from the LEFT, with wrap around if needed) then the hash
 526  * value of the key. ip_dst is the key.
 527  *
 528  * Returns the candidate array of size BATADV_DAT_CANDIDATE_NUM.
 529  */
 530 static struct batadv_dat_candidate *
 531 batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst)
 532 {
 533         int select;
 534         batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key;
 535         struct batadv_dat_candidate *res;
 536
 537         if (!bat_priv->orig_hash)
 538                 return NULL;
 539
 540         res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res),
 541                             GFP_ATOMIC);
 542         if (!res)
 543                 return NULL;
 544
 545         ip_key = (batadv_dat_addr_t)batadv_hash_dat(&ip_dst,
 546                                                     BATADV_DAT_ADDR_MAX);
 547
 548         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 549                    "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst,
 550                    ip_key);
 551
 552         for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
 553                 batadv_choose_next_candidate(bat_priv, res, select, ip_key,
 554                                              &last_max);
 555
 556         return res;
 557 }
 558
 559 /**
 560  * batadv_dat_send_data - send a payload to the selected candidates
 561  * @bat_priv: the bat priv with all the soft interface information
 562  * @skb: payload to send
 563  * @ip: the DHT key
 564  * @packet_subtype: unicast4addr packet subtype to use
 565  *
 566  * This function copies the skb with pskb_copy() and is sent as unicast packet
 567  * to each of the selected candidates.
 568  *
 569  * Returns true if the packet is sent to at least one candidate, false
 570  * otherwise.
 571  */
 572 static bool batadv_dat_send_data(struct batadv_priv *bat_priv,
 573                                  struct sk_buff *skb, __be32 ip,
 574                                  int packet_subtype)
 575 {
 576         int i;
 577         bool ret = false;
 578         int send_status;
 579         struct batadv_neigh_node *neigh_node = NULL;
 580         struct sk_buff *tmp_skb;
 581         struct batadv_dat_candidate *cand;
 582
 583         cand = batadv_dat_select_candidates(bat_priv, ip);
 584         if (!cand)
 585                 goto out;
 586
 587         batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
 588
 589         for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
 590                 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
 591                         continue;
 592
 593                 neigh_node = batadv_orig_router_get(cand[i].orig_node,
 594                                                     BATADV_IF_DEFAULT);
 595                 if (!neigh_node)
 596                         goto free_orig;
 597
 598                 tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC);
 599                 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
 600                                                            cand[i].orig_node,
 601                                                            packet_subtype)) {
 602                         kfree_skb(tmp_skb);
 603                         goto free_neigh;
 604                 }
 605
 606                 send_status = batadv_send_skb_packet(tmp_skb,
 607                                                      neigh_node->if_incoming,
 608                                                      neigh_node->addr);
 609                 if (send_status == NET_XMIT_SUCCESS) {
 610                         /* count the sent packet */
 611                         switch (packet_subtype) {
 612                         case BATADV_P_DAT_DHT_GET:
 613                                 batadv_inc_counter(bat_priv,
 614                                                    BATADV_CNT_DAT_GET_TX);
 615                                 break;
 616                         case BATADV_P_DAT_DHT_PUT:
 617                                 batadv_inc_counter(bat_priv,
 618                                                    BATADV_CNT_DAT_PUT_TX);
 619                                 break;
 620                         }
 621
 622                         /* packet sent to a candidate: return true */
 623                         ret = true;
 624                 }
 625 free_neigh:
 626                 batadv_neigh_node_free_ref(neigh_node);
 627 free_orig:
 628                 batadv_orig_node_free_ref(cand[i].orig_node);
 629         }
 630
 631 out:
 632         kfree(cand);
 633         return ret;
 634 }
 635
 636 /**
 637  * batadv_dat_tvlv_container_update - update the dat tvlv container after dat
 638  *  setting change
 639  * @bat_priv: the bat priv with all the soft interface information
 640  */
 641 static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
 642 {
 643         char dat_mode;
 644
 645         dat_mode = atomic_read(&bat_priv->distributed_arp_table);
 646
 647         switch (dat_mode) {
 648         case 0:
 649                 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 650                 break;
 651         case 1:
 652                 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
 653                                                NULL, 0);
 654                 break;
 655         }
 656 }
 657
 658 /**
 659  * batadv_dat_status_update - update the dat tvlv container after dat
 660  *  setting change
 661  * @net_dev: the soft interface net device
 662  */
 663 void batadv_dat_status_update(struct net_device *net_dev)
 664 {
 665         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 666
 667         batadv_dat_tvlv_container_update(bat_priv);
 668 }
 669
 670 /**
 671  * batadv_gw_tvlv_ogm_handler_v1 - process incoming dat tvlv container
 672  * @bat_priv: the bat priv with all the soft interface information
 673  * @orig: the orig_node of the ogm
 674  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
 675  * @tvlv_value: tvlv buffer containing the gateway data
 676  * @tvlv_value_len: tvlv buffer length
 677  */
 678 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
 679                                            struct batadv_orig_node *orig,
 680                                            uint8_t flags,
 681                                            void *tvlv_value,
 682                                            uint16_t tvlv_value_len)
 683 {
 684         if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
 685                 orig->capabilities &= ~BATADV_ORIG_CAPA_HAS_DAT;
 686         else
 687                 orig->capabilities |= BATADV_ORIG_CAPA_HAS_DAT;
 688 }
 689
 690 /**
 691  * batadv_dat_hash_free - free the local DAT hash table
 692  * @bat_priv: the bat priv with all the soft interface information
 693  */
 694 static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
 695 {
 696         if (!bat_priv->dat.hash)
 697                 return;
 698
 699         __batadv_dat_purge(bat_priv, NULL);
 700
 701         batadv_hash_destroy(bat_priv->dat.hash);
 702
 703         bat_priv->dat.hash = NULL;
 704 }
 705
 706 /**
 707  * batadv_dat_init - initialise the DAT internals
 708  * @bat_priv: the bat priv with all the soft interface information
 709  */
 710 int batadv_dat_init(struct batadv_priv *bat_priv)
 711 {
 712         if (bat_priv->dat.hash)
 713                 return 0;
 714
 715         bat_priv->dat.hash = batadv_hash_new(1024);
 716
 717         if (!bat_priv->dat.hash)
 718                 return -ENOMEM;
 719
 720         batadv_dat_start_timer(bat_priv);
 721
 722         batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
 723                                      NULL, BATADV_TVLV_DAT, 1,
 724                                      BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
 725         batadv_dat_tvlv_container_update(bat_priv);
 726         return 0;
 727 }
 728
 729 /**
 730  * batadv_dat_free - free the DAT internals
 731  * @bat_priv: the bat priv with all the soft interface information
 732  */
 733 void batadv_dat_free(struct batadv_priv *bat_priv)
 734 {
 735         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 736         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 737
 738         cancel_delayed_work_sync(&bat_priv->dat.work);
 739
 740         batadv_dat_hash_free(bat_priv);
 741 }
 742
 743 /**
 744  * batadv_dat_cache_seq_print_text - print the local DAT hash table
 745  * @seq: seq file to print on
 746  * @offset: not used
 747  */
 748 int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
 749 {
 750         struct net_device *net_dev = (struct net_device *)seq->private;
 751         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 752         struct batadv_hashtable *hash = bat_priv->dat.hash;
 753         struct batadv_dat_entry *dat_entry;
 754         struct batadv_hard_iface *primary_if;
 755         struct hlist_head *head;
 756         unsigned long last_seen_jiffies;
 757         int last_seen_msecs, last_seen_secs, last_seen_mins;
 758         uint32_t i;
 759
 760         primary_if = batadv_seq_print_text_primary_if_get(seq);
 761         if (!primary_if)
 762                 goto out;
 763
 764         seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name);
 765         seq_printf(seq, "          %-7s          %-9s %4s %11s\n", "IPv4",
 766                    "MAC", "VID", "last-seen");
 767
 768         for (i = 0; i < hash->size; i++) {
 769                 head = &hash->table[i];
 770
 771                 rcu_read_lock();
 772                 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
 773                         last_seen_jiffies = jiffies - dat_entry->last_update;
 774                         last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
 775                         last_seen_mins = last_seen_msecs / 60000;
 776                         last_seen_msecs = last_seen_msecs % 60000;
 777                         last_seen_secs = last_seen_msecs / 1000;
 778
 779                         seq_printf(seq, " * %15pI4 %14pM %4i %6i:%02i\n",
 780                                    &dat_entry->ip, dat_entry->mac_addr,
 781                                    BATADV_PRINT_VID(dat_entry->vid),
 782                                    last_seen_mins, last_seen_secs);
 783                 }
 784                 rcu_read_unlock();
 785         }
 786
 787 out:
 788         if (primary_if)
 789                 batadv_hardif_free_ref(primary_if);
 790         return 0;
 791 }
 792
 793 /**
 794  * batadv_arp_get_type - parse an ARP packet and gets the type
 795  * @bat_priv: the bat priv with all the soft interface information
 796  * @skb: packet to analyse
 797  * @hdr_size: size of the possible header before the ARP packet in the skb
 798  *
 799  * Returns the ARP type if the skb contains a valid ARP packet, 0 otherwise.
 800  */
 801 static uint16_t batadv_arp_get_type(struct batadv_priv *bat_priv,
 802                                     struct sk_buff *skb, int hdr_size)
 803 {
 804         struct arphdr *arphdr;
 805         struct ethhdr *ethhdr;
 806         __be32 ip_src, ip_dst;
 807         uint8_t *hw_src, *hw_dst;
 808         uint16_t type = 0;
 809
 810         /* pull the ethernet header */
 811         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
 812                 goto out;
 813
 814         ethhdr = (struct ethhdr *)(skb->data + hdr_size);
 815
 816         if (ethhdr->h_proto != htons(ETH_P_ARP))
 817                 goto out;
 818
 819         /* pull the ARP payload */
 820         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
 821                                     arp_hdr_len(skb->dev))))
 822                 goto out;
 823
 824         arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
 825
 826         /* check whether the ARP packet carries a valid IP information */
 827         if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
 828                 goto out;
 829
 830         if (arphdr->ar_pro != htons(ETH_P_IP))
 831                 goto out;
 832
 833         if (arphdr->ar_hln != ETH_ALEN)
 834                 goto out;
 835
 836         if (arphdr->ar_pln != 4)
 837                 goto out;
 838
 839         /* Check for bad reply/request. If the ARP message is not sane, DAT
 840          * will simply ignore it
 841          */
 842         ip_src = batadv_arp_ip_src(skb, hdr_size);
 843         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 844         if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
 845             ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
 846             ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
 847             ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
 848                 goto out;
 849
 850         hw_src = batadv_arp_hw_src(skb, hdr_size);
 851         if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
 852                 goto out;
 853
 854         /* don't care about the destination MAC address in ARP requests */
 855         if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
 856                 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
 857                 if (is_zero_ether_addr(hw_dst) ||
 858                     is_multicast_ether_addr(hw_dst))
 859                         goto out;
 860         }
 861
 862         type = ntohs(arphdr->ar_op);
 863 out:
 864         return type;
 865 }
 866
 867 /**
 868  * batadv_dat_get_vid - extract the VLAN identifier from skb if any
 869  * @skb: the buffer containing the packet to extract the VID from
 870  * @hdr_size: the size of the batman-adv header encapsulating the packet
 871  *
 872  * If the packet embedded in the skb is vlan tagged this function returns the
 873  * VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS is returned.
 874  */
 875 static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
 876 {
 877         unsigned short vid;
 878
 879         vid = batadv_get_vid(skb, *hdr_size);
 880
 881         /* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
 882          * If the header contained in the packet is a VLAN one (which is longer)
 883          * hdr_size is updated so that the functions will still skip the
 884          * correct amount of bytes.
 885          */
 886         if (vid & BATADV_VLAN_HAS_TAG)
 887                 *hdr_size += VLAN_HLEN;
 888
 889         return vid;
 890 }
 891
 892 /**
 893  * batadv_dat_snoop_outgoing_arp_request - snoop the ARP request and try to
 894  * answer using DAT
 895  * @bat_priv: the bat priv with all the soft interface information
 896  * @skb: packet to check
 897  *
 898  * Returns true if the message has been sent to the dht candidates, false
 899  * otherwise. In case of a positive return value the message has to be enqueued
 900  * to permit the fallback.
 901  */
 902 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
 903                                            struct sk_buff *skb)
 904 {
 905         uint16_t type = 0;
 906         __be32 ip_dst, ip_src;
 907         uint8_t *hw_src;
 908         bool ret = false;
 909         struct batadv_dat_entry *dat_entry = NULL;
 910         struct sk_buff *skb_new;
 911         int hdr_size = 0;
 912         unsigned short vid;
 913
 914         if (!atomic_read(&bat_priv->distributed_arp_table))
 915                 goto out;
 916
 917         vid = batadv_dat_get_vid(skb, &hdr_size);
 918
 919         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
 920         /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
 921          * message to the selected DHT candidates
 922          */
 923         if (type != ARPOP_REQUEST)
 924                 goto out;
 925
 926         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
 927                        "Parsing outgoing ARP REQUEST");
 928
 929         ip_src = batadv_arp_ip_src(skb, hdr_size);
 930         hw_src = batadv_arp_hw_src(skb, hdr_size);
 931         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 932
 933         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
 934
 935         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
 936         if (dat_entry) {
 937                 /* If the ARP request is destined for a local client the local
 938                  * client will answer itself. DAT would only generate a
 939                  * duplicate packet.
 940                  *
 941                  * Moreover, if the soft-interface is enslaved into a bridge, an
 942                  * additional DAT answer may trigger kernel warnings about
 943                  * a packet coming from the wrong port.
 944                  */
 945                 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
 946                         ret = true;
 947                         goto out;
 948                 }
 949
 950                 skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
 951                                      bat_priv->soft_iface, ip_dst, hw_src,
 952                                      dat_entry->mac_addr, hw_src);
 953                 if (!skb_new)
 954                         goto out;
 955
 956                 if (vid & BATADV_VLAN_HAS_TAG)
 957                         skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q),
 958                                                   vid & VLAN_VID_MASK);
 959
 960                 skb_reset_mac_header(skb_new);
 961                 skb_new->protocol = eth_type_trans(skb_new,
 962                                                    bat_priv->soft_iface);
 963                 bat_priv->stats.rx_packets++;
 964                 bat_priv->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size;
 965                 bat_priv->soft_iface->last_rx = jiffies;
 966
 967                 netif_rx(skb_new);
 968                 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
 969                 ret = true;
 970         } else {
 971                 /* Send the request to the DHT */
 972                 ret = batadv_dat_send_data(bat_priv, skb, ip_dst,
 973                                            BATADV_P_DAT_DHT_GET);
 974         }
 975 out:
 976         if (dat_entry)
 977                 batadv_dat_entry_free_ref(dat_entry);
 978         return ret;
 979 }
 980
 981 /**
 982  * batadv_dat_snoop_incoming_arp_request - snoop the ARP request and try to
 983  * answer using the local DAT storage
 984  * @bat_priv: the bat priv with all the soft interface information
 985  * @skb: packet to check
 986  * @hdr_size: size of the encapsulation header
 987  *
 988  * Returns true if the request has been answered, false otherwise.
 989  */
 990 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
 991                                            struct sk_buff *skb, int hdr_size)
 992 {
 993         uint16_t type;
 994         __be32 ip_src, ip_dst;
 995         uint8_t *hw_src;
 996         struct sk_buff *skb_new;
 997         struct batadv_dat_entry *dat_entry = NULL;
 998         bool ret = false;
 999         unsigned short vid;
1000         int err;
1001
1002         if (!atomic_read(&bat_priv->distributed_arp_table))
1003                 goto out;
1004
1005         vid = batadv_dat_get_vid(skb, &hdr_size);
1006
1007         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1008         if (type != ARPOP_REQUEST)
1009                 goto out;
1010
1011         hw_src = batadv_arp_hw_src(skb, hdr_size);
1012         ip_src = batadv_arp_ip_src(skb, hdr_size);
1013         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1014
1015         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1016                        "Parsing incoming ARP REQUEST");
1017
1018         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1019
1020         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1021         if (!dat_entry)
1022                 goto out;
1023
1024         skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
1025                              bat_priv->soft_iface, ip_dst, hw_src,
1026                              dat_entry->mac_addr, hw_src);
1027
1028         if (!skb_new)
1029                 goto out;
1030
1031         /* the rest of the TX path assumes that the mac_header offset pointing
1032          * to the inner Ethernet header has been set, therefore reset it now.
1033          */
1034         skb_reset_mac_header(skb_new);
1035
1036         if (vid & BATADV_VLAN_HAS_TAG)
1037                 skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q),
1038                                           vid & VLAN_VID_MASK);
1039
1040         /* To preserve backwards compatibility, the node has choose the outgoing
1041          * format based on the incoming request packet type. The assumption is
1042          * that a node not using the 4addr packet format doesn't support it.
1043          */
1044         if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
1045                 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
1046                                                    BATADV_P_DAT_CACHE_REPLY,
1047                                                    NULL, vid);
1048         else
1049                 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
1050
1051         if (err != NET_XMIT_DROP) {
1052                 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
1053                 ret = true;
1054         }
1055 out:
1056         if (dat_entry)
1057                 batadv_dat_entry_free_ref(dat_entry);
1058         if (ret)
1059                 kfree_skb(skb);
1060         return ret;
1061 }
1062
1063 /**
1064  * batadv_dat_snoop_outgoing_arp_reply - snoop the ARP reply and fill the DHT
1065  * @bat_priv: the bat priv with all the soft interface information
1066  * @skb: packet to check
1067  */
1068 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
1069                                          struct sk_buff *skb)
1070 {
1071         uint16_t type;
1072         __be32 ip_src, ip_dst;
1073         uint8_t *hw_src, *hw_dst;
1074         int hdr_size = 0;
1075         unsigned short vid;
1076
1077         if (!atomic_read(&bat_priv->distributed_arp_table))
1078                 return;
1079
1080         vid = batadv_dat_get_vid(skb, &hdr_size);
1081
1082         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1083         if (type != ARPOP_REPLY)
1084                 return;
1085
1086         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1087                        "Parsing outgoing ARP REPLY");
1088
1089         hw_src = batadv_arp_hw_src(skb, hdr_size);
1090         ip_src = batadv_arp_ip_src(skb, hdr_size);
1091         hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1092         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1093
1094         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1095         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1096
1097         /* Send the ARP reply to the candidates for both the IP addresses that
1098          * the node obtained from the ARP reply
1099          */
1100         batadv_dat_send_data(bat_priv, skb, ip_src, BATADV_P_DAT_DHT_PUT);
1101         batadv_dat_send_data(bat_priv, skb, ip_dst, BATADV_P_DAT_DHT_PUT);
1102 }
1103
1104 /**
1105  * batadv_dat_snoop_incoming_arp_reply - snoop the ARP reply and fill the local
1106  * DAT storage only
1107  * @bat_priv: the bat priv with all the soft interface information
1108  * @skb: packet to check
1109  * @hdr_size: size of the encapsulation header
1110  */
1111 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
1112                                          struct sk_buff *skb, int hdr_size)
1113 {
1114         uint16_t type;
1115         __be32 ip_src, ip_dst;
1116         uint8_t *hw_src, *hw_dst;
1117         bool ret = false;
1118         unsigned short vid;
1119
1120         if (!atomic_read(&bat_priv->distributed_arp_table))
1121                 goto out;
1122
1123         vid = batadv_dat_get_vid(skb, &hdr_size);
1124
1125         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1126         if (type != ARPOP_REPLY)
1127                 goto out;
1128
1129         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1130                        "Parsing incoming ARP REPLY");
1131
1132         hw_src = batadv_arp_hw_src(skb, hdr_size);
1133         ip_src = batadv_arp_ip_src(skb, hdr_size);
1134         hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1135         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1136
1137         /* Update our internal cache with both the IP addresses the node got
1138          * within the ARP reply
1139          */
1140         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1141         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1142
1143         /* if this REPLY is directed to a client of mine, let's deliver the
1144          * packet to the interface
1145          */
1146         ret = !batadv_is_my_client(bat_priv, hw_dst, vid);
1147 out:
1148         if (ret)
1149                 kfree_skb(skb);
1150         /* if ret == false -> packet has to be delivered to the interface */
1151         return ret;
1152 }
1153
1154 /**
1155  * batadv_dat_drop_broadcast_packet - check if an ARP request has to be dropped
1156  * (because the node has already obtained the reply via DAT) or not
1157  * @bat_priv: the bat priv with all the soft interface information
1158  * @forw_packet: the broadcast packet
1159  *
1160  * Returns true if the node can drop the packet, false otherwise.
1161  */
1162 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
1163                                       struct batadv_forw_packet *forw_packet)
1164 {
1165         uint16_t type;
1166         __be32 ip_dst;
1167         struct batadv_dat_entry *dat_entry = NULL;
1168         bool ret = false;
1169         int hdr_size = sizeof(struct batadv_bcast_packet);
1170         unsigned short vid;
1171
1172         if (!atomic_read(&bat_priv->distributed_arp_table))
1173                 goto out;
1174
1175         /* If this packet is an ARP_REQUEST and the node already has the
1176          * information that it is going to ask, then the packet can be dropped
1177          */
1178         if (forw_packet->num_packets)
1179                 goto out;
1180
1181         vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
1182
1183         type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
1184         if (type != ARPOP_REQUEST)
1185                 goto out;
1186
1187         ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
1188         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1189         /* check if the node already got this entry */
1190         if (!dat_entry) {
1191                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1192                            "ARP Request for %pI4: fallback\n", &ip_dst);
1193                 goto out;
1194         }
1195
1196         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1197                    "ARP Request for %pI4: fallback prevented\n", &ip_dst);
1198         ret = true;
1199
1200 out:
1201         if (dat_entry)
1202                 batadv_dat_entry_free_ref(dat_entry);
1203         return ret;
1204 }