1 /* Copyright (C) 2011-2012 B.A.T.M.A.N. contributors:
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.
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.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
20 #include <linux/if_ether.h>
21 #include <linux/if_arp.h>
26 #include "distributed-arp-table.h"
27 #include "hard-interface.h"
28 #include "originator.h"
31 #include "translation-table.h"
34 static void batadv_dat_purge(struct work_struct
*work
);
37 * batadv_dat_start_timer - initialise the DAT periodic worker
38 * @bat_priv: the bat priv with all the soft interface information
40 static void batadv_dat_start_timer(struct batadv_priv
*bat_priv
)
42 INIT_DELAYED_WORK(&bat_priv
->dat
.work
, batadv_dat_purge
);
43 queue_delayed_work(batadv_event_workqueue
, &bat_priv
->dat
.work
,
44 msecs_to_jiffies(10000));
48 * batadv_dat_entry_free_ref - decrements the dat_entry refcounter and possibly
50 * @dat_entry: the oentry to free
52 static void batadv_dat_entry_free_ref(struct batadv_dat_entry
*dat_entry
)
54 if (atomic_dec_and_test(&dat_entry
->refcount
))
55 kfree_rcu(dat_entry
, rcu
);
59 * batadv_dat_to_purge - checks whether a dat_entry has to be purged or not
60 * @dat_entry: the entry to check
62 * Returns true if the entry has to be purged now, false otherwise
64 static bool batadv_dat_to_purge(struct batadv_dat_entry
*dat_entry
)
66 return batadv_has_timed_out(dat_entry
->last_update
,
67 BATADV_DAT_ENTRY_TIMEOUT
);
71 * __batadv_dat_purge - delete entries from the DAT local storage
72 * @bat_priv: the bat priv with all the soft interface information
73 * @to_purge: function in charge to decide whether an entry has to be purged or
74 * not. This function takes the dat_entry as argument and has to
75 * returns a boolean value: true is the entry has to be deleted,
78 * Loops over each entry in the DAT local storage and delete it if and only if
79 * the to_purge function passed as argument returns true
81 static void __batadv_dat_purge(struct batadv_priv
*bat_priv
,
82 bool (*to_purge
)(struct batadv_dat_entry
*))
84 spinlock_t
*list_lock
; /* protects write access to the hash lists */
85 struct batadv_dat_entry
*dat_entry
;
86 struct hlist_node
*node
, *node_tmp
;
87 struct hlist_head
*head
;
90 if (!bat_priv
->dat
.hash
)
93 for (i
= 0; i
< bat_priv
->dat
.hash
->size
; i
++) {
94 head
= &bat_priv
->dat
.hash
->table
[i
];
95 list_lock
= &bat_priv
->dat
.hash
->list_locks
[i
];
97 spin_lock_bh(list_lock
);
98 hlist_for_each_entry_safe(dat_entry
, node
, node_tmp
, head
,
100 /* if an helper function has been passed as parameter,
101 * ask it if the entry has to be purged or not
103 if (to_purge
&& !to_purge(dat_entry
))
107 batadv_dat_entry_free_ref(dat_entry
);
109 spin_unlock_bh(list_lock
);
114 * batadv_dat_purge - periodic task that deletes old entries from the local DAT
116 * @work: kernel work struct
118 static void batadv_dat_purge(struct work_struct
*work
)
120 struct delayed_work
*delayed_work
;
121 struct batadv_priv_dat
*priv_dat
;
122 struct batadv_priv
*bat_priv
;
124 delayed_work
= container_of(work
, struct delayed_work
, work
);
125 priv_dat
= container_of(delayed_work
, struct batadv_priv_dat
, work
);
126 bat_priv
= container_of(priv_dat
, struct batadv_priv
, dat
);
128 __batadv_dat_purge(bat_priv
, batadv_dat_to_purge
);
129 batadv_dat_start_timer(bat_priv
);
133 * batadv_compare_dat - comparing function used in the local DAT hash table
134 * @node: node in the local table
135 * @data2: second object to compare the node to
137 * Returns 1 if the two entry are the same, 0 otherwise
139 static int batadv_compare_dat(const struct hlist_node
*node
, const void *data2
)
141 const void *data1
= container_of(node
, struct batadv_dat_entry
,
144 return (memcmp(data1
, data2
, sizeof(__be32
)) == 0 ? 1 : 0);
148 * batadv_arp_hw_src - extract the hw_src field from an ARP packet
150 * @hdr_size: size of the possible header before the ARP packet
152 * Returns the value of the hw_src field in the ARP packet
154 static uint8_t *batadv_arp_hw_src(struct sk_buff
*skb
, int hdr_size
)
158 addr
= (uint8_t *)(skb
->data
+ hdr_size
);
159 addr
+= ETH_HLEN
+ sizeof(struct arphdr
);
165 * batadv_arp_ip_src - extract the ip_src field from an ARP packet
167 * @hdr_size: size of the possible header before the ARP packet
169 * Returns the value of the ip_src field in the ARP packet
171 static __be32
batadv_arp_ip_src(struct sk_buff
*skb
, int hdr_size
)
173 return *(__be32
*)(batadv_arp_hw_src(skb
, hdr_size
) + ETH_ALEN
);
177 * batadv_arp_hw_dst - extract the hw_dst field from an ARP packet
179 * @hdr_size: size of the possible header before the ARP packet
181 * Returns the value of the hw_dst field in the ARP packet
183 static uint8_t *batadv_arp_hw_dst(struct sk_buff
*skb
, int hdr_size
)
185 return batadv_arp_hw_src(skb
, hdr_size
) + ETH_ALEN
+ 4;
189 * batadv_arp_ip_dst - extract the ip_dst field from an ARP packet
191 * @hdr_size: size of the possible header before the ARP packet
193 * Returns the value of the ip_dst field in the ARP packet
195 static __be32
batadv_arp_ip_dst(struct sk_buff
*skb
, int hdr_size
)
197 return *(__be32
*)(batadv_arp_hw_src(skb
, hdr_size
) + ETH_ALEN
* 2 + 4);
201 * batadv_hash_dat - compute the hash value for an IP address
202 * @data: data to hash
203 * @size: size of the hash table
205 * Returns the selected index in the hash table for the given data
207 static uint32_t batadv_hash_dat(const void *data
, uint32_t size
)
209 const unsigned char *key
= data
;
213 for (i
= 0; i
< 4; i
++) {
215 hash
+= (hash
<< 10);
220 hash
^= (hash
>> 11);
221 hash
+= (hash
<< 15);
227 * batadv_dat_entry_hash_find - looks for a given dat_entry in the local hash
229 * @bat_priv: the bat priv with all the soft interface information
232 * Returns the dat_entry if found, NULL otherwise
234 static struct batadv_dat_entry
*
235 batadv_dat_entry_hash_find(struct batadv_priv
*bat_priv
, __be32 ip
)
237 struct hlist_head
*head
;
238 struct hlist_node
*node
;
239 struct batadv_dat_entry
*dat_entry
, *dat_entry_tmp
= NULL
;
240 struct batadv_hashtable
*hash
= bat_priv
->dat
.hash
;
246 index
= batadv_hash_dat(&ip
, hash
->size
);
247 head
= &hash
->table
[index
];
250 hlist_for_each_entry_rcu(dat_entry
, node
, head
, hash_entry
) {
251 if (dat_entry
->ip
!= ip
)
254 if (!atomic_inc_not_zero(&dat_entry
->refcount
))
257 dat_entry_tmp
= dat_entry
;
262 return dat_entry_tmp
;
266 * batadv_dat_entry_add - add a new dat entry or update it if already exists
267 * @bat_priv: the bat priv with all the soft interface information
268 * @ip: ipv4 to add/edit
269 * @mac_addr: mac address to assign to the given ipv4
271 static void batadv_dat_entry_add(struct batadv_priv
*bat_priv
, __be32 ip
,
274 struct batadv_dat_entry
*dat_entry
;
277 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip
);
278 /* if this entry is already known, just update it */
280 if (!batadv_compare_eth(dat_entry
->mac_addr
, mac_addr
))
281 memcpy(dat_entry
->mac_addr
, mac_addr
, ETH_ALEN
);
282 dat_entry
->last_update
= jiffies
;
283 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
284 "Entry updated: %pI4 %pM\n", &dat_entry
->ip
,
285 dat_entry
->mac_addr
);
289 dat_entry
= kmalloc(sizeof(*dat_entry
), GFP_ATOMIC
);
294 memcpy(dat_entry
->mac_addr
, mac_addr
, ETH_ALEN
);
295 dat_entry
->last_update
= jiffies
;
296 atomic_set(&dat_entry
->refcount
, 2);
298 hash_added
= batadv_hash_add(bat_priv
->dat
.hash
, batadv_compare_dat
,
299 batadv_hash_dat
, &dat_entry
->ip
,
300 &dat_entry
->hash_entry
);
302 if (unlikely(hash_added
!= 0)) {
303 /* remove the reference for the hash */
304 batadv_dat_entry_free_ref(dat_entry
);
308 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "New entry added: %pI4 %pM\n",
309 &dat_entry
->ip
, dat_entry
->mac_addr
);
313 batadv_dat_entry_free_ref(dat_entry
);
316 #ifdef CONFIG_BATMAN_ADV_DEBUG
319 * batadv_dbg_arp - print a debug message containing all the ARP packet details
320 * @bat_priv: the bat priv with all the soft interface information
323 * @hdr_size: size of the possible header before the ARP packet
324 * @msg: message to print together with the debugging information
326 static void batadv_dbg_arp(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
,
327 uint16_t type
, int hdr_size
, char *msg
)
329 struct batadv_unicast_4addr_packet
*unicast_4addr_packet
;
330 struct batadv_bcast_packet
*bcast_pkt
;
332 __be32 ip_src
, ip_dst
;
335 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "%s\n", msg
);
337 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
338 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
339 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
340 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
341 batadv_arp_hw_src(skb
, hdr_size
), &ip_src
,
342 batadv_arp_hw_dst(skb
, hdr_size
), &ip_dst
);
347 /* if the ARP packet is encapsulated in a batman packet, let's print
348 * some debug messages
350 unicast_4addr_packet
= (struct batadv_unicast_4addr_packet
*)skb
->data
;
352 switch (unicast_4addr_packet
->u
.header
.packet_type
) {
354 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
355 "* encapsulated within a UNICAST packet\n");
357 case BATADV_UNICAST_4ADDR
:
358 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
359 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
360 unicast_4addr_packet
->src
);
361 switch (unicast_4addr_packet
->subtype
) {
362 case BATADV_P_DAT_DHT_PUT
:
363 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DAT_DHT_PUT\n");
365 case BATADV_P_DAT_DHT_GET
:
366 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DAT_DHT_GET\n");
368 case BATADV_P_DAT_CACHE_REPLY
:
369 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
370 "* type: DAT_CACHE_REPLY\n");
373 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DATA\n");
376 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: Unknown (%u)!\n",
377 unicast_4addr_packet
->u
.header
.packet_type
);
381 bcast_pkt
= (struct batadv_bcast_packet
*)unicast_4addr_packet
;
382 orig_addr
= bcast_pkt
->orig
;
383 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
384 "* encapsulated within a BCAST packet (src: %pM)\n",
388 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
389 "* encapsulated within an unknown packet type (0x%x)\n",
390 unicast_4addr_packet
->u
.header
.packet_type
);
396 static void batadv_dbg_arp(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
,
397 uint16_t type
, int hdr_size
, char *msg
)
401 #endif /* CONFIG_BATMAN_ADV_DEBUG */
404 * batadv_is_orig_node_eligible - check whether a node can be a DHT candidate
405 * @res: the array with the already selected candidates
406 * @select: number of already selected candidates
407 * @tmp_max: address of the currently evaluated node
408 * @max: current round max address
409 * @last_max: address of the last selected candidate
410 * @candidate: orig_node under evaluation
411 * @max_orig_node: last selected candidate
413 * Returns true if the node has been elected as next candidate or false othrwise
415 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate
*res
,
416 int select
, batadv_dat_addr_t tmp_max
,
417 batadv_dat_addr_t max
,
418 batadv_dat_addr_t last_max
,
419 struct batadv_orig_node
*candidate
,
420 struct batadv_orig_node
*max_orig_node
)
425 /* Check if this node has already been selected... */
426 for (j
= 0; j
< select
; j
++)
427 if (res
[j
].orig_node
== candidate
)
429 /* ..and possibly skip it */
432 /* sanity check: has it already been selected? This should not happen */
433 if (tmp_max
> last_max
)
435 /* check if during this iteration an originator with a closer dht
436 * address has already been found
440 /* this is an hash collision with the temporary selected node. Choose
441 * the one with the lowest address
443 if ((tmp_max
== max
) &&
444 (batadv_compare_eth(candidate
->orig
, max_orig_node
->orig
) > 0))
453 * batadv_choose_next_candidate - select the next DHT candidate
454 * @bat_priv: the bat priv with all the soft interface information
455 * @cands: candidates array
456 * @select: number of candidates already present in the array
457 * @ip_key: key to look up in the DHT
458 * @last_max: pointer where the address of the selected candidate will be saved
460 static void batadv_choose_next_candidate(struct batadv_priv
*bat_priv
,
461 struct batadv_dat_candidate
*cands
,
462 int select
, batadv_dat_addr_t ip_key
,
463 batadv_dat_addr_t
*last_max
)
465 batadv_dat_addr_t max
= 0, tmp_max
= 0;
466 struct batadv_orig_node
*orig_node
, *max_orig_node
= NULL
;
467 struct batadv_hashtable
*hash
= bat_priv
->orig_hash
;
468 struct hlist_node
*node
;
469 struct hlist_head
*head
;
472 /* if no node is eligible as candidate, leave the candidate type as
475 cands
[select
].type
= BATADV_DAT_CANDIDATE_NOT_FOUND
;
477 /* iterate over the originator list and find the node with closest
478 * dat_address which has not been selected yet
480 for (i
= 0; i
< hash
->size
; i
++) {
481 head
= &hash
->table
[i
];
484 hlist_for_each_entry_rcu(orig_node
, node
, head
, hash_entry
) {
485 /* the dht space is a ring and addresses are unsigned */
486 tmp_max
= BATADV_DAT_ADDR_MAX
- orig_node
->dat_addr
+
489 if (!batadv_is_orig_node_eligible(cands
, select
,
491 *last_max
, orig_node
,
495 if (!atomic_inc_not_zero(&orig_node
->refcount
))
500 batadv_orig_node_free_ref(max_orig_node
);
501 max_orig_node
= orig_node
;
506 cands
[select
].type
= BATADV_DAT_CANDIDATE_ORIG
;
507 cands
[select
].orig_node
= max_orig_node
;
508 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
509 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
510 select
, max_orig_node
->orig
, max_orig_node
->dat_addr
,
517 * batadv_dat_select_candidates - selects the nodes which the DHT message has to
519 * @bat_priv: the bat priv with all the soft interface information
520 * @ip_dst: ipv4 to look up in the DHT
522 * An originator O is selected if and only if its DHT_ID value is one of three
523 * closest values (from the LEFT, with wrap around if needed) then the hash
524 * value of the key. ip_dst is the key.
526 * Returns the candidate array of size BATADV_DAT_CANDIDATE_NUM
528 static struct batadv_dat_candidate
*
529 batadv_dat_select_candidates(struct batadv_priv
*bat_priv
, __be32 ip_dst
)
532 batadv_dat_addr_t last_max
= BATADV_DAT_ADDR_MAX
, ip_key
;
533 struct batadv_dat_candidate
*res
;
535 if (!bat_priv
->orig_hash
)
538 res
= kmalloc(BATADV_DAT_CANDIDATES_NUM
* sizeof(*res
), GFP_ATOMIC
);
542 ip_key
= (batadv_dat_addr_t
)batadv_hash_dat(&ip_dst
,
543 BATADV_DAT_ADDR_MAX
);
545 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
546 "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst
,
549 for (select
= 0; select
< BATADV_DAT_CANDIDATES_NUM
; select
++)
550 batadv_choose_next_candidate(bat_priv
, res
, select
, ip_key
,
557 * batadv_dat_send_data - send a payload to the selected candidates
558 * @bat_priv: the bat priv with all the soft interface information
559 * @skb: payload to send
561 * @packet_subtype: unicast4addr packet subtype to use
563 * In this function the skb is copied by means of pskb_copy() and is sent as
564 * unicast packet to each of the selected candidates
566 * Returns true if the packet is sent to at least one candidate, false otherwise
568 static bool batadv_dat_send_data(struct batadv_priv
*bat_priv
,
569 struct sk_buff
*skb
, __be32 ip
,
575 struct batadv_neigh_node
*neigh_node
= NULL
;
576 struct sk_buff
*tmp_skb
;
577 struct batadv_dat_candidate
*cand
;
579 cand
= batadv_dat_select_candidates(bat_priv
, ip
);
583 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "DHT_SEND for %pI4\n", &ip
);
585 for (i
= 0; i
< BATADV_DAT_CANDIDATES_NUM
; i
++) {
586 if (cand
[i
].type
== BATADV_DAT_CANDIDATE_NOT_FOUND
)
589 neigh_node
= batadv_orig_node_get_router(cand
[i
].orig_node
);
593 tmp_skb
= pskb_copy(skb
, GFP_ATOMIC
);
594 if (!batadv_unicast_4addr_prepare_skb(bat_priv
, tmp_skb
,
601 send_status
= batadv_send_skb_packet(tmp_skb
,
602 neigh_node
->if_incoming
,
604 if (send_status
== NET_XMIT_SUCCESS
) {
605 /* count the sent packet */
606 switch (packet_subtype
) {
607 case BATADV_P_DAT_DHT_GET
:
608 batadv_inc_counter(bat_priv
,
609 BATADV_CNT_DAT_GET_TX
);
611 case BATADV_P_DAT_DHT_PUT
:
612 batadv_inc_counter(bat_priv
,
613 BATADV_CNT_DAT_PUT_TX
);
617 /* packet sent to a candidate: return true */
621 batadv_neigh_node_free_ref(neigh_node
);
623 batadv_orig_node_free_ref(cand
[i
].orig_node
);
632 * batadv_dat_hash_free - free the local DAT hash table
633 * @bat_priv: the bat priv with all the soft interface information
635 static void batadv_dat_hash_free(struct batadv_priv
*bat_priv
)
637 if (!bat_priv
->dat
.hash
)
640 __batadv_dat_purge(bat_priv
, NULL
);
642 batadv_hash_destroy(bat_priv
->dat
.hash
);
644 bat_priv
->dat
.hash
= NULL
;
648 * batadv_dat_init - initialise the DAT internals
649 * @bat_priv: the bat priv with all the soft interface information
651 int batadv_dat_init(struct batadv_priv
*bat_priv
)
653 if (bat_priv
->dat
.hash
)
656 bat_priv
->dat
.hash
= batadv_hash_new(1024);
658 if (!bat_priv
->dat
.hash
)
661 batadv_dat_start_timer(bat_priv
);
667 * batadv_dat_free - free the DAT internals
668 * @bat_priv: the bat priv with all the soft interface information
670 void batadv_dat_free(struct batadv_priv
*bat_priv
)
672 cancel_delayed_work_sync(&bat_priv
->dat
.work
);
674 batadv_dat_hash_free(bat_priv
);
678 * batadv_dat_cache_seq_print_text - print the local DAT hash table
679 * @seq: seq file to print on
682 int batadv_dat_cache_seq_print_text(struct seq_file
*seq
, void *offset
)
684 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
685 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
686 struct batadv_hashtable
*hash
= bat_priv
->dat
.hash
;
687 struct batadv_dat_entry
*dat_entry
;
688 struct batadv_hard_iface
*primary_if
;
689 struct hlist_node
*node
;
690 struct hlist_head
*head
;
691 unsigned long last_seen_jiffies
;
692 int last_seen_msecs
, last_seen_secs
, last_seen_mins
;
695 primary_if
= batadv_seq_print_text_primary_if_get(seq
);
699 seq_printf(seq
, "Distributed ARP Table (%s):\n", net_dev
->name
);
700 seq_printf(seq
, " %-7s %-13s %5s\n", "IPv4", "MAC",
703 for (i
= 0; i
< hash
->size
; i
++) {
704 head
= &hash
->table
[i
];
707 hlist_for_each_entry_rcu(dat_entry
, node
, head
, hash_entry
) {
708 last_seen_jiffies
= jiffies
- dat_entry
->last_update
;
709 last_seen_msecs
= jiffies_to_msecs(last_seen_jiffies
);
710 last_seen_mins
= last_seen_msecs
/ 60000;
711 last_seen_msecs
= last_seen_msecs
% 60000;
712 last_seen_secs
= last_seen_msecs
/ 1000;
714 seq_printf(seq
, " * %15pI4 %14pM %6i:%02i\n",
715 &dat_entry
->ip
, dat_entry
->mac_addr
,
716 last_seen_mins
, last_seen_secs
);
723 batadv_hardif_free_ref(primary_if
);
728 * batadv_arp_get_type - parse an ARP packet and gets the type
729 * @bat_priv: the bat priv with all the soft interface information
730 * @skb: packet to analyse
731 * @hdr_size: size of the possible header before the ARP packet in the skb
733 * Returns the ARP type if the skb contains a valid ARP packet, 0 otherwise
735 static uint16_t batadv_arp_get_type(struct batadv_priv
*bat_priv
,
736 struct sk_buff
*skb
, int hdr_size
)
738 struct arphdr
*arphdr
;
739 struct ethhdr
*ethhdr
;
740 __be32 ip_src
, ip_dst
;
743 /* pull the ethernet header */
744 if (unlikely(!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
)))
747 ethhdr
= (struct ethhdr
*)(skb
->data
+ hdr_size
);
749 if (ethhdr
->h_proto
!= htons(ETH_P_ARP
))
752 /* pull the ARP payload */
753 if (unlikely(!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
+
754 arp_hdr_len(skb
->dev
))))
757 arphdr
= (struct arphdr
*)(skb
->data
+ hdr_size
+ ETH_HLEN
);
759 /* Check whether the ARP packet carries a valid
762 if (arphdr
->ar_hrd
!= htons(ARPHRD_ETHER
))
765 if (arphdr
->ar_pro
!= htons(ETH_P_IP
))
768 if (arphdr
->ar_hln
!= ETH_ALEN
)
771 if (arphdr
->ar_pln
!= 4)
774 /* Check for bad reply/request. If the ARP message is not sane, DAT
775 * will simply ignore it
777 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
778 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
779 if (ipv4_is_loopback(ip_src
) || ipv4_is_multicast(ip_src
) ||
780 ipv4_is_loopback(ip_dst
) || ipv4_is_multicast(ip_dst
))
783 type
= ntohs(arphdr
->ar_op
);
789 * batadv_dat_snoop_outgoing_arp_request - snoop the ARP request and try to
791 * @bat_priv: the bat priv with all the soft interface information
792 * @skb: packet to check
794 * Returns true if the message has been sent to the dht candidates, false
795 * otherwise. In case of true the message has to be enqueued to permit the
798 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv
*bat_priv
,
802 __be32 ip_dst
, ip_src
;
805 struct batadv_dat_entry
*dat_entry
= NULL
;
806 struct sk_buff
*skb_new
;
807 struct batadv_hard_iface
*primary_if
= NULL
;
809 if (!atomic_read(&bat_priv
->distributed_arp_table
))
812 type
= batadv_arp_get_type(bat_priv
, skb
, 0);
813 /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
814 * message to the selected DHT candidates
816 if (type
!= ARPOP_REQUEST
)
819 batadv_dbg_arp(bat_priv
, skb
, type
, 0, "Parsing outgoing ARP REQUEST");
821 ip_src
= batadv_arp_ip_src(skb
, 0);
822 hw_src
= batadv_arp_hw_src(skb
, 0);
823 ip_dst
= batadv_arp_ip_dst(skb
, 0);
825 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
827 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
);
829 primary_if
= batadv_primary_if_get_selected(bat_priv
);
833 skb_new
= arp_create(ARPOP_REPLY
, ETH_P_ARP
, ip_src
,
834 primary_if
->soft_iface
, ip_dst
, hw_src
,
835 dat_entry
->mac_addr
, hw_src
);
839 skb_reset_mac_header(skb_new
);
840 skb_new
->protocol
= eth_type_trans(skb_new
,
841 primary_if
->soft_iface
);
842 bat_priv
->stats
.rx_packets
++;
843 bat_priv
->stats
.rx_bytes
+= skb
->len
+ ETH_HLEN
;
844 primary_if
->soft_iface
->last_rx
= jiffies
;
847 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "ARP request replied locally\n");
850 /* Send the request on the DHT */
851 ret
= batadv_dat_send_data(bat_priv
, skb
, ip_dst
,
852 BATADV_P_DAT_DHT_GET
);
856 batadv_dat_entry_free_ref(dat_entry
);
858 batadv_hardif_free_ref(primary_if
);
863 * batadv_dat_snoop_incoming_arp_request - snoop the ARP request and try to
864 * answer using the local DAT storage
865 * @bat_priv: the bat priv with all the soft interface information
866 * @skb: packet to check
867 * @hdr_size: size of the encapsulation header
869 * Returns true if the request has been answered, false otherwise
871 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv
*bat_priv
,
872 struct sk_buff
*skb
, int hdr_size
)
875 __be32 ip_src
, ip_dst
;
877 struct sk_buff
*skb_new
;
878 struct batadv_hard_iface
*primary_if
= NULL
;
879 struct batadv_dat_entry
*dat_entry
= NULL
;
883 if (!atomic_read(&bat_priv
->distributed_arp_table
))
886 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
887 if (type
!= ARPOP_REQUEST
)
890 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
891 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
892 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
894 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
895 "Parsing incoming ARP REQUEST");
897 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
899 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
);
903 primary_if
= batadv_primary_if_get_selected(bat_priv
);
907 skb_new
= arp_create(ARPOP_REPLY
, ETH_P_ARP
, ip_src
,
908 primary_if
->soft_iface
, ip_dst
, hw_src
,
909 dat_entry
->mac_addr
, hw_src
);
914 /* to preserve backwards compatibility, here the node has to answer
915 * using the same packet type it received for the request. This is due
916 * to that if a node is not using the 4addr packet format it may not
919 if (hdr_size
== sizeof(struct batadv_unicast_4addr_packet
))
920 err
= batadv_unicast_4addr_send_skb(bat_priv
, skb_new
,
921 BATADV_P_DAT_CACHE_REPLY
);
923 err
= batadv_unicast_send_skb(bat_priv
, skb_new
);
926 batadv_inc_counter(bat_priv
, BATADV_CNT_DAT_CACHED_REPLY_TX
);
931 batadv_dat_entry_free_ref(dat_entry
);
933 batadv_hardif_free_ref(primary_if
);
940 * batadv_dat_snoop_outgoing_arp_reply - snoop the ARP reply and fill the DHT
941 * @bat_priv: the bat priv with all the soft interface information
942 * @skb: packet to check
944 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv
*bat_priv
,
948 __be32 ip_src
, ip_dst
;
949 uint8_t *hw_src
, *hw_dst
;
951 if (!atomic_read(&bat_priv
->distributed_arp_table
))
954 type
= batadv_arp_get_type(bat_priv
, skb
, 0);
955 if (type
!= ARPOP_REPLY
)
958 batadv_dbg_arp(bat_priv
, skb
, type
, 0, "Parsing outgoing ARP REPLY");
960 hw_src
= batadv_arp_hw_src(skb
, 0);
961 ip_src
= batadv_arp_ip_src(skb
, 0);
962 hw_dst
= batadv_arp_hw_dst(skb
, 0);
963 ip_dst
= batadv_arp_ip_dst(skb
, 0);
965 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
966 batadv_dat_entry_add(bat_priv
, ip_dst
, hw_dst
);
968 /* Send the ARP reply to the candidates for both the IP addresses that
969 * the node got within the ARP reply
971 batadv_dat_send_data(bat_priv
, skb
, ip_src
, BATADV_P_DAT_DHT_PUT
);
972 batadv_dat_send_data(bat_priv
, skb
, ip_dst
, BATADV_P_DAT_DHT_PUT
);
975 * batadv_dat_snoop_incoming_arp_reply - snoop the ARP reply and fill the local
977 * @bat_priv: the bat priv with all the soft interface information
978 * @skb: packet to check
979 * @hdr_size: siaze of the encapsulation header
981 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv
*bat_priv
,
982 struct sk_buff
*skb
, int hdr_size
)
985 __be32 ip_src
, ip_dst
;
986 uint8_t *hw_src
, *hw_dst
;
989 if (!atomic_read(&bat_priv
->distributed_arp_table
))
992 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
993 if (type
!= ARPOP_REPLY
)
996 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
997 "Parsing incoming ARP REPLY");
999 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
1000 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
1001 hw_dst
= batadv_arp_hw_dst(skb
, hdr_size
);
1002 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
1004 /* Update our internal cache with both the IP addresses the node got
1005 * within the ARP reply
1007 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
1008 batadv_dat_entry_add(bat_priv
, ip_dst
, hw_dst
);
1010 /* if this REPLY is directed to a client of mine, let's deliver the
1011 * packet to the interface
1013 ret
= !batadv_is_my_client(bat_priv
, hw_dst
);
1015 /* if ret == false -> packet has to be delivered to the interface */
1020 * batadv_dat_drop_broadcast_packet - check if an ARP request has to be dropped
1021 * (because the node has already got the reply via DAT) or not
1022 * @bat_priv: the bat priv with all the soft interface information
1023 * @forw_packet: the broadcast packet
1025 * Returns true if the node can drop the packet, false otherwise
1027 bool batadv_dat_drop_broadcast_packet(struct batadv_priv
*bat_priv
,
1028 struct batadv_forw_packet
*forw_packet
)
1032 struct batadv_dat_entry
*dat_entry
= NULL
;
1034 const size_t bcast_len
= sizeof(struct batadv_bcast_packet
);
1036 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1039 /* If this packet is an ARP_REQUEST and the node already has the
1040 * information that it is going to ask, then the packet can be dropped
1042 if (forw_packet
->num_packets
)
1045 type
= batadv_arp_get_type(bat_priv
, forw_packet
->skb
, bcast_len
);
1046 if (type
!= ARPOP_REQUEST
)
1049 ip_dst
= batadv_arp_ip_dst(forw_packet
->skb
, bcast_len
);
1050 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
);
1051 /* check if the node already got this entry */
1053 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
1054 "ARP Request for %pI4: fallback\n", &ip_dst
);
1058 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
1059 "ARP Request for %pI4: fallback prevented\n", &ip_dst
);
1064 batadv_dat_entry_free_ref(dat_entry
);