1 /* Copyright (C) 2011-2016 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, see <http://www.gnu.org/licenses/>.
18 #include "distributed-arp-table.h"
21 #include <linux/atomic.h>
22 #include <linux/bitops.h>
23 #include <linux/byteorder/generic.h>
24 #include <linux/errno.h>
25 #include <linux/etherdevice.h>
27 #include <linux/if_arp.h>
28 #include <linux/if_ether.h>
29 #include <linux/if_vlan.h>
31 #include <linux/jiffies.h>
32 #include <linux/kernel.h>
33 #include <linux/kref.h>
34 #include <linux/list.h>
35 #include <linux/rculist.h>
36 #include <linux/rcupdate.h>
37 #include <linux/seq_file.h>
38 #include <linux/skbuff.h>
39 #include <linux/slab.h>
40 #include <linux/spinlock.h>
41 #include <linux/stddef.h>
42 #include <linux/string.h>
43 #include <linux/workqueue.h>
46 #include "hard-interface.h"
48 #include "originator.h"
50 #include "translation-table.h"
53 static void batadv_dat_purge(struct work_struct
*work
);
56 * batadv_dat_start_timer - initialise the DAT periodic worker
57 * @bat_priv: the bat priv with all the soft interface information
59 static void batadv_dat_start_timer(struct batadv_priv
*bat_priv
)
61 INIT_DELAYED_WORK(&bat_priv
->dat
.work
, batadv_dat_purge
);
62 queue_delayed_work(batadv_event_workqueue
, &bat_priv
->dat
.work
,
63 msecs_to_jiffies(10000));
67 * batadv_dat_entry_release - release dat_entry from lists and queue for free
68 * after rcu grace period
69 * @ref: kref pointer of the dat_entry
71 static void batadv_dat_entry_release(struct kref
*ref
)
73 struct batadv_dat_entry
*dat_entry
;
75 dat_entry
= container_of(ref
, struct batadv_dat_entry
, refcount
);
77 kfree_rcu(dat_entry
, rcu
);
81 * batadv_dat_entry_put - decrement the dat_entry refcounter and possibly
83 * @dat_entry: dat_entry to be free'd
85 static void batadv_dat_entry_put(struct batadv_dat_entry
*dat_entry
)
87 kref_put(&dat_entry
->refcount
, batadv_dat_entry_release
);
91 * batadv_dat_to_purge - check whether a dat_entry has to be purged or not
92 * @dat_entry: the entry to check
94 * Return: true if the entry has to be purged now, false otherwise.
96 static bool batadv_dat_to_purge(struct batadv_dat_entry
*dat_entry
)
98 return batadv_has_timed_out(dat_entry
->last_update
,
99 BATADV_DAT_ENTRY_TIMEOUT
);
103 * __batadv_dat_purge - delete entries from the DAT local storage
104 * @bat_priv: the bat priv with all the soft interface information
105 * @to_purge: function in charge to decide whether an entry has to be purged or
106 * not. This function takes the dat_entry as argument and has to
107 * returns a boolean value: true is the entry has to be deleted,
110 * Loops over each entry in the DAT local storage and deletes it if and only if
111 * the to_purge function passed as argument returns true.
113 static void __batadv_dat_purge(struct batadv_priv
*bat_priv
,
114 bool (*to_purge
)(struct batadv_dat_entry
*))
116 spinlock_t
*list_lock
; /* protects write access to the hash lists */
117 struct batadv_dat_entry
*dat_entry
;
118 struct hlist_node
*node_tmp
;
119 struct hlist_head
*head
;
122 if (!bat_priv
->dat
.hash
)
125 for (i
= 0; i
< bat_priv
->dat
.hash
->size
; i
++) {
126 head
= &bat_priv
->dat
.hash
->table
[i
];
127 list_lock
= &bat_priv
->dat
.hash
->list_locks
[i
];
129 spin_lock_bh(list_lock
);
130 hlist_for_each_entry_safe(dat_entry
, node_tmp
, head
,
132 /* if a helper function has been passed as parameter,
133 * ask it if the entry has to be purged or not
135 if (to_purge
&& !to_purge(dat_entry
))
138 hlist_del_rcu(&dat_entry
->hash_entry
);
139 batadv_dat_entry_put(dat_entry
);
141 spin_unlock_bh(list_lock
);
146 * batadv_dat_purge - periodic task that deletes old entries from the local DAT
148 * @work: kernel work struct
150 static void batadv_dat_purge(struct work_struct
*work
)
152 struct delayed_work
*delayed_work
;
153 struct batadv_priv_dat
*priv_dat
;
154 struct batadv_priv
*bat_priv
;
156 delayed_work
= to_delayed_work(work
);
157 priv_dat
= container_of(delayed_work
, struct batadv_priv_dat
, work
);
158 bat_priv
= container_of(priv_dat
, struct batadv_priv
, dat
);
160 __batadv_dat_purge(bat_priv
, batadv_dat_to_purge
);
161 batadv_dat_start_timer(bat_priv
);
165 * batadv_compare_dat - comparing function used in the local DAT hash table
166 * @node: node in the local table
167 * @data2: second object to compare the node to
169 * Return: true if the two entries are the same, false otherwise.
171 static bool batadv_compare_dat(const struct hlist_node
*node
, const void *data2
)
173 const void *data1
= container_of(node
, struct batadv_dat_entry
,
176 return memcmp(data1
, data2
, sizeof(__be32
)) == 0;
180 * batadv_arp_hw_src - extract the hw_src field from an ARP packet
182 * @hdr_size: size of the possible header before the ARP packet
184 * Return: the value of the hw_src field in the ARP packet.
186 static u8
*batadv_arp_hw_src(struct sk_buff
*skb
, int hdr_size
)
190 addr
= (u8
*)(skb
->data
+ hdr_size
);
191 addr
+= ETH_HLEN
+ sizeof(struct arphdr
);
197 * batadv_arp_ip_src - extract the ip_src field from an ARP packet
199 * @hdr_size: size of the possible header before the ARP packet
201 * Return: the value of the ip_src field in the ARP packet.
203 static __be32
batadv_arp_ip_src(struct sk_buff
*skb
, int hdr_size
)
205 return *(__be32
*)(batadv_arp_hw_src(skb
, hdr_size
) + ETH_ALEN
);
209 * batadv_arp_hw_dst - extract the hw_dst field from an ARP packet
211 * @hdr_size: size of the possible header before the ARP packet
213 * Return: the value of the hw_dst field in the ARP packet.
215 static u8
*batadv_arp_hw_dst(struct sk_buff
*skb
, int hdr_size
)
217 return batadv_arp_hw_src(skb
, hdr_size
) + ETH_ALEN
+ 4;
221 * batadv_arp_ip_dst - extract the ip_dst field from an ARP packet
223 * @hdr_size: size of the possible header before the ARP packet
225 * Return: the value of the ip_dst field in the ARP packet.
227 static __be32
batadv_arp_ip_dst(struct sk_buff
*skb
, int hdr_size
)
229 return *(__be32
*)(batadv_arp_hw_src(skb
, hdr_size
) + ETH_ALEN
* 2 + 4);
233 * batadv_hash_dat - compute the hash value for an IP address
234 * @data: data to hash
235 * @size: size of the hash table
237 * Return: the selected index in the hash table for the given data.
239 static u32
batadv_hash_dat(const void *data
, u32 size
)
242 const struct batadv_dat_entry
*dat
= data
;
243 const unsigned char *key
;
246 key
= (const unsigned char *)&dat
->ip
;
247 for (i
= 0; i
< sizeof(dat
->ip
); i
++) {
249 hash
+= (hash
<< 10);
253 key
= (const unsigned char *)&dat
->vid
;
254 for (i
= 0; i
< sizeof(dat
->vid
); i
++) {
256 hash
+= (hash
<< 10);
261 hash
^= (hash
>> 11);
262 hash
+= (hash
<< 15);
268 * batadv_dat_entry_hash_find - look for a given dat_entry in the local hash
270 * @bat_priv: the bat priv with all the soft interface information
272 * @vid: VLAN identifier
274 * Return: the dat_entry if found, NULL otherwise.
276 static struct batadv_dat_entry
*
277 batadv_dat_entry_hash_find(struct batadv_priv
*bat_priv
, __be32 ip
,
280 struct hlist_head
*head
;
281 struct batadv_dat_entry to_find
, *dat_entry
, *dat_entry_tmp
= NULL
;
282 struct batadv_hashtable
*hash
= bat_priv
->dat
.hash
;
291 index
= batadv_hash_dat(&to_find
, hash
->size
);
292 head
= &hash
->table
[index
];
295 hlist_for_each_entry_rcu(dat_entry
, head
, hash_entry
) {
296 if (dat_entry
->ip
!= ip
)
299 if (!kref_get_unless_zero(&dat_entry
->refcount
))
302 dat_entry_tmp
= dat_entry
;
307 return dat_entry_tmp
;
311 * batadv_dat_entry_add - add a new dat entry or update it if already exists
312 * @bat_priv: the bat priv with all the soft interface information
313 * @ip: ipv4 to add/edit
314 * @mac_addr: mac address to assign to the given ipv4
315 * @vid: VLAN identifier
317 static void batadv_dat_entry_add(struct batadv_priv
*bat_priv
, __be32 ip
,
318 u8
*mac_addr
, unsigned short vid
)
320 struct batadv_dat_entry
*dat_entry
;
323 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip
, vid
);
324 /* if this entry is already known, just update it */
326 if (!batadv_compare_eth(dat_entry
->mac_addr
, mac_addr
))
327 ether_addr_copy(dat_entry
->mac_addr
, mac_addr
);
328 dat_entry
->last_update
= jiffies
;
329 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
330 "Entry updated: %pI4 %pM (vid: %d)\n",
331 &dat_entry
->ip
, dat_entry
->mac_addr
,
332 BATADV_PRINT_VID(vid
));
336 dat_entry
= kmalloc(sizeof(*dat_entry
), GFP_ATOMIC
);
341 dat_entry
->vid
= vid
;
342 ether_addr_copy(dat_entry
->mac_addr
, mac_addr
);
343 dat_entry
->last_update
= jiffies
;
344 kref_init(&dat_entry
->refcount
);
345 kref_get(&dat_entry
->refcount
);
347 hash_added
= batadv_hash_add(bat_priv
->dat
.hash
, batadv_compare_dat
,
348 batadv_hash_dat
, dat_entry
,
349 &dat_entry
->hash_entry
);
351 if (unlikely(hash_added
!= 0)) {
352 /* remove the reference for the hash */
353 batadv_dat_entry_put(dat_entry
);
357 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "New entry added: %pI4 %pM (vid: %d)\n",
358 &dat_entry
->ip
, dat_entry
->mac_addr
, BATADV_PRINT_VID(vid
));
362 batadv_dat_entry_put(dat_entry
);
365 #ifdef CONFIG_BATMAN_ADV_DEBUG
368 * batadv_dbg_arp - print a debug message containing all the ARP packet details
369 * @bat_priv: the bat priv with all the soft interface information
372 * @hdr_size: size of the possible header before the ARP packet
373 * @msg: message to print together with the debugging information
375 static void batadv_dbg_arp(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
,
376 u16 type
, int hdr_size
, char *msg
)
378 struct batadv_unicast_4addr_packet
*unicast_4addr_packet
;
379 struct batadv_bcast_packet
*bcast_pkt
;
381 __be32 ip_src
, ip_dst
;
384 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "%s\n", msg
);
386 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
387 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
388 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
389 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n",
390 batadv_arp_hw_src(skb
, hdr_size
), &ip_src
,
391 batadv_arp_hw_dst(skb
, hdr_size
), &ip_dst
);
396 unicast_4addr_packet
= (struct batadv_unicast_4addr_packet
*)skb
->data
;
398 switch (unicast_4addr_packet
->u
.packet_type
) {
400 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
401 "* encapsulated within a UNICAST packet\n");
403 case BATADV_UNICAST_4ADDR
:
404 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
405 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n",
406 unicast_4addr_packet
->src
);
407 switch (unicast_4addr_packet
->subtype
) {
408 case BATADV_P_DAT_DHT_PUT
:
409 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DAT_DHT_PUT\n");
411 case BATADV_P_DAT_DHT_GET
:
412 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DAT_DHT_GET\n");
414 case BATADV_P_DAT_CACHE_REPLY
:
415 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
416 "* type: DAT_CACHE_REPLY\n");
419 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: DATA\n");
422 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "* type: Unknown (%u)!\n",
423 unicast_4addr_packet
->u
.packet_type
);
427 bcast_pkt
= (struct batadv_bcast_packet
*)unicast_4addr_packet
;
428 orig_addr
= bcast_pkt
->orig
;
429 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
430 "* encapsulated within a BCAST packet (src: %pM)\n",
434 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
435 "* encapsulated within an unknown packet type (0x%x)\n",
436 unicast_4addr_packet
->u
.packet_type
);
442 static void batadv_dbg_arp(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
,
443 u16 type
, int hdr_size
, char *msg
)
447 #endif /* CONFIG_BATMAN_ADV_DEBUG */
450 * batadv_is_orig_node_eligible - check whether a node can be a DHT candidate
451 * @res: the array with the already selected candidates
452 * @select: number of already selected candidates
453 * @tmp_max: address of the currently evaluated node
454 * @max: current round max address
455 * @last_max: address of the last selected candidate
456 * @candidate: orig_node under evaluation
457 * @max_orig_node: last selected candidate
459 * Return: true if the node has been elected as next candidate or false
462 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate
*res
,
463 int select
, batadv_dat_addr_t tmp_max
,
464 batadv_dat_addr_t max
,
465 batadv_dat_addr_t last_max
,
466 struct batadv_orig_node
*candidate
,
467 struct batadv_orig_node
*max_orig_node
)
472 /* check if orig node candidate is running DAT */
473 if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT
, &candidate
->capabilities
))
476 /* Check if this node has already been selected... */
477 for (j
= 0; j
< select
; j
++)
478 if (res
[j
].orig_node
== candidate
)
480 /* ..and possibly skip it */
483 /* sanity check: has it already been selected? This should not happen */
484 if (tmp_max
> last_max
)
486 /* check if during this iteration an originator with a closer dht
487 * address has already been found
491 /* this is an hash collision with the temporary selected node. Choose
492 * the one with the lowest address
494 if ((tmp_max
== max
) && max_orig_node
&&
495 (batadv_compare_eth(candidate
->orig
, max_orig_node
->orig
) > 0))
504 * batadv_choose_next_candidate - select the next DHT candidate
505 * @bat_priv: the bat priv with all the soft interface information
506 * @cands: candidates array
507 * @select: number of candidates already present in the array
508 * @ip_key: key to look up in the DHT
509 * @last_max: pointer where the address of the selected candidate will be saved
511 static void batadv_choose_next_candidate(struct batadv_priv
*bat_priv
,
512 struct batadv_dat_candidate
*cands
,
513 int select
, batadv_dat_addr_t ip_key
,
514 batadv_dat_addr_t
*last_max
)
516 batadv_dat_addr_t max
= 0;
517 batadv_dat_addr_t tmp_max
= 0;
518 struct batadv_orig_node
*orig_node
, *max_orig_node
= NULL
;
519 struct batadv_hashtable
*hash
= bat_priv
->orig_hash
;
520 struct hlist_head
*head
;
523 /* if no node is eligible as candidate, leave the candidate type as
526 cands
[select
].type
= BATADV_DAT_CANDIDATE_NOT_FOUND
;
528 /* iterate over the originator list and find the node with the closest
529 * dat_address which has not been selected yet
531 for (i
= 0; i
< hash
->size
; i
++) {
532 head
= &hash
->table
[i
];
535 hlist_for_each_entry_rcu(orig_node
, head
, hash_entry
) {
536 /* the dht space is a ring using unsigned addresses */
537 tmp_max
= BATADV_DAT_ADDR_MAX
- orig_node
->dat_addr
+
540 if (!batadv_is_orig_node_eligible(cands
, select
,
542 *last_max
, orig_node
,
546 if (!kref_get_unless_zero(&orig_node
->refcount
))
551 batadv_orig_node_put(max_orig_node
);
552 max_orig_node
= orig_node
;
557 cands
[select
].type
= BATADV_DAT_CANDIDATE_ORIG
;
558 cands
[select
].orig_node
= max_orig_node
;
559 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
560 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n",
561 select
, max_orig_node
->orig
, max_orig_node
->dat_addr
,
568 * batadv_dat_select_candidates - select the nodes which the DHT message has to
570 * @bat_priv: the bat priv with all the soft interface information
571 * @ip_dst: ipv4 to look up in the DHT
572 * @vid: VLAN identifier
574 * An originator O is selected if and only if its DHT_ID value is one of three
575 * closest values (from the LEFT, with wrap around if needed) then the hash
576 * value of the key. ip_dst is the key.
578 * Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM.
580 static struct batadv_dat_candidate
*
581 batadv_dat_select_candidates(struct batadv_priv
*bat_priv
, __be32 ip_dst
,
585 batadv_dat_addr_t last_max
= BATADV_DAT_ADDR_MAX
, ip_key
;
586 struct batadv_dat_candidate
*res
;
587 struct batadv_dat_entry dat
;
589 if (!bat_priv
->orig_hash
)
592 res
= kmalloc_array(BATADV_DAT_CANDIDATES_NUM
, sizeof(*res
),
599 ip_key
= (batadv_dat_addr_t
)batadv_hash_dat(&dat
,
600 BATADV_DAT_ADDR_MAX
);
602 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
603 "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst
,
606 for (select
= 0; select
< BATADV_DAT_CANDIDATES_NUM
; select
++)
607 batadv_choose_next_candidate(bat_priv
, res
, select
, ip_key
,
614 * batadv_dat_send_data - send a payload to the selected candidates
615 * @bat_priv: the bat priv with all the soft interface information
616 * @skb: payload to send
618 * @vid: VLAN identifier
619 * @packet_subtype: unicast4addr packet subtype to use
621 * This function copies the skb with pskb_copy() and is sent as unicast packet
622 * to each of the selected candidates.
624 * Return: true if the packet is sent to at least one candidate, false
627 static bool batadv_dat_send_data(struct batadv_priv
*bat_priv
,
628 struct sk_buff
*skb
, __be32 ip
,
629 unsigned short vid
, int packet_subtype
)
634 struct batadv_neigh_node
*neigh_node
= NULL
;
635 struct sk_buff
*tmp_skb
;
636 struct batadv_dat_candidate
*cand
;
638 cand
= batadv_dat_select_candidates(bat_priv
, ip
, vid
);
642 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "DHT_SEND for %pI4\n", &ip
);
644 for (i
= 0; i
< BATADV_DAT_CANDIDATES_NUM
; i
++) {
645 if (cand
[i
].type
== BATADV_DAT_CANDIDATE_NOT_FOUND
)
648 neigh_node
= batadv_orig_router_get(cand
[i
].orig_node
,
653 tmp_skb
= pskb_copy_for_clone(skb
, GFP_ATOMIC
);
654 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv
, tmp_skb
,
661 send_status
= batadv_send_unicast_skb(tmp_skb
, neigh_node
);
662 if (send_status
== NET_XMIT_SUCCESS
) {
663 /* count the sent packet */
664 switch (packet_subtype
) {
665 case BATADV_P_DAT_DHT_GET
:
666 batadv_inc_counter(bat_priv
,
667 BATADV_CNT_DAT_GET_TX
);
669 case BATADV_P_DAT_DHT_PUT
:
670 batadv_inc_counter(bat_priv
,
671 BATADV_CNT_DAT_PUT_TX
);
675 /* packet sent to a candidate: return true */
679 batadv_neigh_node_put(neigh_node
);
681 batadv_orig_node_put(cand
[i
].orig_node
);
690 * batadv_dat_tvlv_container_update - update the dat tvlv container after dat
692 * @bat_priv: the bat priv with all the soft interface information
694 static void batadv_dat_tvlv_container_update(struct batadv_priv
*bat_priv
)
698 dat_mode
= atomic_read(&bat_priv
->distributed_arp_table
);
702 batadv_tvlv_container_unregister(bat_priv
, BATADV_TVLV_DAT
, 1);
705 batadv_tvlv_container_register(bat_priv
, BATADV_TVLV_DAT
, 1,
712 * batadv_dat_status_update - update the dat tvlv container after dat
714 * @net_dev: the soft interface net device
716 void batadv_dat_status_update(struct net_device
*net_dev
)
718 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
720 batadv_dat_tvlv_container_update(bat_priv
);
724 * batadv_dat_tvlv_ogm_handler_v1 - process incoming dat tvlv container
725 * @bat_priv: the bat priv with all the soft interface information
726 * @orig: the orig_node of the ogm
727 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
728 * @tvlv_value: tvlv buffer containing the gateway data
729 * @tvlv_value_len: tvlv buffer length
731 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv
*bat_priv
,
732 struct batadv_orig_node
*orig
,
734 void *tvlv_value
, u16 tvlv_value_len
)
736 if (flags
& BATADV_TVLV_HANDLER_OGM_CIFNOTFND
)
737 clear_bit(BATADV_ORIG_CAPA_HAS_DAT
, &orig
->capabilities
);
739 set_bit(BATADV_ORIG_CAPA_HAS_DAT
, &orig
->capabilities
);
743 * batadv_dat_hash_free - free the local DAT hash table
744 * @bat_priv: the bat priv with all the soft interface information
746 static void batadv_dat_hash_free(struct batadv_priv
*bat_priv
)
748 if (!bat_priv
->dat
.hash
)
751 __batadv_dat_purge(bat_priv
, NULL
);
753 batadv_hash_destroy(bat_priv
->dat
.hash
);
755 bat_priv
->dat
.hash
= NULL
;
759 * batadv_dat_init - initialise the DAT internals
760 * @bat_priv: the bat priv with all the soft interface information
762 * Return: 0 in case of success, a negative error code otherwise
764 int batadv_dat_init(struct batadv_priv
*bat_priv
)
766 if (bat_priv
->dat
.hash
)
769 bat_priv
->dat
.hash
= batadv_hash_new(1024);
771 if (!bat_priv
->dat
.hash
)
774 batadv_dat_start_timer(bat_priv
);
776 batadv_tvlv_handler_register(bat_priv
, batadv_dat_tvlv_ogm_handler_v1
,
777 NULL
, BATADV_TVLV_DAT
, 1,
778 BATADV_TVLV_HANDLER_OGM_CIFNOTFND
);
779 batadv_dat_tvlv_container_update(bat_priv
);
784 * batadv_dat_free - free the DAT internals
785 * @bat_priv: the bat priv with all the soft interface information
787 void batadv_dat_free(struct batadv_priv
*bat_priv
)
789 batadv_tvlv_container_unregister(bat_priv
, BATADV_TVLV_DAT
, 1);
790 batadv_tvlv_handler_unregister(bat_priv
, BATADV_TVLV_DAT
, 1);
792 cancel_delayed_work_sync(&bat_priv
->dat
.work
);
794 batadv_dat_hash_free(bat_priv
);
798 * batadv_dat_cache_seq_print_text - print the local DAT hash table
799 * @seq: seq file to print on
804 int batadv_dat_cache_seq_print_text(struct seq_file
*seq
, void *offset
)
806 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
807 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
808 struct batadv_hashtable
*hash
= bat_priv
->dat
.hash
;
809 struct batadv_dat_entry
*dat_entry
;
810 struct batadv_hard_iface
*primary_if
;
811 struct hlist_head
*head
;
812 unsigned long last_seen_jiffies
;
813 int last_seen_msecs
, last_seen_secs
, last_seen_mins
;
816 primary_if
= batadv_seq_print_text_primary_if_get(seq
);
820 seq_printf(seq
, "Distributed ARP Table (%s):\n", net_dev
->name
);
822 " IPv4 MAC VID last-seen\n");
824 for (i
= 0; i
< hash
->size
; i
++) {
825 head
= &hash
->table
[i
];
828 hlist_for_each_entry_rcu(dat_entry
, head
, hash_entry
) {
829 last_seen_jiffies
= jiffies
- dat_entry
->last_update
;
830 last_seen_msecs
= jiffies_to_msecs(last_seen_jiffies
);
831 last_seen_mins
= last_seen_msecs
/ 60000;
832 last_seen_msecs
= last_seen_msecs
% 60000;
833 last_seen_secs
= last_seen_msecs
/ 1000;
835 seq_printf(seq
, " * %15pI4 %14pM %4i %6i:%02i\n",
836 &dat_entry
->ip
, dat_entry
->mac_addr
,
837 BATADV_PRINT_VID(dat_entry
->vid
),
838 last_seen_mins
, last_seen_secs
);
845 batadv_hardif_put(primary_if
);
850 * batadv_arp_get_type - parse an ARP packet and gets the type
851 * @bat_priv: the bat priv with all the soft interface information
852 * @skb: packet to analyse
853 * @hdr_size: size of the possible header before the ARP packet in the skb
855 * Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise.
857 static u16
batadv_arp_get_type(struct batadv_priv
*bat_priv
,
858 struct sk_buff
*skb
, int hdr_size
)
860 struct arphdr
*arphdr
;
861 struct ethhdr
*ethhdr
;
862 __be32 ip_src
, ip_dst
;
866 /* pull the ethernet header */
867 if (unlikely(!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
)))
870 ethhdr
= (struct ethhdr
*)(skb
->data
+ hdr_size
);
872 if (ethhdr
->h_proto
!= htons(ETH_P_ARP
))
875 /* pull the ARP payload */
876 if (unlikely(!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
+
877 arp_hdr_len(skb
->dev
))))
880 arphdr
= (struct arphdr
*)(skb
->data
+ hdr_size
+ ETH_HLEN
);
882 /* check whether the ARP packet carries a valid IP information */
883 if (arphdr
->ar_hrd
!= htons(ARPHRD_ETHER
))
886 if (arphdr
->ar_pro
!= htons(ETH_P_IP
))
889 if (arphdr
->ar_hln
!= ETH_ALEN
)
892 if (arphdr
->ar_pln
!= 4)
895 /* Check for bad reply/request. If the ARP message is not sane, DAT
896 * will simply ignore it
898 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
899 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
900 if (ipv4_is_loopback(ip_src
) || ipv4_is_multicast(ip_src
) ||
901 ipv4_is_loopback(ip_dst
) || ipv4_is_multicast(ip_dst
) ||
902 ipv4_is_zeronet(ip_src
) || ipv4_is_lbcast(ip_src
) ||
903 ipv4_is_zeronet(ip_dst
) || ipv4_is_lbcast(ip_dst
))
906 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
907 if (is_zero_ether_addr(hw_src
) || is_multicast_ether_addr(hw_src
))
910 /* don't care about the destination MAC address in ARP requests */
911 if (arphdr
->ar_op
!= htons(ARPOP_REQUEST
)) {
912 hw_dst
= batadv_arp_hw_dst(skb
, hdr_size
);
913 if (is_zero_ether_addr(hw_dst
) ||
914 is_multicast_ether_addr(hw_dst
))
918 type
= ntohs(arphdr
->ar_op
);
924 * batadv_dat_get_vid - extract the VLAN identifier from skb if any
925 * @skb: the buffer containing the packet to extract the VID from
926 * @hdr_size: the size of the batman-adv header encapsulating the packet
928 * Return: If the packet embedded in the skb is vlan tagged this function
929 * returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS
932 static unsigned short batadv_dat_get_vid(struct sk_buff
*skb
, int *hdr_size
)
936 vid
= batadv_get_vid(skb
, *hdr_size
);
938 /* ARP parsing functions jump forward of hdr_size + ETH_HLEN.
939 * If the header contained in the packet is a VLAN one (which is longer)
940 * hdr_size is updated so that the functions will still skip the
941 * correct amount of bytes.
943 if (vid
& BATADV_VLAN_HAS_TAG
)
944 *hdr_size
+= VLAN_HLEN
;
950 * batadv_dat_snoop_outgoing_arp_request - snoop the ARP request and try to
952 * @bat_priv: the bat priv with all the soft interface information
953 * @skb: packet to check
955 * Return: true if the message has been sent to the dht candidates, false
956 * otherwise. In case of a positive return value the message has to be enqueued
957 * to permit the fallback.
959 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv
*bat_priv
,
963 __be32 ip_dst
, ip_src
;
966 struct batadv_dat_entry
*dat_entry
= NULL
;
967 struct sk_buff
*skb_new
;
971 if (!atomic_read(&bat_priv
->distributed_arp_table
))
974 vid
= batadv_dat_get_vid(skb
, &hdr_size
);
976 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
977 /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast
978 * message to the selected DHT candidates
980 if (type
!= ARPOP_REQUEST
)
983 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
984 "Parsing outgoing ARP REQUEST");
986 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
987 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
988 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
990 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
, vid
);
992 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
, vid
);
994 /* If the ARP request is destined for a local client the local
995 * client will answer itself. DAT would only generate a
998 * Moreover, if the soft-interface is enslaved into a bridge, an
999 * additional DAT answer may trigger kernel warnings about
1000 * a packet coming from the wrong port.
1002 if (batadv_is_my_client(bat_priv
, dat_entry
->mac_addr
, vid
)) {
1007 skb_new
= arp_create(ARPOP_REPLY
, ETH_P_ARP
, ip_src
,
1008 bat_priv
->soft_iface
, ip_dst
, hw_src
,
1009 dat_entry
->mac_addr
, hw_src
);
1013 if (vid
& BATADV_VLAN_HAS_TAG
)
1014 skb_new
= vlan_insert_tag(skb_new
, htons(ETH_P_8021Q
),
1015 vid
& VLAN_VID_MASK
);
1017 skb_reset_mac_header(skb_new
);
1018 skb_new
->protocol
= eth_type_trans(skb_new
,
1019 bat_priv
->soft_iface
);
1020 bat_priv
->stats
.rx_packets
++;
1021 bat_priv
->stats
.rx_bytes
+= skb
->len
+ ETH_HLEN
+ hdr_size
;
1022 bat_priv
->soft_iface
->last_rx
= jiffies
;
1025 batadv_dbg(BATADV_DBG_DAT
, bat_priv
, "ARP request replied locally\n");
1028 /* Send the request to the DHT */
1029 ret
= batadv_dat_send_data(bat_priv
, skb
, ip_dst
, vid
,
1030 BATADV_P_DAT_DHT_GET
);
1034 batadv_dat_entry_put(dat_entry
);
1039 * batadv_dat_snoop_incoming_arp_request - snoop the ARP request and try to
1040 * answer using the local DAT storage
1041 * @bat_priv: the bat priv with all the soft interface information
1042 * @skb: packet to check
1043 * @hdr_size: size of the encapsulation header
1045 * Return: true if the request has been answered, false otherwise.
1047 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv
*bat_priv
,
1048 struct sk_buff
*skb
, int hdr_size
)
1051 __be32 ip_src
, ip_dst
;
1053 struct sk_buff
*skb_new
;
1054 struct batadv_dat_entry
*dat_entry
= NULL
;
1059 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1062 vid
= batadv_dat_get_vid(skb
, &hdr_size
);
1064 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
1065 if (type
!= ARPOP_REQUEST
)
1068 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
1069 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
1070 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
1072 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
1073 "Parsing incoming ARP REQUEST");
1075 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
, vid
);
1077 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
, vid
);
1081 skb_new
= arp_create(ARPOP_REPLY
, ETH_P_ARP
, ip_src
,
1082 bat_priv
->soft_iface
, ip_dst
, hw_src
,
1083 dat_entry
->mac_addr
, hw_src
);
1088 /* the rest of the TX path assumes that the mac_header offset pointing
1089 * to the inner Ethernet header has been set, therefore reset it now.
1091 skb_reset_mac_header(skb_new
);
1093 if (vid
& BATADV_VLAN_HAS_TAG
)
1094 skb_new
= vlan_insert_tag(skb_new
, htons(ETH_P_8021Q
),
1095 vid
& VLAN_VID_MASK
);
1097 /* To preserve backwards compatibility, the node has choose the outgoing
1098 * format based on the incoming request packet type. The assumption is
1099 * that a node not using the 4addr packet format doesn't support it.
1101 if (hdr_size
== sizeof(struct batadv_unicast_4addr_packet
))
1102 err
= batadv_send_skb_via_tt_4addr(bat_priv
, skb_new
,
1103 BATADV_P_DAT_CACHE_REPLY
,
1106 err
= batadv_send_skb_via_tt(bat_priv
, skb_new
, NULL
, vid
);
1108 if (err
!= NET_XMIT_DROP
) {
1109 batadv_inc_counter(bat_priv
, BATADV_CNT_DAT_CACHED_REPLY_TX
);
1114 batadv_dat_entry_put(dat_entry
);
1121 * batadv_dat_snoop_outgoing_arp_reply - snoop the ARP reply and fill the DHT
1122 * @bat_priv: the bat priv with all the soft interface information
1123 * @skb: packet to check
1125 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv
*bat_priv
,
1126 struct sk_buff
*skb
)
1129 __be32 ip_src
, ip_dst
;
1130 u8
*hw_src
, *hw_dst
;
1134 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1137 vid
= batadv_dat_get_vid(skb
, &hdr_size
);
1139 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
1140 if (type
!= ARPOP_REPLY
)
1143 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
1144 "Parsing outgoing ARP REPLY");
1146 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
1147 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
1148 hw_dst
= batadv_arp_hw_dst(skb
, hdr_size
);
1149 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
1151 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
, vid
);
1152 batadv_dat_entry_add(bat_priv
, ip_dst
, hw_dst
, vid
);
1154 /* Send the ARP reply to the candidates for both the IP addresses that
1155 * the node obtained from the ARP reply
1157 batadv_dat_send_data(bat_priv
, skb
, ip_src
, vid
, BATADV_P_DAT_DHT_PUT
);
1158 batadv_dat_send_data(bat_priv
, skb
, ip_dst
, vid
, BATADV_P_DAT_DHT_PUT
);
1162 * batadv_dat_snoop_incoming_arp_reply - snoop the ARP reply and fill the local
1164 * @bat_priv: the bat priv with all the soft interface information
1165 * @skb: packet to check
1166 * @hdr_size: size of the encapsulation header
1168 * Return: true if the packet was snooped and consumed by DAT. False if the
1169 * packet has to be delivered to the interface
1171 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv
*bat_priv
,
1172 struct sk_buff
*skb
, int hdr_size
)
1175 __be32 ip_src
, ip_dst
;
1176 u8
*hw_src
, *hw_dst
;
1177 bool dropped
= false;
1180 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1183 vid
= batadv_dat_get_vid(skb
, &hdr_size
);
1185 type
= batadv_arp_get_type(bat_priv
, skb
, hdr_size
);
1186 if (type
!= ARPOP_REPLY
)
1189 batadv_dbg_arp(bat_priv
, skb
, type
, hdr_size
,
1190 "Parsing incoming ARP REPLY");
1192 hw_src
= batadv_arp_hw_src(skb
, hdr_size
);
1193 ip_src
= batadv_arp_ip_src(skb
, hdr_size
);
1194 hw_dst
= batadv_arp_hw_dst(skb
, hdr_size
);
1195 ip_dst
= batadv_arp_ip_dst(skb
, hdr_size
);
1197 /* Update our internal cache with both the IP addresses the node got
1198 * within the ARP reply
1200 batadv_dat_entry_add(bat_priv
, ip_src
, hw_src
, vid
);
1201 batadv_dat_entry_add(bat_priv
, ip_dst
, hw_dst
, vid
);
1203 /* if this REPLY is directed to a client of mine, let's deliver the
1204 * packet to the interface
1206 dropped
= !batadv_is_my_client(bat_priv
, hw_dst
, vid
);
1208 /* if this REPLY is sent on behalf of a client of mine, let's drop the
1209 * packet because the client will reply by itself
1211 dropped
|= batadv_is_my_client(bat_priv
, hw_src
, vid
);
1215 /* if dropped == false -> deliver to the interface */
1220 * batadv_dat_drop_broadcast_packet - check if an ARP request has to be dropped
1221 * (because the node has already obtained the reply via DAT) or not
1222 * @bat_priv: the bat priv with all the soft interface information
1223 * @forw_packet: the broadcast packet
1225 * Return: true if the node can drop the packet, false otherwise.
1227 bool batadv_dat_drop_broadcast_packet(struct batadv_priv
*bat_priv
,
1228 struct batadv_forw_packet
*forw_packet
)
1232 struct batadv_dat_entry
*dat_entry
= NULL
;
1234 int hdr_size
= sizeof(struct batadv_bcast_packet
);
1237 if (!atomic_read(&bat_priv
->distributed_arp_table
))
1240 /* If this packet is an ARP_REQUEST and the node already has the
1241 * information that it is going to ask, then the packet can be dropped
1243 if (forw_packet
->num_packets
)
1246 vid
= batadv_dat_get_vid(forw_packet
->skb
, &hdr_size
);
1248 type
= batadv_arp_get_type(bat_priv
, forw_packet
->skb
, hdr_size
);
1249 if (type
!= ARPOP_REQUEST
)
1252 ip_dst
= batadv_arp_ip_dst(forw_packet
->skb
, hdr_size
);
1253 dat_entry
= batadv_dat_entry_hash_find(bat_priv
, ip_dst
, vid
);
1254 /* check if the node already got this entry */
1256 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
1257 "ARP Request for %pI4: fallback\n", &ip_dst
);
1261 batadv_dbg(BATADV_DBG_DAT
, bat_priv
,
1262 "ARP Request for %pI4: fallback prevented\n", &ip_dst
);
1267 batadv_dat_entry_put(dat_entry
);