Eric Lee / smarc-fsl-linux-kernel

Commit e300d314664ef6746e697d5b581f85114ab1f843

Authored by Linus Lüssing 2013-07-03 16:40:00 +0800

Committed by Antonio Quartulli 2013-10-19 23:31:54 +0800

batman-adv: refine API calls for unicast transmissions of SKBs

With this patch the functions batadv_send_skb_unicast() and
batadv_send_skb_unicast_4addr() are further refined into
batadv_send_skb_via_tt(), batadv_send_skb_via_tt_4addr() and
batadv_send_skb_via_gw(). This way we avoid any "guessing" about where to send
a packet in the unicast forwarding methods and let the callers decide.

This is going to be useful for the upcoming multicast related patches in
particular.

Further, the return values were polished a little to use the more
appropriate NET_XMIT_* defines.

Signed-off-by: Linus Lüssing <linus.luessing@web.de>
Acked-by: Antonio Quartulli <antonio@meshcoding.com>
Signed-off-by: Marek Lindner <lindner_marek@yahoo.de>
Signed-off-by: Antonio Quartulli <antonio@meshcoding.com>

Showing 4 changed files with 108 additions and 48 deletions Inline Diff

net/batman-adv/distributed-arp-table.c
net/batman-adv/send.c
net/batman-adv/send.h
net/batman-adv/soft-interface.c

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

Diff comments View file @ e300d31

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

net/batman-adv/send.c

Diff comments View file @ e300d31

 /* Copyright (C) 2007-2013 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA
  */
 #include "main.h"
 #include "distributed-arp-table.h"
 #include "send.h"
 #include "routing.h"
 #include "translation-table.h"
 #include "soft-interface.h"
 #include "hard-interface.h"
 #include "gateway_common.h"
 #include "gateway_client.h"
 #include "originator.h"
 #include "network-coding.h"
 #include "fragmentation.h"
 static void batadv_send_outstanding_bcast_packet(struct work_struct *work);
 /* send out an already prepared packet to the given address via the
  * specified batman interface
  */
 int batadv_send_skb_packet(struct sk_buff *skb,
 			   struct batadv_hard_iface *hard_iface,
 			   const uint8_t *dst_addr)
 {
 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 	struct ethhdr *ethhdr;
 	if (hard_iface->if_status != BATADV_IF_ACTIVE)
 		goto send_skb_err;
 	if (unlikely(!hard_iface->net_dev))
 		goto send_skb_err;
 	if (!(hard_iface->net_dev->flags & IFF_UP)) {
 		pr_warn("Interface %s is not up - can't send packet via that interface!\n",
 			hard_iface->net_dev->name);
 		goto send_skb_err;
 	}
 	/* push to the ethernet header. */
 	if (batadv_skb_head_push(skb, ETH_HLEN) < 0)
 		goto send_skb_err;
 	skb_reset_mac_header(skb);
 	ethhdr = eth_hdr(skb);
 	memcpy(ethhdr->h_source, hard_iface->net_dev->dev_addr, ETH_ALEN);
 	memcpy(ethhdr->h_dest, dst_addr, ETH_ALEN);
 	ethhdr->h_proto = htons(ETH_P_BATMAN);
 	skb_set_network_header(skb, ETH_HLEN);
 	skb->protocol = htons(ETH_P_BATMAN);
 	skb->dev = hard_iface->net_dev;
 	/* Save a clone of the skb to use when decoding coded packets */
 	batadv_nc_skb_store_for_decoding(bat_priv, skb);
 	/* dev_queue_xmit() returns a negative result on error.	 However on
 	 * congestion and traffic shaping, it drops and returns NET_XMIT_DROP
 	 * (which is > 0). This will not be treated as an error.
 	 */
 	return dev_queue_xmit(skb);
 send_skb_err:
 	kfree_skb(skb);
 	return NET_XMIT_DROP;
 }
 /**
  * batadv_send_skb_to_orig - Lookup next-hop and transmit skb.
  * @skb: Packet to be transmitted.
  * @orig_node: Final destination of the packet.
  * @recv_if: Interface used when receiving the packet (can be NULL).
  *
  * Looks up the best next-hop towards the passed originator and passes the
  * skb on for preparation of MAC header. If the packet originated from this
  * host, NULL can be passed as recv_if and no interface alternating is
  * attempted.
  *
  * Returns NET_XMIT_SUCCESS on success, NET_XMIT_DROP on failure, or
  * NET_XMIT_POLICED if the skb is buffered for later transmit.
  */
 int batadv_send_skb_to_orig(struct sk_buff *skb,
 			    struct batadv_orig_node *orig_node,
 			    struct batadv_hard_iface *recv_if)
 {
 	struct batadv_priv *bat_priv = orig_node->bat_priv;
 	struct batadv_neigh_node *neigh_node;
 	int ret = NET_XMIT_DROP;
 	/* batadv_find_router() increases neigh_nodes refcount if found. */
 	neigh_node = batadv_find_router(bat_priv, orig_node, recv_if);
 	if (!neigh_node)
 		goto out;
 	/* Check if the skb is too large to send in one piece and fragment
 	 * it if needed.
 	 */
 	if (atomic_read(&bat_priv->fragmentation) &&
 	    skb->len > neigh_node->if_incoming->net_dev->mtu) {
 		/* Fragment and send packet. */
 		if (batadv_frag_send_packet(skb, orig_node, neigh_node))
 			ret = NET_XMIT_SUCCESS;
 		goto out;
 	}
 	/* try to network code the packet, if it is received on an interface
 	 * (i.e. being forwarded). If the packet originates from this node or if
 	 * network coding fails, then send the packet as usual.
 	 */
 	if (recv_if && batadv_nc_skb_forward(skb, neigh_node)) {
 		ret = NET_XMIT_POLICED;
 	} else {
 		batadv_send_skb_packet(skb, neigh_node->if_incoming,
 				       neigh_node->addr);
 		ret = NET_XMIT_SUCCESS;
 	}
 out:
 	if (neigh_node)
 		batadv_neigh_node_free_ref(neigh_node);
 	return ret;
 }
 /**
  * batadv_send_skb_push_fill_unicast - extend the buffer and initialize the
  *  common fields for unicast packets
  * @skb: the skb carrying the unicast header to initialize
  * @hdr_size: amount of bytes to push at the beginning of the skb
  * @orig_node: the destination node
  *
  * Returns false if the buffer extension was not possible or true otherwise.
  */
 static bool
 batadv_send_skb_push_fill_unicast(struct sk_buff *skb, int hdr_size,
 				  struct batadv_orig_node *orig_node)
 {
 	struct batadv_unicast_packet *unicast_packet;
 	uint8_t ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
 	if (batadv_skb_head_push(skb, hdr_size) < 0)
 		return false;
 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
 	unicast_packet->header.version = BATADV_COMPAT_VERSION;
 	/* batman packet type: unicast */
 	unicast_packet->header.packet_type = BATADV_UNICAST;
 	/* set unicast ttl */
 	unicast_packet->header.ttl = BATADV_TTL;
 	/* copy the destination for faster routing */
 	memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN);
 	/* set the destination tt version number */
 	unicast_packet->ttvn = ttvn;
 	return true;
 }
 /**
  * batadv_send_skb_prepare_unicast - encapsulate an skb with a unicast header
  * @skb: the skb containing the payload to encapsulate
  * @orig_node: the destination node
  *
  * Returns false if the payload could not be encapsulated or true otherwise.
  */
 static bool batadv_send_skb_prepare_unicast(struct sk_buff *skb,
 					    struct batadv_orig_node *orig_node)
 {
 	size_t uni_size = sizeof(struct batadv_unicast_packet);
 	return batadv_send_skb_push_fill_unicast(skb, uni_size, orig_node);
 }
 /**
  * batadv_send_skb_prepare_unicast_4addr - encapsulate an skb with a
  *  unicast 4addr header
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: the skb containing the payload to encapsulate
  * @orig_node: the destination node
  * @packet_subtype: the unicast 4addr packet subtype to use
  *
  * Returns false if the payload could not be encapsulated or true otherwise.
  */
 bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv,
 					   struct sk_buff *skb,
 					   struct batadv_orig_node *orig,
 					   int packet_subtype)
 {
 	struct batadv_hard_iface *primary_if;
 	struct batadv_unicast_4addr_packet *uc_4addr_packet;
 	bool ret = false;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out;
 	/* Pull the header space and fill the unicast_packet substructure.
 	 * We can do that because the first member of the uc_4addr_packet
 	 * is of type struct unicast_packet
 	 */
 	if (!batadv_send_skb_push_fill_unicast(skb, sizeof(*uc_4addr_packet),
 					       orig))
 		goto out;
 	uc_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
 	uc_4addr_packet->u.header.packet_type = BATADV_UNICAST_4ADDR;
 	memcpy(uc_4addr_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
 	uc_4addr_packet->subtype = packet_subtype;
 	uc_4addr_packet->reserved = 0;
 	ret = true;
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	return ret;
 }
 /**
- * batadv_send_generic_unicast_skb - send an skb as unicast
+ * batadv_send_skb_unicast - encapsulate and send an skb via unicast
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: payload to send
  * @packet_type: the batman unicast packet type to use
  * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast
  *  4addr packets)
+ * @orig_node: the originator to send the packet to
  * @vid: the vid to be used to search the translation table
  *
- * Returns 1 in case of error or 0 otherwise.
+ * Wrap the given skb into a batman-adv unicast or unicast-4addr header
+ * depending on whether BATADV_UNICAST or BATADV_UNICAST_4ADDR was supplied
+ * as packet_type. Then send this frame to the given orig_node and release a
+ * reference to this orig_node.
+ *
+ * Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
  */
-int batadv_send_skb_generic_unicast(struct batadv_priv *bat_priv,
+static int batadv_send_skb_unicast(struct batadv_priv *bat_priv,
-				    struct sk_buff *skb, int packet_type,
+				   struct sk_buff *skb, int packet_type,
-				    int packet_subtype,
+				   int packet_subtype,
-				    unsigned short vid)
+				   struct batadv_orig_node *orig_node,
+				   unsigned short vid)
 {
 	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
 	struct batadv_unicast_packet *unicast_packet;
-	struct batadv_orig_node *orig_node;
+	int ret = NET_XMIT_DROP;
-	int ret = NET_RX_DROP;
-	/* get routing information */
-	if (is_multicast_ether_addr(ethhdr->h_dest))
-		orig_node = batadv_gw_get_selected_orig(bat_priv);
-	else
-		/* check for tt host - increases orig_node refcount.
-		 * returns NULL in case of AP isolation
-		 */
-		orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
-						     ethhdr->h_dest, vid);
 	if (!orig_node)
 		goto out;
 	switch (packet_type) {
 	case BATADV_UNICAST:
 		if (!batadv_send_skb_prepare_unicast(skb, orig_node))
 			goto out;
 		break;
 	case BATADV_UNICAST_4ADDR:
 		if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, skb,
 							   orig_node,
 							   packet_subtype))
 			goto out;
 		break;
 	default:
 		/* this function supports UNICAST and UNICAST_4ADDR only. It
 		 * should never be invoked with any other packet type
 		 */
 		goto out;
 	}
 	unicast_packet = (struct batadv_unicast_packet *)skb->data;
 	/* inform the destination node that we are still missing a correct route
 	 * for this client. The destination will receive this packet and will
 	 * try to reroute it because the ttvn contained in the header is less
 	 * than the current one
 	 */
 	if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest, vid))
 		unicast_packet->ttvn = unicast_packet->ttvn - 1;
 	if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
-		ret = 0;
+		ret = NET_XMIT_SUCCESS;
 out:
 	if (orig_node)
 		batadv_orig_node_free_ref(orig_node);
-	if (ret == NET_RX_DROP)
+	if (ret == NET_XMIT_DROP)
 		kfree_skb(skb);
 	return ret;
+}
+/**
+ * batadv_send_skb_via_tt_generic - send an skb via TT lookup
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: payload to send
+ * @packet_type: the batman unicast packet type to use
+ * @packet_subtype: the unicast 4addr packet subtype (only relevant for unicast
+ *  4addr packets)
+ * @vid: the vid to be used to search the translation table
+ *
+ * Look up the recipient node for the destination address in the ethernet
+ * header via the translation table. Wrap the given skb into a batman-adv
+ * unicast or unicast-4addr header depending on whether BATADV_UNICAST or
+ * BATADV_UNICAST_4ADDR was supplied as packet_type. Then send this frame
+ * to the according destination node.
+ *
+ * Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
+ */
+int batadv_send_skb_via_tt_generic(struct batadv_priv *bat_priv,
+				   struct sk_buff *skb, int packet_type,
+				   int packet_subtype, unsigned short vid)
+{
+	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
+	struct batadv_orig_node *orig_node;
+	orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
+					     ethhdr->h_dest, vid);
+	return batadv_send_skb_unicast(bat_priv, skb, packet_type,
+				       packet_subtype, orig_node, vid);
+}
+/**
+ * batadv_send_skb_via_gw - send an skb via gateway lookup
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: payload to send
+ * @vid: the vid to be used to search the translation table
+ *
+ * Look up the currently selected gateway. Wrap the given skb into a batman-adv
+ * unicast header and send this frame to this gateway node.
+ *
+ * Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
+ */
+int batadv_send_skb_via_gw(struct batadv_priv *bat_priv, struct sk_buff *skb,
+			   unsigned short vid)
+{
+	struct batadv_orig_node *orig_node;
+	orig_node = batadv_gw_get_selected_orig(bat_priv);
+	return batadv_send_skb_unicast(bat_priv, skb, BATADV_UNICAST, 0,
+				       orig_node, vid);
 }
 void batadv_schedule_bat_ogm(struct batadv_hard_iface *hard_iface)
 {
 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 	if ((hard_iface->if_status == BATADV_IF_NOT_IN_USE) ||
 	    (hard_iface->if_status == BATADV_IF_TO_BE_REMOVED))
 		return;
 	/* the interface gets activated here to avoid race conditions between
 	 * the moment of activating the interface in
 	 * hardif_activate_interface() where the originator mac is set and
 	 * outdated packets (especially uninitialized mac addresses) in the
 	 * packet queue
 	 */
 	if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED)
 		hard_iface->if_status = BATADV_IF_ACTIVE;
 	bat_priv->bat_algo_ops->bat_ogm_schedule(hard_iface);
 }
 static void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet)
 {
 	if (forw_packet->skb)
 		kfree_skb(forw_packet->skb);
 	if (forw_packet->if_incoming)
 		batadv_hardif_free_ref(forw_packet->if_incoming);
 	kfree(forw_packet);
 }
 static void
 _batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
 				 struct batadv_forw_packet *forw_packet,
 				 unsigned long send_time)
 {
 	/* add new packet to packet list */
 	spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 	hlist_add_head(&forw_packet->list, &bat_priv->forw_bcast_list);
 	spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 	/* start timer for this packet */
 	queue_delayed_work(batadv_event_workqueue, &forw_packet->delayed_work,
 			   send_time);
 }
 /* add a broadcast packet to the queue and setup timers. broadcast packets
  * are sent multiple times to increase probability for being received.
  *
  * This function returns NETDEV_TX_OK on success and NETDEV_TX_BUSY on
  * errors.
  *
  * The skb is not consumed, so the caller should make sure that the
  * skb is freed.
  */
 int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
 				    const struct sk_buff *skb,
 				    unsigned long delay)
 {
 	struct batadv_hard_iface *primary_if = NULL;
 	struct batadv_forw_packet *forw_packet;
 	struct batadv_bcast_packet *bcast_packet;
 	struct sk_buff *newskb;
 	if (!batadv_atomic_dec_not_zero(&bat_priv->bcast_queue_left)) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "bcast packet queue full\n");
 		goto out;
 	}
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if)
 		goto out_and_inc;
 	forw_packet = kmalloc(sizeof(*forw_packet), GFP_ATOMIC);
 	if (!forw_packet)
 		goto out_and_inc;
 	newskb = skb_copy(skb, GFP_ATOMIC);
 	if (!newskb)
 		goto packet_free;
 	/* as we have a copy now, it is safe to decrease the TTL */
 	bcast_packet = (struct batadv_bcast_packet *)newskb->data;
 	bcast_packet->header.ttl--;
 	skb_reset_mac_header(newskb);
 	forw_packet->skb = newskb;
 	forw_packet->if_incoming = primary_if;
 	/* how often did we send the bcast packet ? */
 	forw_packet->num_packets = 0;
 	INIT_DELAYED_WORK(&forw_packet->delayed_work,
 			  batadv_send_outstanding_bcast_packet);
 	_batadv_add_bcast_packet_to_list(bat_priv, forw_packet, delay);
 	return NETDEV_TX_OK;
 packet_free:
 	kfree(forw_packet);
 out_and_inc:
 	atomic_inc(&bat_priv->bcast_queue_left);
 out:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	return NETDEV_TX_BUSY;
 }
 static void batadv_send_outstanding_bcast_packet(struct work_struct *work)
 {
 	struct batadv_hard_iface *hard_iface;
 	struct delayed_work *delayed_work;
 	struct batadv_forw_packet *forw_packet;
 	struct sk_buff *skb1;
 	struct net_device *soft_iface;
 	struct batadv_priv *bat_priv;
 	delayed_work = container_of(work, struct delayed_work, work);
 	forw_packet = container_of(delayed_work, struct batadv_forw_packet,
 				   delayed_work);
 	soft_iface = forw_packet->if_incoming->soft_iface;
 	bat_priv = netdev_priv(soft_iface);
 	spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 	hlist_del(&forw_packet->list);
 	spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 	if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)
 		goto out;
 	if (batadv_dat_drop_broadcast_packet(bat_priv, forw_packet))
 		goto out;
 	/* rebroadcast packet */
 	rcu_read_lock();
 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
 		if (hard_iface->soft_iface != soft_iface)
 			continue;
 		if (forw_packet->num_packets >= hard_iface->num_bcasts)
 			continue;
 		/* send a copy of the saved skb */
 		skb1 = skb_clone(forw_packet->skb, GFP_ATOMIC);
 		if (skb1)
 			batadv_send_skb_packet(skb1, hard_iface,
 					       batadv_broadcast_addr);
 	}
 	rcu_read_unlock();
 	forw_packet->num_packets++;
 	/* if we still have some more bcasts to send */
 	if (forw_packet->num_packets < BATADV_NUM_BCASTS_MAX) {
 		_batadv_add_bcast_packet_to_list(bat_priv, forw_packet,
 						 msecs_to_jiffies(5));
 		return;
 	}
 out:
 	batadv_forw_packet_free(forw_packet);
 	atomic_inc(&bat_priv->bcast_queue_left);
 }
 void batadv_send_outstanding_bat_ogm_packet(struct work_struct *work)
 {
 	struct delayed_work *delayed_work;
 	struct batadv_forw_packet *forw_packet;
 	struct batadv_priv *bat_priv;
 	delayed_work = container_of(work, struct delayed_work, work);
 	forw_packet = container_of(delayed_work, struct batadv_forw_packet,
 				   delayed_work);
 	bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
 	spin_lock_bh(&bat_priv->forw_bat_list_lock);
 	hlist_del(&forw_packet->list);
 	spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 	if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING)
 		goto out;
 	bat_priv->bat_algo_ops->bat_ogm_emit(forw_packet);
 	/* we have to have at least one packet in the queue
 	 * to determine the queues wake up time unless we are
 	 * shutting down
 	 */
 	if (forw_packet->own)
 		batadv_schedule_bat_ogm(forw_packet->if_incoming);
 out:
 	/* don't count own packet */
 	if (!forw_packet->own)
 		atomic_inc(&bat_priv->batman_queue_left);
 	batadv_forw_packet_free(forw_packet);
 }
 void
 batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
 				 const struct batadv_hard_iface *hard_iface)
 {
 	struct batadv_forw_packet *forw_packet;
 	struct hlist_node *safe_tmp_node;
 	bool pending;
 	if (hard_iface)
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "purge_outstanding_packets(): %s\n",
 			   hard_iface->net_dev->name);
 	else
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "purge_outstanding_packets()\n");
 	/* free bcast list */
 	spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 	hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
 				  &bat_priv->forw_bcast_list, list) {
 		/* if purge_outstanding_packets() was called with an argument
 		 * we delete only packets belonging to the given interface
 		 */
 		if ((hard_iface) &&
 		    (forw_packet->if_incoming != hard_iface))
 			continue;
 		spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 		/* batadv_send_outstanding_bcast_packet() will lock the list to
 		 * delete the item from the list
 		 */
 		pending = cancel_delayed_work_sync(&forw_packet->delayed_work);
 		spin_lock_bh(&bat_priv->forw_bcast_list_lock);
 		if (pending) {
 			hlist_del(&forw_packet->list);
 			batadv_forw_packet_free(forw_packet);
 		}
 	}
 	spin_unlock_bh(&bat_priv->forw_bcast_list_lock);
 	/* free batman packet list */
 	spin_lock_bh(&bat_priv->forw_bat_list_lock);
 	hlist_for_each_entry_safe(forw_packet, safe_tmp_node,
 				  &bat_priv->forw_bat_list, list) {
 		/* if purge_outstanding_packets() was called with an argument
 		 * we delete only packets belonging to the given interface
 		 */
 		if ((hard_iface) &&
 		    (forw_packet->if_incoming != hard_iface))
 			continue;
 		spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 		/* send_outstanding_bat_packet() will lock the list to
 		 * delete the item from the list
 		 */

net/batman-adv/send.h

Diff comments View file @ e300d31

 /* Copyright (C) 2007-2013 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA
  */
 #ifndef _NET_BATMAN_ADV_SEND_H_
 #define _NET_BATMAN_ADV_SEND_H_
 int batadv_send_skb_packet(struct sk_buff *skb,
 			   struct batadv_hard_iface *hard_iface,
 			   const uint8_t *dst_addr);
 int batadv_send_skb_to_orig(struct sk_buff *skb,
 			    struct batadv_orig_node *orig_node,
 			    struct batadv_hard_iface *recv_if);
 void batadv_schedule_bat_ogm(struct batadv_hard_iface *hard_iface);
 int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv,
 				    const struct sk_buff *skb,
 				    unsigned long delay);
 void batadv_send_outstanding_bat_ogm_packet(struct work_struct *work);
 void
 batadv_purge_outstanding_packets(struct batadv_priv *bat_priv,
 				 const struct batadv_hard_iface *hard_iface);
 bool batadv_send_skb_prepare_unicast_4addr(struct batadv_priv *bat_priv,
 					   struct sk_buff *skb,
 					   struct batadv_orig_node *orig_node,
 					   int packet_subtype);
-int batadv_send_skb_generic_unicast(struct batadv_priv *bat_priv,
+int batadv_send_skb_via_tt_generic(struct batadv_priv *bat_priv,
-				    struct sk_buff *skb, int packet_type,
+				   struct sk_buff *skb, int packet_type,
-				    int packet_subtype,
+				   int packet_subtype, unsigned short vid);
-				    unsigned short vid);
+int batadv_send_skb_via_gw(struct batadv_priv *bat_priv, struct sk_buff *skb,
+			   unsigned short vid);
 /**
- * batadv_send_unicast_skb - send the skb encapsulated in a unicast packet
+ * batadv_send_skb_via_tt - send an skb via TT lookup
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: the payload to send
  * @vid: the vid to be used to search the translation table
  *
- * Returns 1 in case of error or 0 otherwise.
+ * Look up the recipient node for the destination address in the ethernet
+ * header via the translation table. Wrap the given skb into a batman-adv
+ * unicast header. Then send this frame to the according destination node.
+ *
+ * Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
  */
-static inline int batadv_send_skb_unicast(struct batadv_priv *bat_priv,
+static inline int batadv_send_skb_via_tt(struct batadv_priv *bat_priv,
-					  struct sk_buff *skb,
+					 struct sk_buff *skb,
-					  unsigned short vid)
+					 unsigned short vid)
 {
-	return batadv_send_skb_generic_unicast(bat_priv, skb, BATADV_UNICAST,
+	return batadv_send_skb_via_tt_generic(bat_priv, skb, BATADV_UNICAST, 0,
-					       0, vid);
+					      vid);
 }
 /**
- * batadv_send_4addr_unicast_skb - send the skb encapsulated in a unicast 4addr
+ * batadv_send_skb_via_tt_4addr - send an skb via TT lookup
- *  packet
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: the payload to send
  * @packet_subtype: the unicast 4addr packet subtype to use
  * @vid: the vid to be used to search the translation table
  *
- * Returns 1 in case of error or 0 otherwise.
+ * Look up the recipient node for the destination address in the ethernet
+ * header via the translation table. Wrap the given skb into a batman-adv
+ * unicast-4addr header. Then send this frame to the according destination
+ * node.
+ *
+ * Returns NET_XMIT_DROP in case of error or NET_XMIT_SUCCESS otherwise.
  */
-static inline int batadv_send_skb_unicast_4addr(struct batadv_priv *bat_priv,
+static inline int batadv_send_skb_via_tt_4addr(struct batadv_priv *bat_priv,
-						struct sk_buff *skb,
+					       struct sk_buff *skb,
-						int packet_subtype,
+					       int packet_subtype,
-						unsigned short vid)
+					       unsigned short vid)
 {
-	return batadv_send_skb_generic_unicast(bat_priv, skb,
+	return batadv_send_skb_via_tt_generic(bat_priv, skb,
-					       BATADV_UNICAST_4ADDR,
+					      BATADV_UNICAST_4ADDR,
-					       packet_subtype, vid);
+					      packet_subtype, vid);
 }
 #endif /* _NET_BATMAN_ADV_SEND_H_ */

net/batman-adv/soft-interface.c

Diff comments View file @ e300d31

 /* Copyright (C) 2007-2013 B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA
  */
 #include "main.h"
 #include "soft-interface.h"
 #include "hard-interface.h"
 #include "distributed-arp-table.h"
 #include "routing.h"
 #include "send.h"
 #include "debugfs.h"
 #include "translation-table.h"
 #include "hash.h"
 #include "gateway_common.h"
 #include "gateway_client.h"
 #include "sysfs.h"
 #include "originator.h"
 #include <linux/slab.h>
 #include <linux/ethtool.h>
 #include <linux/etherdevice.h>
 #include <linux/if_vlan.h>
 #include "bridge_loop_avoidance.h"
 #include "network-coding.h"
 static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
 static void batadv_get_drvinfo(struct net_device *dev,
 			       struct ethtool_drvinfo *info);
 static u32 batadv_get_msglevel(struct net_device *dev);
 static void batadv_set_msglevel(struct net_device *dev, u32 value);
 static u32 batadv_get_link(struct net_device *dev);
 static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data);
 static void batadv_get_ethtool_stats(struct net_device *dev,
 				     struct ethtool_stats *stats, u64 *data);
 static int batadv_get_sset_count(struct net_device *dev, int stringset);
 static const struct ethtool_ops batadv_ethtool_ops = {
 	.get_settings = batadv_get_settings,
 	.get_drvinfo = batadv_get_drvinfo,
 	.get_msglevel = batadv_get_msglevel,
 	.set_msglevel = batadv_set_msglevel,
 	.get_link = batadv_get_link,
 	.get_strings = batadv_get_strings,
 	.get_ethtool_stats = batadv_get_ethtool_stats,
 	.get_sset_count = batadv_get_sset_count,
 };
 int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
 {
 	int result;
 	/* TODO: We must check if we can release all references to non-payload
 	 * data using skb_header_release in our skbs to allow skb_cow_header to
 	 * work optimally. This means that those skbs are not allowed to read
 	 * or write any data which is before the current position of skb->data
 	 * after that call and thus allow other skbs with the same data buffer
 	 * to write freely in that area.
 	 */
 	result = skb_cow_head(skb, len);
 	if (result < 0)
 		return result;
 	skb_push(skb, len);
 	return 0;
 }
 static int batadv_interface_open(struct net_device *dev)
 {
 	netif_start_queue(dev);
 	return 0;
 }
 static int batadv_interface_release(struct net_device *dev)
 {
 	netif_stop_queue(dev);
 	return 0;
 }
 static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct net_device_stats *stats = &bat_priv->stats;
 	stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX);
 	stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES);
 	stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 	stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX);
 	stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES);
 	return stats;
 }
 static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct sockaddr *addr = p;
 	uint8_t old_addr[ETH_ALEN];
 	if (!is_valid_ether_addr(addr->sa_data))
 		return -EADDRNOTAVAIL;
 	memcpy(old_addr, dev->dev_addr, ETH_ALEN);
 	memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
 	/* only modify transtable if it has been initialized before */
 	if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) {
 		batadv_tt_local_remove(bat_priv, old_addr, BATADV_NO_FLAGS,
 				       "mac address changed", false);
 		batadv_tt_local_add(dev, addr->sa_data, BATADV_NO_FLAGS,
 				    BATADV_NULL_IFINDEX);
 	}
 	return 0;
 }
 static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu)
 {
 	/* check ranges */
 	if ((new_mtu < 68) || (new_mtu > batadv_hardif_min_mtu(dev)))
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 /**
  * batadv_interface_set_rx_mode - set the rx mode of a device
  * @dev: registered network device to modify
  *
  * We do not actually need to set any rx filters for the virtual batman
  * soft interface. However a dummy handler enables a user to set static
  * multicast listeners for instance.
  */
 static void batadv_interface_set_rx_mode(struct net_device *dev)
 {
 }
 static int batadv_interface_tx(struct sk_buff *skb,
 			       struct net_device *soft_iface)
 {
 	struct ethhdr *ethhdr;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_hard_iface *primary_if = NULL;
 	struct batadv_bcast_packet *bcast_packet;
 	__be16 ethertype = htons(ETH_P_BATMAN);
 	static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,
 						   0x00, 0x00};
 	static const uint8_t ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00,
 						    0x00, 0x00};
 	struct vlan_ethhdr *vhdr;
 	unsigned int header_len = 0;
 	int data_len = skb->len, ret;
 	unsigned long brd_delay = 1;
 	bool do_bcast = false;
 	unsigned short vid;
 	uint32_t seqno;
 	if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 		goto dropped;
 	soft_iface->trans_start = jiffies;
 	vid = batadv_get_vid(skb, 0);
 	ethhdr = (struct ethhdr *)skb->data;
 	switch (ntohs(ethhdr->h_proto)) {
 	case ETH_P_8021Q:
 		vhdr = (struct vlan_ethhdr *)skb->data;
 		if (vhdr->h_vlan_encapsulated_proto != ethertype)
 			break;
 		/* fall through */
 	case ETH_P_BATMAN:
 		goto dropped;
 	}
 	if (batadv_bla_tx(bat_priv, skb, vid))
 		goto dropped;
 	/* skb->data might have been reallocated by batadv_bla_tx() */
 	ethhdr = (struct ethhdr *)skb->data;
 	/* Register the client MAC in the transtable */
 	if (!is_multicast_ether_addr(ethhdr->h_source))
 		batadv_tt_local_add(soft_iface, ethhdr->h_source, vid,
 				    skb->skb_iif);
 	/* don't accept stp packets. STP does not help in meshes.
 	 * better use the bridge loop avoidance ...
 	 *
 	 * The same goes for ECTP sent at least by some Cisco Switches,
 	 * it might confuse the mesh when used with bridge loop avoidance.
 	 */
 	if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
 		goto dropped;
 	if (batadv_compare_eth(ethhdr->h_dest, ectp_addr))
 		goto dropped;
 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
 		do_bcast = true;
 		switch (atomic_read(&bat_priv->gw_mode)) {
 		case BATADV_GW_MODE_SERVER:
 			/* gateway servers should not send dhcp
 			 * requests into the mesh
 			 */
 			ret = batadv_gw_is_dhcp_target(skb, &header_len);
 			if (ret)
 				goto dropped;
 			break;
 		case BATADV_GW_MODE_CLIENT:
 			/* gateway clients should send dhcp requests
 			 * via unicast to their gateway
 			 */
 			ret = batadv_gw_is_dhcp_target(skb, &header_len);
 			if (ret)
 				do_bcast = false;
 			break;
 		case BATADV_GW_MODE_OFF:
 		default:
 			break;
 		}
 		/* reminder: ethhdr might have become unusable from here on
 		 * (batadv_gw_is_dhcp_target() might have reallocated skb data)
 		 */
 	}
 	batadv_skb_set_priority(skb, 0);
 	/* ethernet packet should be broadcasted */
 	if (do_bcast) {
 		primary_if = batadv_primary_if_get_selected(bat_priv);
 		if (!primary_if)
 			goto dropped;
 		/* in case of ARP request, we do not immediately broadcasti the
 		 * packet, instead we first wait for DAT to try to retrieve the
 		 * correct ARP entry
 		 */
 		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
 			brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);
 		if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
 			goto dropped;
 		bcast_packet = (struct batadv_bcast_packet *)skb->data;
 		bcast_packet->header.version = BATADV_COMPAT_VERSION;
 		bcast_packet->header.ttl = BATADV_TTL;
 		/* batman packet type: broadcast */
 		bcast_packet->header.packet_type = BATADV_BCAST;
 		bcast_packet->reserved = 0;
 		/* hw address of first interface is the orig mac because only
 		 * this mac is known throughout the mesh
 		 */
 		memcpy(bcast_packet->orig,
 		       primary_if->net_dev->dev_addr, ETH_ALEN);
 		/* set broadcast sequence number */
 		seqno = atomic_inc_return(&bat_priv->bcast_seqno);
 		bcast_packet->seqno = htonl(seqno);
 		batadv_add_bcast_packet_to_list(bat_priv, skb, brd_delay);
 		/* a copy is stored in the bcast list, therefore removing
 		 * the original skb.
 		 */
 		kfree_skb(skb);
 	/* unicast packet */
 	} else {
 		if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_OFF) {
 			ret = batadv_gw_out_of_range(bat_priv, skb);
 			if (ret)
 				goto dropped;
 		}
 		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
 			goto dropped;
 		batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb);
-		ret = batadv_send_skb_unicast(bat_priv, skb, vid);
+		if (is_multicast_ether_addr(ethhdr->h_dest))
-		if (ret != 0)
+			ret = batadv_send_skb_via_gw(bat_priv, skb, vid);
+		else
+			ret = batadv_send_skb_via_tt(bat_priv, skb, vid);
+		if (ret == NET_XMIT_DROP)
 			goto dropped_freed;
 	}
 	batadv_inc_counter(bat_priv, BATADV_CNT_TX);
 	batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
 	goto end;
 dropped:
 	kfree_skb(skb);
 dropped_freed:
 	batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 end:
 	if (primary_if)
 		batadv_hardif_free_ref(primary_if);
 	return NETDEV_TX_OK;
 }
 void batadv_interface_rx(struct net_device *soft_iface,
 			 struct sk_buff *skb, struct batadv_hard_iface *recv_if,
 			 int hdr_size, struct batadv_orig_node *orig_node)
 {
 	struct batadv_header *batadv_header = (struct batadv_header *)skb->data;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	__be16 ethertype = htons(ETH_P_BATMAN);
 	struct vlan_ethhdr *vhdr;
 	struct ethhdr *ethhdr;
 	unsigned short vid;
 	bool is_bcast;
 	is_bcast = (batadv_header->packet_type == BATADV_BCAST);
 	/* check if enough space is available for pulling, and pull */
 	if (!pskb_may_pull(skb, hdr_size))
 		goto dropped;
 	skb_pull_rcsum(skb, hdr_size);
 	skb_reset_mac_header(skb);
 	vid = batadv_get_vid(skb, hdr_size);
 	ethhdr = eth_hdr(skb);
 	switch (ntohs(ethhdr->h_proto)) {
 	case ETH_P_8021Q:
 		vhdr = (struct vlan_ethhdr *)skb->data;
 		if (vhdr->h_vlan_encapsulated_proto != ethertype)
 			break;
 		/* fall through */
 	case ETH_P_BATMAN:
 		goto dropped;
 	}
 	/* skb->dev & skb->pkt_type are set here */
 	if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
 		goto dropped;
 	skb->protocol = eth_type_trans(skb, soft_iface);
 	/* should not be necessary anymore as we use skb_pull_rcsum()
 	 * TODO: please verify this and remove this TODO
 	 * -- Dec 21st 2009, Simon Wunderlich
 	 */
 	/* skb->ip_summed = CHECKSUM_UNNECESSARY; */
 	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
 	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
 			   skb->len + ETH_HLEN);
 	soft_iface->last_rx = jiffies;
 	/* Let the bridge loop avoidance check the packet. If will
 	 * not handle it, we can safely push it up.
 	 */
 	if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
 		goto out;
 	if (orig_node)
 		batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
 						     ethhdr->h_source, vid);
 	if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest,
 				  vid))
 		goto dropped;
 	netif_rx(skb);
 	goto out;
 dropped:
 	kfree_skb(skb);
 out:
 	return;
 }
 /**
  * batadv_softif_vlan_free_ref - decrease the vlan object refcounter and
  *  possibly free it
  * @softif_vlan: the vlan object to release
  */
 void batadv_softif_vlan_free_ref(struct batadv_softif_vlan *softif_vlan)
 {
 	if (atomic_dec_and_test(&softif_vlan->refcount))
 		kfree_rcu(softif_vlan, rcu);
 }
 /**
  * batadv_softif_vlan_get - get the vlan object for a specific vid
  * @bat_priv: the bat priv with all the soft interface information
  * @vid: the identifier of the vlan object to retrieve
  *
  * Returns the private data of the vlan matching the vid passed as argument or
  * NULL otherwise. The refcounter of the returned object is incremented by 1.
  */
 struct batadv_softif_vlan *batadv_softif_vlan_get(struct batadv_priv *bat_priv,
 						  unsigned short vid)
 {
 	struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
 		if (vlan_tmp->vid != vid)
 			continue;
 		if (!atomic_inc_not_zero(&vlan_tmp->refcount))
 			continue;
 		vlan = vlan_tmp;
 		break;
 	}
 	rcu_read_unlock();
 	return vlan;
 }
 /**
  * batadv_create_vlan - allocate the needed resources for a new vlan
  * @bat_priv: the bat priv with all the soft interface information
  * @vid: the VLAN identifier
  *
  * Returns 0 on success, a negative error otherwise.
  */
 int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid)
 {
 	struct batadv_softif_vlan *vlan;
 	int err;
 	vlan = batadv_softif_vlan_get(bat_priv, vid);
 	if (vlan) {
 		batadv_softif_vlan_free_ref(vlan);
 		return -EEXIST;
 	}
 	vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC);
 	if (!vlan)
 		return -ENOMEM;
 	vlan->vid = vid;
 	atomic_set(&vlan->refcount, 1);
 	atomic_set(&vlan->ap_isolation, 0);
 	err = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan);
 	if (err) {
 		kfree(vlan);
 		return err;
 	}
 	/* add a new TT local entry. This one will be marked with the NOPURGE
 	 * flag
 	 */
 	batadv_tt_local_add(bat_priv->soft_iface,
 			    bat_priv->soft_iface->dev_addr, vid,
 			    BATADV_NULL_IFINDEX);
 	spin_lock_bh(&bat_priv->softif_vlan_list_lock);
 	hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list);
 	spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 	return 0;
 }
 /**
  * batadv_softif_destroy_vlan - remove and destroy a softif_vlan object
  * @bat_priv: the bat priv with all the soft interface information
  * @vlan: the object to remove
  */
 static void batadv_softif_destroy_vlan(struct batadv_priv *bat_priv,
 				       struct batadv_softif_vlan *vlan)
 {
 	spin_lock_bh(&bat_priv->softif_vlan_list_lock);
 	hlist_del_rcu(&vlan->list);
 	spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 	batadv_sysfs_del_vlan(bat_priv, vlan);
 	/* explicitly remove the associated TT local entry because it is marked
 	 * with the NOPURGE flag
 	 */
 	batadv_tt_local_remove(bat_priv, bat_priv->soft_iface->dev_addr,
 			       vlan->vid, "vlan interface destroyed", false);
 	batadv_softif_vlan_free_ref(vlan);
 }
 /**
  * batadv_interface_add_vid - ndo_add_vid API implementation
  * @dev: the netdev of the mesh interface
  * @vid: identifier of the new vlan
  *
  * Set up all the internal structures for handling the new vlan on top of the
  * mesh interface
  *
  * Returns 0 on success or a negative error code in case of failure.
  */
 static int batadv_interface_add_vid(struct net_device *dev, __be16 proto,
 				    unsigned short vid)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	/* only 802.1Q vlans are supported.
 	 * batman-adv does not know how to handle other types
 	 */
 	if (proto != htons(ETH_P_8021Q))
 		return -EINVAL;
 	vid |= BATADV_VLAN_HAS_TAG;
 	return batadv_softif_create_vlan(bat_priv, vid);
 }
 /**
  * batadv_interface_kill_vid - ndo_kill_vid API implementation
  * @dev: the netdev of the mesh interface
  * @vid: identifier of the deleted vlan
  *
  * Destroy all the internal structures used to handle the vlan identified by vid
  * on top of the mesh interface
  *
  * Returns 0 on success, -EINVAL if the specified prototype is not ETH_P_8021Q
  * or -ENOENT if the specified vlan id wasn't registered.
  */
 static int batadv_interface_kill_vid(struct net_device *dev, __be16 proto,
 				     unsigned short vid)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_softif_vlan *vlan;
 	/* only 802.1Q vlans are supported. batman-adv does not know how to
 	 * handle other types
 	 */
 	if (proto != htons(ETH_P_8021Q))
 		return -EINVAL;
 	vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG);
 	if (!vlan)
 		return -ENOENT;
 	batadv_softif_destroy_vlan(bat_priv, vlan);
 	/* finally free the vlan object */
 	batadv_softif_vlan_free_ref(vlan);
 	return 0;
 }
 /* batman-adv network devices have devices nesting below it and are a special
  * "super class" of normal network devices; split their locks off into a
  * separate class since they always nest.
  */
 static struct lock_class_key batadv_netdev_xmit_lock_key;
 static struct lock_class_key batadv_netdev_addr_lock_key;
 /**
  * batadv_set_lockdep_class_one - Set lockdep class for a single tx queue
  * @dev: device which owns the tx queue
  * @txq: tx queue to modify
  * @_unused: always NULL
  */
 static void batadv_set_lockdep_class_one(struct net_device *dev,
 					 struct netdev_queue *txq,
 					 void *_unused)
 {
 	lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
 }
 /**
  * batadv_set_lockdep_class - Set txq and addr_list lockdep class
  * @dev: network device to modify
  */
 static void batadv_set_lockdep_class(struct net_device *dev)
 {
 	lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
 	netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
 }
 /**
  * batadv_softif_destroy_finish - cleans up the remains of a softif
  * @work: work queue item
  *
  * Free the parts of the soft interface which can not be removed under
  * rtnl lock (to prevent deadlock situations).
  */
 static void batadv_softif_destroy_finish(struct work_struct *work)
 {
 	struct batadv_softif_vlan *vlan;
 	struct batadv_priv *bat_priv;
 	struct net_device *soft_iface;
 	bat_priv = container_of(work, struct batadv_priv,
 				cleanup_work);
 	soft_iface = bat_priv->soft_iface;
 	/* destroy the "untagged" VLAN */
 	vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
 	if (vlan) {
 		batadv_softif_destroy_vlan(bat_priv, vlan);
 		batadv_softif_vlan_free_ref(vlan);
 	}
 	batadv_sysfs_del_meshif(soft_iface);
 	rtnl_lock();
 	unregister_netdevice(soft_iface);
 	rtnl_unlock();
 }
 /**
  * batadv_softif_init_late - late stage initialization of soft interface
  * @dev: registered network device to modify
  *
  * Returns error code on failures
  */
 static int batadv_softif_init_late(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv;
 	uint32_t random_seqno;
 	int ret;
 	size_t cnt_len = sizeof(uint64_t) * BATADV_CNT_NUM;
 	batadv_set_lockdep_class(dev);
 	bat_priv = netdev_priv(dev);
 	bat_priv->soft_iface = dev;
 	INIT_WORK(&bat_priv->cleanup_work, batadv_softif_destroy_finish);
 	/* batadv_interface_stats() needs to be available as soon as
 	 * register_netdevice() has been called
 	 */
 	bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(uint64_t));
 	if (!bat_priv->bat_counters)
 		return -ENOMEM;
 	atomic_set(&bat_priv->aggregated_ogms, 1);
 	atomic_set(&bat_priv->bonding, 0);
 #ifdef CONFIG_BATMAN_ADV_BLA
 	atomic_set(&bat_priv->bridge_loop_avoidance, 0);
 #endif
 #ifdef CONFIG_BATMAN_ADV_DAT
 	atomic_set(&bat_priv->distributed_arp_table, 1);
 #endif
 	atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF);
 	atomic_set(&bat_priv->gw_sel_class, 20);
 	atomic_set(&bat_priv->gw.bandwidth_down, 100);
 	atomic_set(&bat_priv->gw.bandwidth_up, 20);
 	atomic_set(&bat_priv->orig_interval, 1000);
 	atomic_set(&bat_priv->hop_penalty, 30);
 #ifdef CONFIG_BATMAN_ADV_DEBUG
 	atomic_set(&bat_priv->log_level, 0);
 #endif
 	atomic_set(&bat_priv->fragmentation, 1);
 	atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
 	atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
 	atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
 	atomic_set(&bat_priv->bcast_seqno, 1);
 	atomic_set(&bat_priv->tt.vn, 0);
 	atomic_set(&bat_priv->tt.local_changes, 0);
 	atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
 #ifdef CONFIG_BATMAN_ADV_BLA
 	atomic_set(&bat_priv->bla.num_requests, 0);
 #endif
 	bat_priv->tt.last_changeset = NULL;
 	bat_priv->tt.last_changeset_len = 0;
 	/* randomize initial seqno to avoid collision */
 	get_random_bytes(&random_seqno, sizeof(random_seqno));
 	atomic_set(&bat_priv->frag_seqno, random_seqno);
 	bat_priv->primary_if = NULL;
 	bat_priv->num_ifaces = 0;
 	batadv_nc_init_bat_priv(bat_priv);
 	ret = batadv_algo_select(bat_priv, batadv_routing_algo);
 	if (ret < 0)
 		goto free_bat_counters;
 	ret = batadv_debugfs_add_meshif(dev);
 	if (ret < 0)
 		goto free_bat_counters;
 	ret = batadv_mesh_init(dev);
 	if (ret < 0)
 		goto unreg_debugfs;
 	return 0;
 unreg_debugfs:
 	batadv_debugfs_del_meshif(dev);
 free_bat_counters:
 	free_percpu(bat_priv->bat_counters);
 	bat_priv->bat_counters = NULL;
 	return ret;
 }
 /**
  * batadv_softif_slave_add - Add a slave interface to a batadv_soft_interface
  * @dev: batadv_soft_interface used as master interface
  * @slave_dev: net_device which should become the slave interface
  *
  * Return 0 if successful or error otherwise.
  */
 static int batadv_softif_slave_add(struct net_device *dev,
 				   struct net_device *slave_dev)
 {
 	struct batadv_hard_iface *hard_iface;
 	int ret = -EINVAL;
 	hard_iface = batadv_hardif_get_by_netdev(slave_dev);
 	if (!hard_iface || hard_iface->soft_iface != NULL)
 		goto out;
 	ret = batadv_hardif_enable_interface(hard_iface, dev->name);
 out:
 	if (hard_iface)
 		batadv_hardif_free_ref(hard_iface);
 	return ret;
 }
 /**
  * batadv_softif_slave_del - Delete a slave iface from a batadv_soft_interface
  * @dev: batadv_soft_interface used as master interface
  * @slave_dev: net_device which should be removed from the master interface
  *
  * Return 0 if successful or error otherwise.
  */
 static int batadv_softif_slave_del(struct net_device *dev,
 				   struct net_device *slave_dev)
 {
 	struct batadv_hard_iface *hard_iface;
 	int ret = -EINVAL;
 	hard_iface = batadv_hardif_get_by_netdev(slave_dev);
 	if (!hard_iface || hard_iface->soft_iface != dev)
 		goto out;
 	batadv_hardif_disable_interface(hard_iface, BATADV_IF_CLEANUP_KEEP);
 	ret = 0;
 out:
 	if (hard_iface)
 		batadv_hardif_free_ref(hard_iface);
 	return ret;
 }
 static const struct net_device_ops batadv_netdev_ops = {
 	.ndo_init = batadv_softif_init_late,
 	.ndo_open = batadv_interface_open,
 	.ndo_stop = batadv_interface_release,
 	.ndo_get_stats = batadv_interface_stats,
 	.ndo_vlan_rx_add_vid = batadv_interface_add_vid,
 	.ndo_vlan_rx_kill_vid = batadv_interface_kill_vid,
 	.ndo_set_mac_address = batadv_interface_set_mac_addr,
 	.ndo_change_mtu = batadv_interface_change_mtu,
 	.ndo_set_rx_mode = batadv_interface_set_rx_mode,
 	.ndo_start_xmit = batadv_interface_tx,
 	.ndo_validate_addr = eth_validate_addr,
 	.ndo_add_slave = batadv_softif_slave_add,
 	.ndo_del_slave = batadv_softif_slave_del,
 };
 /**
  * batadv_softif_free - Deconstructor of batadv_soft_interface
  * @dev: Device to cleanup and remove
  */
 static void batadv_softif_free(struct net_device *dev)
 {
 	batadv_debugfs_del_meshif(dev);
 	batadv_mesh_free(dev);
 	/* some scheduled RCU callbacks need the bat_priv struct to accomplish
 	 * their tasks. Wait for them all to be finished before freeing the
 	 * netdev and its private data (bat_priv)
 	 */
 	rcu_barrier();
 	free_netdev(dev);
 }
 /**
  * batadv_softif_init_early - early stage initialization of soft interface
  * @dev: registered network device to modify
  */
 static void batadv_softif_init_early(struct net_device *dev)
 {
 	struct batadv_priv *priv = netdev_priv(dev);
 	ether_setup(dev);
 	dev->netdev_ops = &batadv_netdev_ops;
 	dev->destructor = batadv_softif_free;
 	dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 	dev->tx_queue_len = 0;
 	/* can't call min_mtu, because the needed variables
 	 * have not been initialized yet
 	 */
 	dev->mtu = ETH_DATA_LEN;
 	/* reserve more space in the skbuff for our header */
 	dev->hard_header_len = batadv_max_header_len();
 	/* generate random address */
 	eth_hw_addr_random(dev);
 	SET_ETHTOOL_OPS(dev, &batadv_ethtool_ops);
 	memset(priv, 0, sizeof(*priv));
 }
 struct net_device *batadv_softif_create(const char *name)
 {
 	struct net_device *soft_iface;
 	int ret;
 	soft_iface = alloc_netdev(sizeof(struct batadv_priv), name,
 				  batadv_softif_init_early);
 	if (!soft_iface)
 		return NULL;
 	soft_iface->rtnl_link_ops = &batadv_link_ops;
 	ret = register_netdevice(soft_iface);
 	if (ret < 0) {
 		pr_err("Unable to register the batman interface '%s': %i\n",
 		       name, ret);
 		free_netdev(soft_iface);
 		return NULL;
 	}
 	return soft_iface;
 }
 /**
  * batadv_softif_destroy_sysfs - deletion of batadv_soft_interface via sysfs
  * @soft_iface: the to-be-removed batman-adv interface
  */
 void batadv_softif_destroy_sysfs(struct net_device *soft_iface)
 {
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	queue_work(batadv_event_workqueue, &bat_priv->cleanup_work);
 }
 /**
  * batadv_softif_destroy_netlink - deletion of batadv_soft_interface via netlink
  * @soft_iface: the to-be-removed batman-adv interface
  * @head: list pointer
  */
 static void batadv_softif_destroy_netlink(struct net_device *soft_iface,
 					  struct list_head *head)
 {
 	struct batadv_hard_iface *hard_iface;
 	list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
 		if (hard_iface->soft_iface == soft_iface)
 			batadv_hardif_disable_interface(hard_iface,
 							BATADV_IF_CLEANUP_KEEP);
 	}
 	batadv_sysfs_del_meshif(soft_iface);
 	unregister_netdevice_queue(soft_iface, head);
 }
 int batadv_softif_is_valid(const struct net_device *net_dev)
 {
 	if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
 		return 1;
 	return 0;
 }
 struct rtnl_link_ops batadv_link_ops __read_mostly = {
 	.kind		= "batadv",
 	.priv_size	= sizeof(struct batadv_priv),
 	.setup		= batadv_softif_init_early,
 	.dellink	= batadv_softif_destroy_netlink,
 };
 /* ethtool */
 static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
 	cmd->supported = 0;
 	cmd->advertising = 0;
 	ethtool_cmd_speed_set(cmd, SPEED_10);
 	cmd->duplex = DUPLEX_FULL;
 	cmd->port = PORT_TP;
 	cmd->phy_address = 0;
 	cmd->transceiver = XCVR_INTERNAL;
 	cmd->autoneg = AUTONEG_DISABLE;
 	cmd->maxtxpkt = 0;
 	cmd->maxrxpkt = 0;
 	return 0;
 }
 static void batadv_get_drvinfo(struct net_device *dev,
 			       struct ethtool_drvinfo *info)
 {
 	strlcpy(info->driver, "B.A.T.M.A.N. advanced", sizeof(info->driver));
 	strlcpy(info->version, BATADV_SOURCE_VERSION, sizeof(info->version));
 	strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
 	strlcpy(info->bus_info, "batman", sizeof(info->bus_info));
 }
 static u32 batadv_get_msglevel(struct net_device *dev)
 {
 	return -EOPNOTSUPP;
 }
 static void batadv_set_msglevel(struct net_device *dev, u32 value)
 {
 }
 static u32 batadv_get_link(struct net_device *dev)
 {
 	return 1;
 }
 /* Inspired by drivers/net/ethernet/dlink/sundance.c:1702
  * Declare each description string in struct.name[] to get fixed sized buffer
  * and compile time checking for strings longer than ETH_GSTRING_LEN.
  */
 static const struct {
 	const char name[ETH_GSTRING_LEN];
 } batadv_counters_strings[] = {
 	{ "tx" },
 	{ "tx_bytes" },
 	{ "tx_dropped" },
 	{ "rx" },
 	{ "rx_bytes" },
 	{ "forward" },
 	{ "forward_bytes" },
 	{ "mgmt_tx" },
 	{ "mgmt_tx_bytes" },
 	{ "mgmt_rx" },
 	{ "mgmt_rx_bytes" },
 	{ "frag_tx" },
 	{ "frag_tx_bytes" },
 	{ "frag_rx" },
 	{ "frag_rx_bytes" },
 	{ "frag_fwd" },
 	{ "frag_fwd_bytes" },
 	{ "tt_request_tx" },
 	{ "tt_request_rx" },
 	{ "tt_response_tx" },
 	{ "tt_response_rx" },
 	{ "tt_roam_adv_tx" },
 	{ "tt_roam_adv_rx" },
 #ifdef CONFIG_BATMAN_ADV_DAT
 	{ "dat_get_tx" },
 	{ "dat_get_rx" },
 	{ "dat_put_tx" },
 	{ "dat_put_rx" },
 	{ "dat_cached_reply_tx" },
 #endif
 #ifdef CONFIG_BATMAN_ADV_NC
 	{ "nc_code" },
 	{ "nc_code_bytes" },
 	{ "nc_recode" },
 	{ "nc_recode_bytes" },
 	{ "nc_buffer" },
 	{ "nc_decode" },
 	{ "nc_decode_bytes" },
 	{ "nc_decode_failed" },
 	{ "nc_sniffed" },
 #endif
 };
 static void batadv_get_strings(struct net_device *dev, uint32_t stringset,
 			       uint8_t *data)
 {
 	if (stringset == ETH_SS_STATS)
 		memcpy(data, batadv_counters_strings,
 		       sizeof(batadv_counters_strings));
 }
 static void batadv_get_ethtool_stats(struct net_device *dev,
 				     struct ethtool_stats *stats,
 				     uint64_t *data)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	int i;
 	for (i = 0; i < BATADV_CNT_NUM; i++)
 		data[i] = batadv_sum_counter(bat_priv, i);
 }
 static int batadv_get_sset_count(struct net_device *dev, int stringset)
 {
 	if (stringset == ETH_SS_STATS)
 		return BATADV_CNT_NUM;
 	return -EOPNOTSUPP;
 }