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                         memcpy(dat_entry->mac_addr, mac_addr, ETH_ALEN);
 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         memcpy(dat_entry->mac_addr, mac_addr, ETH_ALEN);
 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(BATADV_DAT_CANDIDATES_NUM * sizeof(*res), GFP_ATOMIC);
 541         if (!res)
 542                 return NULL;
 543
 544         ip_key = (batadv_dat_addr_t)batadv_hash_dat(&ip_dst,
 545                                                     BATADV_DAT_ADDR_MAX);
 546
 547         batadv_dbg(BATADV_DBG_DAT, bat_priv,
 548                    "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst,
 549                    ip_key);
 550
 551         for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++)
 552                 batadv_choose_next_candidate(bat_priv, res, select, ip_key,
 553                                              &last_max);
 554
 555         return res;
 556 }
 557
 558 /**
 559  * batadv_dat_send_data - send a payload to the selected candidates
 560  * @bat_priv: the bat priv with all the soft interface information
 561  * @skb: payload to send
 562  * @ip: the DHT key
 563  * @packet_subtype: unicast4addr packet subtype to use
 564  *
 565  * This function copies the skb with pskb_copy() and is sent as unicast packet
 566  * to each of the selected candidates.
 567  *
 568  * Returns true if the packet is sent to at least one candidate, false
 569  * otherwise.
 570  */
 571 static bool batadv_dat_send_data(struct batadv_priv *bat_priv,
 572                                  struct sk_buff *skb, __be32 ip,
 573                                  int packet_subtype)
 574 {
 575         int i;
 576         bool ret = false;
 577         int send_status;
 578         struct batadv_neigh_node *neigh_node = NULL;
 579         struct sk_buff *tmp_skb;
 580         struct batadv_dat_candidate *cand;
 581
 582         cand = batadv_dat_select_candidates(bat_priv, ip);
 583         if (!cand)
 584                 goto out;
 585
 586         batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip);
 587
 588         for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) {
 589                 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND)
 590                         continue;
 591
 592                 neigh_node = batadv_orig_router_get(cand[i].orig_node,
 593                                                     BATADV_IF_DEFAULT);
 594                 if (!neigh_node)
 595                         goto free_orig;
 596
 597                 tmp_skb = pskb_copy(skb, GFP_ATOMIC);
 598                 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb,
 599                                                            cand[i].orig_node,
 600                                                            packet_subtype)) {
 601                         kfree_skb(tmp_skb);
 602                         goto free_neigh;
 603                 }
 604
 605                 send_status = batadv_send_skb_packet(tmp_skb,
 606                                                      neigh_node->if_incoming,
 607                                                      neigh_node->addr);
 608                 if (send_status == NET_XMIT_SUCCESS) {
 609                         /* count the sent packet */
 610                         switch (packet_subtype) {
 611                         case BATADV_P_DAT_DHT_GET:
 612                                 batadv_inc_counter(bat_priv,
 613                                                    BATADV_CNT_DAT_GET_TX);
 614                                 break;
 615                         case BATADV_P_DAT_DHT_PUT:
 616                                 batadv_inc_counter(bat_priv,
 617                                                    BATADV_CNT_DAT_PUT_TX);
 618                                 break;
 619                         }
 620
 621                         /* packet sent to a candidate: return true */
 622                         ret = true;
 623                 }
 624 free_neigh:
 625                 batadv_neigh_node_free_ref(neigh_node);
 626 free_orig:
 627                 batadv_orig_node_free_ref(cand[i].orig_node);
 628         }
 629
 630 out:
 631         kfree(cand);
 632         return ret;
 633 }
 634
 635 /**
 636  * batadv_dat_tvlv_container_update - update the dat tvlv container after dat
 637  *  setting change
 638  * @bat_priv: the bat priv with all the soft interface information
 639  */
 640 static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv)
 641 {
 642         char dat_mode;
 643
 644         dat_mode = atomic_read(&bat_priv->distributed_arp_table);
 645
 646         switch (dat_mode) {
 647         case 0:
 648                 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 649                 break;
 650         case 1:
 651                 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1,
 652                                                NULL, 0);
 653                 break;
 654         }
 655 }
 656
 657 /**
 658  * batadv_dat_status_update - update the dat tvlv container after dat
 659  *  setting change
 660  * @net_dev: the soft interface net device
 661  */
 662 void batadv_dat_status_update(struct net_device *net_dev)
 663 {
 664         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 665         batadv_dat_tvlv_container_update(bat_priv);
 666 }
 667
 668 /**
 669  * batadv_gw_tvlv_ogm_handler_v1 - process incoming dat tvlv container
 670  * @bat_priv: the bat priv with all the soft interface information
 671  * @orig: the orig_node of the ogm
 672  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
 673  * @tvlv_value: tvlv buffer containing the gateway data
 674  * @tvlv_value_len: tvlv buffer length
 675  */
 676 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
 677                                            struct batadv_orig_node *orig,
 678                                            uint8_t flags,
 679                                            void *tvlv_value,
 680                                            uint16_t tvlv_value_len)
 681 {
 682         if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND)
 683                 orig->capabilities &= ~BATADV_ORIG_CAPA_HAS_DAT;
 684         else
 685                 orig->capabilities |= BATADV_ORIG_CAPA_HAS_DAT;
 686 }
 687
 688 /**
 689  * batadv_dat_hash_free - free the local DAT hash table
 690  * @bat_priv: the bat priv with all the soft interface information
 691  */
 692 static void batadv_dat_hash_free(struct batadv_priv *bat_priv)
 693 {
 694         if (!bat_priv->dat.hash)
 695                 return;
 696
 697         __batadv_dat_purge(bat_priv, NULL);
 698
 699         batadv_hash_destroy(bat_priv->dat.hash);
 700
 701         bat_priv->dat.hash = NULL;
 702 }
 703
 704 /**
 705  * batadv_dat_init - initialise the DAT internals
 706  * @bat_priv: the bat priv with all the soft interface information
 707  */
 708 int batadv_dat_init(struct batadv_priv *bat_priv)
 709 {
 710         if (bat_priv->dat.hash)
 711                 return 0;
 712
 713         bat_priv->dat.hash = batadv_hash_new(1024);
 714
 715         if (!bat_priv->dat.hash)
 716                 return -ENOMEM;
 717
 718         batadv_dat_start_timer(bat_priv);
 719
 720         batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1,
 721                                      NULL, BATADV_TVLV_DAT, 1,
 722                                      BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
 723         batadv_dat_tvlv_container_update(bat_priv);
 724         return 0;
 725 }
 726
 727 /**
 728  * batadv_dat_free - free the DAT internals
 729  * @bat_priv: the bat priv with all the soft interface information
 730  */
 731 void batadv_dat_free(struct batadv_priv *bat_priv)
 732 {
 733         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 734         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1);
 735
 736         cancel_delayed_work_sync(&bat_priv->dat.work);
 737
 738         batadv_dat_hash_free(bat_priv);
 739 }
 740
 741 /**
 742  * batadv_dat_cache_seq_print_text - print the local DAT hash table
 743  * @seq: seq file to print on
 744  * @offset: not used
 745  */
 746 int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset)
 747 {
 748         struct net_device *net_dev = (struct net_device *)seq->private;
 749         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 750         struct batadv_hashtable *hash = bat_priv->dat.hash;
 751         struct batadv_dat_entry *dat_entry;
 752         struct batadv_hard_iface *primary_if;
 753         struct hlist_head *head;
 754         unsigned long last_seen_jiffies;
 755         int last_seen_msecs, last_seen_secs, last_seen_mins;
 756         uint32_t i;
 757
 758         primary_if = batadv_seq_print_text_primary_if_get(seq);
 759         if (!primary_if)
 760                 goto out;
 761
 762         seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name);
 763         seq_printf(seq, "          %-7s          %-9s %4s %11s\n", "IPv4",
 764                    "MAC", "VID", "last-seen");
 765
 766         for (i = 0; i < hash->size; i++) {
 767                 head = &hash->table[i];
 768
 769                 rcu_read_lock();
 770                 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) {
 771                         last_seen_jiffies = jiffies - dat_entry->last_update;
 772                         last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
 773                         last_seen_mins = last_seen_msecs / 60000;
 774                         last_seen_msecs = last_seen_msecs % 60000;
 775                         last_seen_secs = last_seen_msecs / 1000;
 776
 777                         seq_printf(seq, " * %15pI4 %14pM %4i %6i:%02i\n",
 778                                    &dat_entry->ip, dat_entry->mac_addr,
 779                                    BATADV_PRINT_VID(dat_entry->vid),
 780                                    last_seen_mins, last_seen_secs);
 781                 }
 782                 rcu_read_unlock();
 783         }
 784
 785 out:
 786         if (primary_if)
 787                 batadv_hardif_free_ref(primary_if);
 788         return 0;
 789 }
 790
 791 /**
 792  * batadv_arp_get_type - parse an ARP packet and gets the type
 793  * @bat_priv: the bat priv with all the soft interface information
 794  * @skb: packet to analyse
 795  * @hdr_size: size of the possible header before the ARP packet in the skb
 796  *
 797  * Returns the ARP type if the skb contains a valid ARP packet, 0 otherwise.
 798  */
 799 static uint16_t batadv_arp_get_type(struct batadv_priv *bat_priv,
 800                                     struct sk_buff *skb, int hdr_size)
 801 {
 802         struct arphdr *arphdr;
 803         struct ethhdr *ethhdr;
 804         __be32 ip_src, ip_dst;
 805         uint8_t *hw_src, *hw_dst;
 806         uint16_t type = 0;
 807
 808         /* pull the ethernet header */
 809         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN)))
 810                 goto out;
 811
 812         ethhdr = (struct ethhdr *)(skb->data + hdr_size);
 813
 814         if (ethhdr->h_proto != htons(ETH_P_ARP))
 815                 goto out;
 816
 817         /* pull the ARP payload */
 818         if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN +
 819                                     arp_hdr_len(skb->dev))))
 820                 goto out;
 821
 822         arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN);
 823
 824         /* check whether the ARP packet carries a valid IP information */
 825         if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
 826                 goto out;
 827
 828         if (arphdr->ar_pro != htons(ETH_P_IP))
 829                 goto out;
 830
 831         if (arphdr->ar_hln != ETH_ALEN)
 832                 goto out;
 833
 834         if (arphdr->ar_pln != 4)
 835                 goto out;
 836
 837         /* Check for bad reply/request. If the ARP message is not sane, DAT
 838          * will simply ignore it
 839          */
 840         ip_src = batadv_arp_ip_src(skb, hdr_size);
 841         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 842         if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) ||
 843             ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) ||
 844             ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) ||
 845             ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst))
 846                 goto out;
 847
 848         hw_src = batadv_arp_hw_src(skb, hdr_size);
 849         if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src))
 850                 goto out;
 851
 852         /* don't care about the destination MAC address in ARP requests */
 853         if (arphdr->ar_op != htons(ARPOP_REQUEST)) {
 854                 hw_dst = batadv_arp_hw_dst(skb, hdr_size);
 855                 if (is_zero_ether_addr(hw_dst) ||
 856                     is_multicast_ether_addr(hw_dst))
 857                         goto out;
 858         }
 859
 860         type = ntohs(arphdr->ar_op);
 861 out:
 862         return type;
 863 }
 864
 865 /**
 866  * batadv_dat_get_vid - extract the VLAN identifier from skb if any
 867  * @skb: the buffer containing the packet to extract the VID from
 868  * @hdr_size: the size of the batman-adv header encapsulating the packet
 869  *
 870  * If the packet embedded in the skb is vlan tagged this function returns the
 871  * VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS is returned.
 872  */
 873 static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size)
 874 {
 875         unsigned short vid;
 876
 877         vid = batadv_get_vid(skb, *hdr_size);
 878
 879         /* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
 880          * If the header contained in the packet is a VLAN one (which is longer)
 881          * hdr_size is updated so that the functions will still skip the
 882          * correct amount of bytes.
 883          */
 884         if (vid & BATADV_VLAN_HAS_TAG)
 885                 *hdr_size += VLAN_HLEN;
 886
 887         return vid;
 888 }
 889
 890 /**
 891  * batadv_dat_snoop_outgoing_arp_request - snoop the ARP request and try to
 892  * answer using DAT
 893  * @bat_priv: the bat priv with all the soft interface information
 894  * @skb: packet to check
 895  *
 896  * Returns true if the message has been sent to the dht candidates, false
 897  * otherwise. In case of a positive return value the message has to be enqueued
 898  * to permit the fallback.
 899  */
 900 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
 901                                            struct sk_buff *skb)
 902 {
 903         uint16_t type = 0;
 904         __be32 ip_dst, ip_src;
 905         uint8_t *hw_src;
 906         bool ret = false;
 907         struct batadv_dat_entry *dat_entry = NULL;
 908         struct sk_buff *skb_new;
 909         int hdr_size = 0;
 910         unsigned short vid;
 911
 912         if (!atomic_read(&bat_priv->distributed_arp_table))
 913                 goto out;
 914
 915         vid = batadv_dat_get_vid(skb, &hdr_size);
 916
 917         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
 918         /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
 919          * message to the selected DHT candidates
 920          */
 921         if (type != ARPOP_REQUEST)
 922                 goto out;
 923
 924         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
 925                        "Parsing outgoing ARP REQUEST");
 926
 927         ip_src = batadv_arp_ip_src(skb, hdr_size);
 928         hw_src = batadv_arp_hw_src(skb, hdr_size);
 929         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
 930
 931         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
 932
 933         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
 934         if (dat_entry) {
 935                 /* If the ARP request is destined for a local client the local
 936                  * client will answer itself. DAT would only generate a
 937                  * duplicate packet.
 938                  *
 939                  * Moreover, if the soft-interface is enslaved into a bridge, an
 940                  * additional DAT answer may trigger kernel warnings about
 941                  * a packet coming from the wrong port.
 942                  */
 943                 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) {
 944                         ret = true;
 945                         goto out;
 946                 }
 947
 948                 skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
 949                                      bat_priv->soft_iface, ip_dst, hw_src,
 950                                      dat_entry->mac_addr, hw_src);
 951                 if (!skb_new)
 952                         goto out;
 953
 954                 if (vid & BATADV_VLAN_HAS_TAG)
 955                         skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q),
 956                                                   vid & VLAN_VID_MASK);
 957
 958                 skb_reset_mac_header(skb_new);
 959                 skb_new->protocol = eth_type_trans(skb_new,
 960                                                    bat_priv->soft_iface);
 961                 bat_priv->stats.rx_packets++;
 962                 bat_priv->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size;
 963                 bat_priv->soft_iface->last_rx = jiffies;
 964
 965                 netif_rx(skb_new);
 966                 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
 967                 ret = true;
 968         } else {
 969                 /* Send the request to the DHT */
 970                 ret = batadv_dat_send_data(bat_priv, skb, ip_dst,
 971                                            BATADV_P_DAT_DHT_GET);
 972         }
 973 out:
 974         if (dat_entry)
 975                 batadv_dat_entry_free_ref(dat_entry);
 976         return ret;
 977 }
 978
 979 /**
 980  * batadv_dat_snoop_incoming_arp_request - snoop the ARP request and try to
 981  * answer using the local DAT storage
 982  * @bat_priv: the bat priv with all the soft interface information
 983  * @skb: packet to check
 984  * @hdr_size: size of the encapsulation header
 985  *
 986  * Returns true if the request has been answered, false otherwise.
 987  */
 988 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv,
 989                                            struct sk_buff *skb, int hdr_size)
 990 {
 991         uint16_t type;
 992         __be32 ip_src, ip_dst;
 993         uint8_t *hw_src;
 994         struct sk_buff *skb_new;
 995         struct batadv_dat_entry *dat_entry = NULL;
 996         bool ret = false;
 997         unsigned short vid;
 998         int err;
 999
1000         if (!atomic_read(&bat_priv->distributed_arp_table))
1001                 goto out;
1002
1003         vid = batadv_dat_get_vid(skb, &hdr_size);
1004
1005         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1006         if (type != ARPOP_REQUEST)
1007                 goto out;
1008
1009         hw_src = batadv_arp_hw_src(skb, hdr_size);
1010         ip_src = batadv_arp_ip_src(skb, hdr_size);
1011         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1012
1013         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1014                        "Parsing incoming ARP REQUEST");
1015
1016         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1017
1018         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1019         if (!dat_entry)
1020                 goto out;
1021
1022         skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src,
1023                              bat_priv->soft_iface, ip_dst, hw_src,
1024                              dat_entry->mac_addr, hw_src);
1025
1026         if (!skb_new)
1027                 goto out;
1028
1029         if (vid & BATADV_VLAN_HAS_TAG)
1030                 skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q),
1031                                           vid & VLAN_VID_MASK);
1032
1033         /* To preserve backwards compatibility, the node has choose the outgoing
1034          * format based on the incoming request packet type. The assumption is
1035          * that a node not using the 4addr packet format doesn't support it.
1036          */
1037         if (hdr_size == sizeof(struct batadv_unicast_4addr_packet))
1038                 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new,
1039                                                    BATADV_P_DAT_CACHE_REPLY,
1040                                                    NULL, vid);
1041         else
1042                 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid);
1043
1044         if (err != NET_XMIT_DROP) {
1045                 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX);
1046                 ret = true;
1047         }
1048 out:
1049         if (dat_entry)
1050                 batadv_dat_entry_free_ref(dat_entry);
1051         if (ret)
1052                 kfree_skb(skb);
1053         return ret;
1054 }
1055
1056 /**
1057  * batadv_dat_snoop_outgoing_arp_reply - snoop the ARP reply and fill the DHT
1058  * @bat_priv: the bat priv with all the soft interface information
1059  * @skb: packet to check
1060  */
1061 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
1062                                          struct sk_buff *skb)
1063 {
1064         uint16_t type;
1065         __be32 ip_src, ip_dst;
1066         uint8_t *hw_src, *hw_dst;
1067         int hdr_size = 0;
1068         unsigned short vid;
1069
1070         if (!atomic_read(&bat_priv->distributed_arp_table))
1071                 return;
1072
1073         vid = batadv_dat_get_vid(skb, &hdr_size);
1074
1075         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1076         if (type != ARPOP_REPLY)
1077                 return;
1078
1079         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1080                        "Parsing outgoing ARP REPLY");
1081
1082         hw_src = batadv_arp_hw_src(skb, hdr_size);
1083         ip_src = batadv_arp_ip_src(skb, hdr_size);
1084         hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1085         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1086
1087         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1088         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1089
1090         /* Send the ARP reply to the candidates for both the IP addresses that
1091          * the node obtained from the ARP reply
1092          */
1093         batadv_dat_send_data(bat_priv, skb, ip_src, BATADV_P_DAT_DHT_PUT);
1094         batadv_dat_send_data(bat_priv, skb, ip_dst, BATADV_P_DAT_DHT_PUT);
1095 }
1096 /**
1097  * batadv_dat_snoop_incoming_arp_reply - snoop the ARP reply and fill the local
1098  * DAT storage only
1099  * @bat_priv: the bat priv with all the soft interface information
1100  * @skb: packet to check
1101  * @hdr_size: size of the encapsulation header
1102  */
1103 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
1104                                          struct sk_buff *skb, int hdr_size)
1105 {
1106         uint16_t type;
1107         __be32 ip_src, ip_dst;
1108         uint8_t *hw_src, *hw_dst;
1109         bool ret = false;
1110         unsigned short vid;
1111
1112         if (!atomic_read(&bat_priv->distributed_arp_table))
1113                 goto out;
1114
1115         vid = batadv_dat_get_vid(skb, &hdr_size);
1116
1117         type = batadv_arp_get_type(bat_priv, skb, hdr_size);
1118         if (type != ARPOP_REPLY)
1119                 goto out;
1120
1121         batadv_dbg_arp(bat_priv, skb, type, hdr_size,
1122                        "Parsing incoming ARP REPLY");
1123
1124         hw_src = batadv_arp_hw_src(skb, hdr_size);
1125         ip_src = batadv_arp_ip_src(skb, hdr_size);
1126         hw_dst = batadv_arp_hw_dst(skb, hdr_size);
1127         ip_dst = batadv_arp_ip_dst(skb, hdr_size);
1128
1129         /* Update our internal cache with both the IP addresses the node got
1130          * within the ARP reply
1131          */
1132         batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
1133         batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);
1134
1135         /* if this REPLY is directed to a client of mine, let's deliver the
1136          * packet to the interface
1137          */
1138         ret = !batadv_is_my_client(bat_priv, hw_dst, vid);
1139 out:
1140         if (ret)
1141                 kfree_skb(skb);
1142         /* if ret == false -> packet has to be delivered to the interface */
1143         return ret;
1144 }
1145
1146 /**
1147  * batadv_dat_drop_broadcast_packet - check if an ARP request has to be dropped
1148  * (because the node has already obtained the reply via DAT) or not
1149  * @bat_priv: the bat priv with all the soft interface information
1150  * @forw_packet: the broadcast packet
1151  *
1152  * Returns true if the node can drop the packet, false otherwise.
1153  */
1154 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
1155                                       struct batadv_forw_packet *forw_packet)
1156 {
1157         uint16_t type;
1158         __be32 ip_dst;
1159         struct batadv_dat_entry *dat_entry = NULL;
1160         bool ret = false;
1161         int hdr_size = sizeof(struct batadv_bcast_packet);
1162         unsigned short vid;
1163
1164         if (!atomic_read(&bat_priv->distributed_arp_table))
1165                 goto out;
1166
1167         /* If this packet is an ARP_REQUEST and the node already has the
1168          * information that it is going to ask, then the packet can be dropped
1169          */
1170         if (forw_packet->num_packets)
1171                 goto out;
1172
1173         vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);
1174
1175         type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size);
1176         if (type != ARPOP_REQUEST)
1177                 goto out;
1178
1179         ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size);
1180         dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid);
1181         /* check if the node already got this entry */
1182         if (!dat_entry) {
1183                 batadv_dbg(BATADV_DBG_DAT, bat_priv,
1184                            "ARP Request for %pI4: fallback\n", &ip_dst);
1185                 goto out;
1186         }
1187
1188         batadv_dbg(BATADV_DBG_DAT, bat_priv,
1189                    "ARP Request for %pI4: fallback prevented\n", &ip_dst);
1190         ret = true;
1191
1192 out:
1193         if (dat_entry)
1194                 batadv_dat_entry_free_ref(dat_entry);
1195         return ret;
1196 }