1 /* Copyright (C) 2011-2013 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_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_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
))
106 hlist_del_rcu(&dat_entry
->hash_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 batadv_dat_entry
*dat_entry
, *dat_entry_tmp
= NULL
;
239 struct batadv_hashtable
*hash
= bat_priv
->dat
.hash
;
245 index
= batadv_hash_dat(&ip
, hash
->size
);
246 head
= &hash
->table
[index
];
249 hlist_for_each_entry_rcu(dat_entry
, head
, hash_entry
) {
250 if (dat_entry
->ip
!= ip
)
253 if (!atomic_inc_not_zero(&dat_entry
->refcount
))
256 dat_entry_tmp
= dat_entry
;
261 return dat_entry_tmp
;
265 * batadv_dat_entry_add - add a new dat entry or update it if already exists
266 * @bat_priv: the bat priv with all the soft interface information
267 * @ip: ipv4 to add/edit
268 * @mac_addr: mac address to assign to the given ipv4
270 static void batadv_dat_entry_add(struct batadv_priv
*bat_priv
, __be32 ip
,
273 struct batadv_dat_entry
*dat_entry
;
276 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip
);
277 /* if this entry is already known, just update it */
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\n", &dat_entry
->ip
,
284 dat_entry
->mac_addr
);
288 dat_entry
= kmalloc(sizeof(*dat_entry
), GFP_ATOMIC
);
293 memcpy(dat_entry
->mac_addr
, mac_addr
, ETH_ALEN
);
294 dat_entry
->last_update
= jiffies
;
295 atomic_set(&dat_entry
->refcount
, 2);
297 hash_added
= batadv_hash_add(bat_priv
->dat
.hash
, batadv_compare_dat
,
298 batadv_hash_dat
, &dat_entry
->ip
,
299 &dat_entry
->hash_entry
);
301 if (unlikely(hash_added
!= 0)) {
302 /* remove the reference for the hash */
303 batadv_dat_entry_free_ref(dat_entry
);
307 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "New entry added: %pI4 %pM\n",
308 &dat_entry
->ip
, dat_entry
->mac_addr
);
312 batadv_dat_entry_free_ref(dat_entry
);
315 #ifdef CONFIG_BATMAN_ADV_DEBUG
318 * batadv_dbg_arp - print a debug message containing all the ARP packet details
319 * @bat_priv: the bat priv with all the soft interface information
322 * @hdr_size: size of the possible header before the ARP packet
323 * @msg: message to print together with the debugging information
325 static void batadv_dbg_arp(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
,
326 uint16_t type
, int hdr_size
, char *msg
)
328 struct batadv_unicast_4addr_packet
*unicast_4addr_packet
;
329 struct batadv_bcast_packet
*bcast_pkt
;
331 __be32 ip_src
, ip_dst
;
334 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "%s\n", msg
);
336 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
337 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
338 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
339 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
340 batadv_arp_hw_src(skb
, hdr_size
), &ip_src
,
341 batadv_arp_hw_dst(skb
, hdr_size
), &ip_dst
);
346 /* if the ARP packet is encapsulated in a batman packet, let's print
347 * some debug messages
349 unicast_4addr_packet
= (struct batadv_unicast_4addr_packet
*)skb
->data
;
351 switch (unicast_4addr_packet
->u
.header
.packet_type
) {
353 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
354 "* encapsulated within a UNICAST packet\n");
356 case BATADV_UNICAST_4ADDR
:
357 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
358 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
359 unicast_4addr_packet
->src
);
360 switch (unicast_4addr_packet
->subtype
) {
361 case BATADV_P_DAT_DHT_PUT
:
362 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DAT_DHT_PUT\n");
364 case BATADV_P_DAT_DHT_GET
:
365 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DAT_DHT_GET\n");
367 case BATADV_P_DAT_CACHE_REPLY
:
368 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
369 "* type: DAT_CACHE_REPLY\n");
372 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DATA\n");
375 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: Unknown (%u)!\n",
376 unicast_4addr_packet
->u
.header
.packet_type
);
380 bcast_pkt
= (struct batadv_bcast_packet
*)unicast_4addr_packet
;
381 orig_addr
= bcast_pkt
->orig
;
382 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
383 "* encapsulated within a BCAST packet (src: %pM)\n",
387 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
388 "* encapsulated within an unknown packet type (0x%x)\n",
389 unicast_4addr_packet
->u
.header
.packet_type
);
395 static void batadv_dbg_arp(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
,
396 uint16_t type
, int hdr_size
, char *msg
)
400 #endif /* CONFIG_BATMAN_ADV_DEBUG */
403 * batadv_is_orig_node_eligible - check whether a node can be a DHT candidate
404 * @res: the array with the already selected candidates
405 * @select: number of already selected candidates
406 * @tmp_max: address of the currently evaluated node
407 * @max: current round max address
408 * @last_max: address of the last selected candidate
409 * @candidate: orig_node under evaluation
410 * @max_orig_node: last selected candidate
412 * Returns true if the node has been elected as next candidate or false othrwise
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
)
424 /* Check if this node has already been selected... */
425 for (j
= 0; j
< select
; j
++)
426 if (res
[j
].orig_node
== candidate
)
428 /* ..and possibly skip it */
431 /* sanity check: has it already been selected? This should not happen */
432 if (tmp_max
> last_max
)
434 /* check if during this iteration an originator with a closer dht
435 * address has already been found
439 /* this is an hash collision with the temporary selected node. Choose
440 * the one with the lowest address
442 if ((tmp_max
== max
) && max_orig_node
&&
443 (batadv_compare_eth(candidate
->orig
, max_orig_node
->orig
) > 0))
452 * batadv_choose_next_candidate - select the next DHT candidate
453 * @bat_priv: the bat priv with all the soft interface information
454 * @cands: candidates array
455 * @select: number of candidates already present in the array
456 * @ip_key: key to look up in the DHT
457 * @last_max: pointer where the address of the selected candidate will be saved
459 static void batadv_choose_next_candidate(struct batadv_priv
*bat_priv
,
460 struct batadv_dat_candidate
*cands
,
461 int select
, batadv_dat_addr_t ip_key
,
462 batadv_dat_addr_t
*last_max
)
464 batadv_dat_addr_t max
= 0, tmp_max
= 0;
465 struct batadv_orig_node
*orig_node
, *max_orig_node
= NULL
;
466 struct batadv_hashtable
*hash
= bat_priv
->orig_hash
;
467 struct hlist_head
*head
;
470 /* if no node is eligible as candidate, leave the candidate type as
473 cands
[select
].type
= BATADV_DAT_CANDIDATE_NOT_FOUND
;
475 /* iterate over the originator list and find the node with closest
476 * dat_address which has not been selected yet
478 for (i
= 0; i
< hash
->size
; i
++) {
479 head
= &hash
->table
[i
];
482 hlist_for_each_entry_rcu(orig_node
, head
, hash_entry
) {
483 /* the dht space is a ring and addresses are unsigned */
484 tmp_max
= BATADV_DAT_ADDR_MAX
- orig_node
->dat_addr
+
487 if (!batadv_is_orig_node_eligible(cands
, select
,
489 *last_max
, orig_node
,
493 if (!atomic_inc_not_zero(&orig_node
->refcount
))
498 batadv_orig_node_free_ref(max_orig_node
);
499 max_orig_node
= orig_node
;
504 cands
[select
].type
= BATADV_DAT_CANDIDATE_ORIG
;
505 cands
[select
].orig_node
= max_orig_node
;
506 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
507 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
508 select
, max_orig_node
->orig
, max_orig_node
->dat_addr
,
515 * batadv_dat_select_candidates - selects the nodes which the DHT message has to
517 * @bat_priv: the bat priv with all the soft interface information
518 * @ip_dst: ipv4 to look up in the DHT
520 * An originator O is selected if and only if its DHT_ID value is one of three
521 * closest values (from the LEFT, with wrap around if needed) then the hash
522 * value of the key. ip_dst is the key.
524 * Returns the candidate array of size BATADV_DAT_CANDIDATE_NUM
526 static struct batadv_dat_candidate
*
527 batadv_dat_select_candidates(struct batadv_priv
*bat_priv
, __be32 ip_dst
)
530 batadv_dat_addr_t last_max
= BATADV_DAT_ADDR_MAX
, ip_key
;
531 struct batadv_dat_candidate
*res
;
533 if (!bat_priv
->orig_hash
)
536 res
= kmalloc(BATADV_DAT_CANDIDATES_NUM
* sizeof(*res
), GFP_ATOMIC
);
540 ip_key
= (batadv_dat_addr_t
)batadv_hash_dat(&ip_dst
,
541 BATADV_DAT_ADDR_MAX
);
543 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
544 "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst
,
547 for (select
= 0; select
< BATADV_DAT_CANDIDATES_NUM
; select
++)
548 batadv_choose_next_candidate(bat_priv
, res
, select
, ip_key
,
555 * batadv_dat_send_data - send a payload to the selected candidates
556 * @bat_priv: the bat priv with all the soft interface information
557 * @skb: payload to send
559 * @packet_subtype: unicast4addr packet subtype to use
561 * In this function the skb is copied by means of pskb_copy() and is sent as
562 * unicast packet to each of the selected candidates
564 * Returns true if the packet is sent to at least one candidate, false otherwise
566 static bool batadv_dat_send_data(struct batadv_priv
*bat_priv
,
567 struct sk_buff
*skb
, __be32 ip
,
573 struct batadv_neigh_node
*neigh_node
= NULL
;
574 struct sk_buff
*tmp_skb
;
575 struct batadv_dat_candidate
*cand
;
577 cand
= batadv_dat_select_candidates(bat_priv
, ip
);
581 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "DHT_SEND for %pI4\n", &ip
);
583 for (i
= 0; i
< BATADV_DAT_CANDIDATES_NUM
; i
++) {
584 if (cand
[i
].type
== BATADV_DAT_CANDIDATE_NOT_FOUND
)
587 neigh_node
= batadv_orig_node_get_router(cand
[i
].orig_node
);
591 tmp_skb
= pskb_copy(skb
, GFP_ATOMIC
);
592 if (!batadv_unicast_4addr_prepare_skb(bat_priv
, tmp_skb
,
599 send_status
= batadv_send_skb_packet(tmp_skb
,
600 neigh_node
->if_incoming
,
602 if (send_status
== NET_XMIT_SUCCESS
) {
603 /* count the sent packet */
604 switch (packet_subtype
) {
605 case BATADV_P_DAT_DHT_GET
:
606 batadv_inc_counter(bat_priv
,
607 BATADV_CNT_DAT_GET_TX
);
609 case BATADV_P_DAT_DHT_PUT
:
610 batadv_inc_counter(bat_priv
,
611 BATADV_CNT_DAT_PUT_TX
);
615 /* packet sent to a candidate: return true */
619 batadv_neigh_node_free_ref(neigh_node
);
621 batadv_orig_node_free_ref(cand
[i
].orig_node
);
630 * batadv_dat_hash_free - free the local DAT hash table
631 * @bat_priv: the bat priv with all the soft interface information
633 static void batadv_dat_hash_free(struct batadv_priv
*bat_priv
)
635 if (!bat_priv
->dat
.hash
)
638 __batadv_dat_purge(bat_priv
, NULL
);
640 batadv_hash_destroy(bat_priv
->dat
.hash
);
642 bat_priv
->dat
.hash
= NULL
;
646 * batadv_dat_init - initialise the DAT internals
647 * @bat_priv: the bat priv with all the soft interface information
649 int batadv_dat_init(struct batadv_priv
*bat_priv
)
651 if (bat_priv
->dat
.hash
)
654 bat_priv
->dat
.hash
= batadv_hash_new(1024);
656 if (!bat_priv
->dat
.hash
)
659 batadv_dat_start_timer(bat_priv
);
665 * batadv_dat_free - free the DAT internals
666 * @bat_priv: the bat priv with all the soft interface information
668 void batadv_dat_free(struct batadv_priv
*bat_priv
)
670 cancel_delayed_work_sync(&bat_priv
->dat
.work
);
672 batadv_dat_hash_free(bat_priv
);
676 * batadv_dat_cache_seq_print_text - print the local DAT hash table
677 * @seq: seq file to print on
680 int batadv_dat_cache_seq_print_text(struct seq_file
*seq
, void *offset
)
682 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
683 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
684 struct batadv_hashtable
*hash
= bat_priv
->dat
.hash
;
685 struct batadv_dat_entry
*dat_entry
;
686 struct batadv_hard_iface
*primary_if
;
687 struct hlist_head
*head
;
688 unsigned long last_seen_jiffies
;
689 int last_seen_msecs
, last_seen_secs
, last_seen_mins
;
692 primary_if
= batadv_seq_print_text_primary_if_get(seq
);
696 seq_printf(seq
, "Distributed ARP Table (%s):\n", net_dev
->name
);
697 seq_printf(seq
, " %-7s %-13s %5s\n", "IPv4", "MAC",
700 for (i
= 0; i
< hash
->size
; i
++) {
701 head
= &hash
->table
[i
];
704 hlist_for_each_entry_rcu(dat_entry
, head
, hash_entry
) {
705 last_seen_jiffies
= jiffies
- dat_entry
->last_update
;
706 last_seen_msecs
= jiffies_to_msecs(last_seen_jiffies
);
707 last_seen_mins
= last_seen_msecs
/ 60000;
708 last_seen_msecs
= last_seen_msecs
% 60000;
709 last_seen_secs
= last_seen_msecs
/ 1000;
711 seq_printf(seq
, " * %15pI4 %14pM %6i:%02i\n",
712 &dat_entry
->ip
, dat_entry
->mac_addr
,
713 last_seen_mins
, last_seen_secs
);
720 batadv_hardif_free_ref(primary_if
);
725 * batadv_arp_get_type - parse an ARP packet and gets the type
726 * @bat_priv: the bat priv with all the soft interface information
727 * @skb: packet to analyse
728 * @hdr_size: size of the possible header before the ARP packet in the skb
730 * Returns the ARP type if the skb contains a valid ARP packet, 0 otherwise
732 static uint16_t batadv_arp_get_type(struct batadv_priv
*bat_priv
,
733 struct sk_buff
*skb
, int hdr_size
)
735 struct arphdr
*arphdr
;
736 struct ethhdr
*ethhdr
;
737 __be32 ip_src
, ip_dst
;
738 uint8_t *hw_src
, *hw_dst
;
741 /* pull the ethernet header */
742 if (unlikely(!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
)))
745 ethhdr
= (struct ethhdr
*)(skb
->data
+ hdr_size
);
747 if (ethhdr
->h_proto
!= htons(ETH_P_ARP
))
750 /* pull the ARP payload */
751 if (unlikely(!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
+
752 arp_hdr_len(skb
->dev
))))
755 arphdr
= (struct arphdr
*)(skb
->data
+ hdr_size
+ ETH_HLEN
);
757 /* Check whether the ARP packet carries a valid
760 if (arphdr
->ar_hrd
!= htons(ARPHRD_ETHER
))
763 if (arphdr
->ar_pro
!= htons(ETH_P_IP
))
766 if (arphdr
->ar_hln
!= ETH_ALEN
)
769 if (arphdr
->ar_pln
!= 4)
772 /* Check for bad reply/request. If the ARP message is not sane, DAT
773 * will simply ignore it
775 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
776 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
777 if (ipv4_is_loopback(ip_src
) || ipv4_is_multicast(ip_src
) ||
778 ipv4_is_loopback(ip_dst
) || ipv4_is_multicast(ip_dst
) ||
779 ipv4_is_zeronet(ip_src
) || ipv4_is_lbcast(ip_src
) ||
780 ipv4_is_zeronet(ip_dst
) || ipv4_is_lbcast(ip_dst
))
783 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
784 if (is_zero_ether_addr(hw_src
) || is_multicast_ether_addr(hw_src
))
787 /* we don't care about the destination MAC address in ARP requests */
788 if (arphdr
->ar_op
!= htons(ARPOP_REQUEST
)) {
789 hw_dst
= batadv_arp_hw_dst(skb
, hdr_size
);
790 if (is_zero_ether_addr(hw_dst
) ||
791 is_multicast_ether_addr(hw_dst
))
795 type
= ntohs(arphdr
->ar_op
);
801 * batadv_dat_snoop_outgoing_arp_request - snoop the ARP request and try to
803 * @bat_priv: the bat priv with all the soft interface information
804 * @skb: packet to check
806 * Returns true if the message has been sent to the dht candidates, false
807 * otherwise. In case of true the message has to be enqueued to permit the
810 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv
*bat_priv
,
814 __be32 ip_dst
, ip_src
;
817 struct batadv_dat_entry
*dat_entry
= NULL
;
818 struct sk_buff
*skb_new
;
820 if (!atomic_read(&bat_priv
->distributed_arp_table
))
823 type
= batadv_arp_get_type(bat_priv
, skb
, 0);
824 /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
825 * message to the selected DHT candidates
827 if (type
!= ARPOP_REQUEST
)
830 batadv_dbg_arp(bat_priv
, skb
, type
, 0, "Parsing outgoing ARP REQUEST");
832 ip_src
= batadv_arp_ip_src(skb
, 0);
833 hw_src
= batadv_arp_hw_src(skb
, 0);
834 ip_dst
= batadv_arp_ip_dst(skb
, 0);
836 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
838 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
);
840 /* If the ARP request is destined for a local client the local
841 * client will answer itself. DAT would only generate a
844 * Moreover, if the soft-interface is enslaved into a bridge, an
845 * additional DAT answer may trigger kernel warnings about
846 * a packet coming from the wrong port.
848 if (batadv_is_my_client(bat_priv
, dat_entry
->mac_addr
)) {
853 skb_new
= arp_create(ARPOP_REPLY
, ETH_P_ARP
, ip_src
,
854 bat_priv
->soft_iface
, ip_dst
, hw_src
,
855 dat_entry
->mac_addr
, hw_src
);
859 skb_reset_mac_header(skb_new
);
860 skb_new
->protocol
= eth_type_trans(skb_new
,
861 bat_priv
->soft_iface
);
862 bat_priv
->stats
.rx_packets
++;
863 bat_priv
->stats
.rx_bytes
+= skb
->len
+ ETH_HLEN
;
864 bat_priv
->soft_iface
->last_rx
= jiffies
;
867 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "ARP request replied locally\n");
870 /* Send the request on the DHT */
871 ret
= batadv_dat_send_data(bat_priv
, skb
, ip_dst
,
872 BATADV_P_DAT_DHT_GET
);
876 batadv_dat_entry_free_ref(dat_entry
);
881 * batadv_dat_snoop_incoming_arp_request - snoop the ARP request and try to
882 * answer using the local DAT storage
883 * @bat_priv: the bat priv with all the soft interface information
884 * @skb: packet to check
885 * @hdr_size: size of the encapsulation header
887 * Returns true if the request has been answered, false otherwise
889 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv
*bat_priv
,
890 struct sk_buff
*skb
, int hdr_size
)
893 __be32 ip_src
, ip_dst
;
895 struct sk_buff
*skb_new
;
896 struct batadv_dat_entry
*dat_entry
= NULL
;
900 if (!atomic_read(&bat_priv
->distributed_arp_table
))
903 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
904 if (type
!= ARPOP_REQUEST
)
907 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
908 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
909 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
911 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
912 "Parsing incoming ARP REQUEST");
914 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
916 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
);
920 skb_new
= arp_create(ARPOP_REPLY
, ETH_P_ARP
, ip_src
,
921 bat_priv
->soft_iface
, ip_dst
, hw_src
,
922 dat_entry
->mac_addr
, hw_src
);
927 /* to preserve backwards compatibility, here the node has to answer
928 * using the same packet type it received for the request. This is due
929 * to that if a node is not using the 4addr packet format it may not
932 if (hdr_size
== sizeof(struct batadv_unicast_4addr_packet
))
933 err
= batadv_unicast_4addr_send_skb(bat_priv
, skb_new
,
934 BATADV_P_DAT_CACHE_REPLY
);
936 err
= batadv_unicast_send_skb(bat_priv
, skb_new
);
939 batadv_inc_counter(bat_priv
, BATADV_CNT_DAT_CACHED_REPLY_TX
);
944 batadv_dat_entry_free_ref(dat_entry
);
951 * batadv_dat_snoop_outgoing_arp_reply - snoop the ARP reply and fill the DHT
952 * @bat_priv: the bat priv with all the soft interface information
953 * @skb: packet to check
955 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv
*bat_priv
,
959 __be32 ip_src
, ip_dst
;
960 uint8_t *hw_src
, *hw_dst
;
962 if (!atomic_read(&bat_priv
->distributed_arp_table
))
965 type
= batadv_arp_get_type(bat_priv
, skb
, 0);
966 if (type
!= ARPOP_REPLY
)
969 batadv_dbg_arp(bat_priv
, skb
, type
, 0, "Parsing outgoing ARP REPLY");
971 hw_src
= batadv_arp_hw_src(skb
, 0);
972 ip_src
= batadv_arp_ip_src(skb
, 0);
973 hw_dst
= batadv_arp_hw_dst(skb
, 0);
974 ip_dst
= batadv_arp_ip_dst(skb
, 0);
976 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
977 batadv_dat_entry_add(bat_priv
, ip_dst
, hw_dst
);
979 /* Send the ARP reply to the candidates for both the IP addresses that
980 * the node got within the ARP reply
982 batadv_dat_send_data(bat_priv
, skb
, ip_src
, BATADV_P_DAT_DHT_PUT
);
983 batadv_dat_send_data(bat_priv
, skb
, ip_dst
, BATADV_P_DAT_DHT_PUT
);
986 * batadv_dat_snoop_incoming_arp_reply - snoop the ARP reply and fill the local
988 * @bat_priv: the bat priv with all the soft interface information
989 * @skb: packet to check
990 * @hdr_size: siaze of the encapsulation header
992 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv
*bat_priv
,
993 struct sk_buff
*skb
, int hdr_size
)
996 __be32 ip_src
, ip_dst
;
997 uint8_t *hw_src
, *hw_dst
;
1000 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1003 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
1004 if (type
!= ARPOP_REPLY
)
1007 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
1008 "Parsing incoming ARP REPLY");
1010 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
1011 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
1012 hw_dst
= batadv_arp_hw_dst(skb
, hdr_size
);
1013 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
1015 /* Update our internal cache with both the IP addresses the node got
1016 * within the ARP reply
1018 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
);
1019 batadv_dat_entry_add(bat_priv
, ip_dst
, hw_dst
);
1021 /* if this REPLY is directed to a client of mine, let's deliver the
1022 * packet to the interface
1024 ret
= !batadv_is_my_client(bat_priv
, hw_dst
);
1028 /* if ret == false -> packet has to be delivered to the interface */
1033 * batadv_dat_drop_broadcast_packet - check if an ARP request has to be dropped
1034 * (because the node has already got the reply via DAT) or not
1035 * @bat_priv: the bat priv with all the soft interface information
1036 * @forw_packet: the broadcast packet
1038 * Returns true if the node can drop the packet, false otherwise
1040 bool batadv_dat_drop_broadcast_packet(struct batadv_priv
*bat_priv
,
1041 struct batadv_forw_packet
*forw_packet
)
1045 struct batadv_dat_entry
*dat_entry
= NULL
;
1047 const size_t bcast_len
= sizeof(struct batadv_bcast_packet
);
1049 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1052 /* If this packet is an ARP_REQUEST and the node already has the
1053 * information that it is going to ask, then the packet can be dropped
1055 if (forw_packet
->num_packets
)
1058 type
= batadv_arp_get_type(bat_priv
, forw_packet
->skb
, bcast_len
);
1059 if (type
!= ARPOP_REQUEST
)
1062 ip_dst
= batadv_arp_ip_dst(forw_packet
->skb
, bcast_len
);
1063 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
);
1064 /* check if the node already got this entry */
1066 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
1067 "ARP Request for %pI4: fallback\n", &ip_dst
);
1071 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
1072 "ARP Request for %pI4: fallback prevented\n", &ip_dst
);
1077 batadv_dat_entry_free_ref(dat_entry
);