blob: c49cf24ab33d7c65665f560b650cf4f04e5f7d08 [file] [log] [blame]
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001/* Copyright (C) 2011-2012 B.A.T.M.A.N. contributors:
Simon Wunderlich23721382012-01-22 20:00:19 +01002 *
3 * Simon Wunderlich
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA
Simon Wunderlich23721382012-01-22 20:00:19 +010018 */
19
20#include "main.h"
21#include "hash.h"
22#include "hard-interface.h"
23#include "originator.h"
24#include "bridge_loop_avoidance.h"
Simon Wunderlich20ff9d52012-01-22 20:00:23 +010025#include "translation-table.h"
Simon Wunderlich23721382012-01-22 20:00:19 +010026#include "send.h"
27
28#include <linux/etherdevice.h>
29#include <linux/crc16.h>
30#include <linux/if_arp.h>
31#include <net/arp.h>
32#include <linux/if_vlan.h>
33
Sven Eckelmann3b300de2012-05-12 18:33:53 +020034static const uint8_t batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
Simon Wunderlich23721382012-01-22 20:00:19 +010035
Sven Eckelmann3b300de2012-05-12 18:33:53 +020036static void batadv_bla_periodic_work(struct work_struct *work);
Sven Eckelmann56303d32012-06-05 22:31:31 +020037static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
38 struct batadv_backbone_gw *backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +010039
40/* return the index of the claim */
Sven Eckelmann3b300de2012-05-12 18:33:53 +020041static inline uint32_t batadv_choose_claim(const void *data, uint32_t size)
Simon Wunderlich23721382012-01-22 20:00:19 +010042{
Simon Wunderlich07568d02012-08-30 18:22:27 +020043 struct batadv_claim *claim = (struct batadv_claim *)data;
Simon Wunderlich23721382012-01-22 20:00:19 +010044 uint32_t hash = 0;
Simon Wunderlich23721382012-01-22 20:00:19 +010045
Simon Wunderlich07568d02012-08-30 18:22:27 +020046 hash = batadv_hash_bytes(hash, &claim->addr, sizeof(claim->addr));
47 hash = batadv_hash_bytes(hash, &claim->vid, sizeof(claim->vid));
Simon Wunderlich23721382012-01-22 20:00:19 +010048
49 hash += (hash << 3);
50 hash ^= (hash >> 11);
51 hash += (hash << 15);
52
53 return hash % size;
54}
55
56/* return the index of the backbone gateway */
Sven Eckelmann3b300de2012-05-12 18:33:53 +020057static inline uint32_t batadv_choose_backbone_gw(const void *data,
58 uint32_t size)
Simon Wunderlich23721382012-01-22 20:00:19 +010059{
Simon Wunderlich07568d02012-08-30 18:22:27 +020060 struct batadv_claim *claim = (struct batadv_claim *)data;
Simon Wunderlich23721382012-01-22 20:00:19 +010061 uint32_t hash = 0;
Simon Wunderlich23721382012-01-22 20:00:19 +010062
Simon Wunderlich07568d02012-08-30 18:22:27 +020063 hash = batadv_hash_bytes(hash, &claim->addr, sizeof(claim->addr));
64 hash = batadv_hash_bytes(hash, &claim->vid, sizeof(claim->vid));
Simon Wunderlich23721382012-01-22 20:00:19 +010065
66 hash += (hash << 3);
67 hash ^= (hash >> 11);
68 hash += (hash << 15);
69
70 return hash % size;
71}
72
73
74/* compares address and vid of two backbone gws */
Sven Eckelmann3b300de2012-05-12 18:33:53 +020075static int batadv_compare_backbone_gw(const struct hlist_node *node,
76 const void *data2)
Simon Wunderlich23721382012-01-22 20:00:19 +010077{
Sven Eckelmann56303d32012-06-05 22:31:31 +020078 const void *data1 = container_of(node, struct batadv_backbone_gw,
Simon Wunderlich23721382012-01-22 20:00:19 +010079 hash_entry);
80
81 return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0);
82}
83
84/* compares address and vid of two claims */
Sven Eckelmann3b300de2012-05-12 18:33:53 +020085static int batadv_compare_claim(const struct hlist_node *node,
86 const void *data2)
Simon Wunderlich23721382012-01-22 20:00:19 +010087{
Sven Eckelmann56303d32012-06-05 22:31:31 +020088 const void *data1 = container_of(node, struct batadv_claim,
Simon Wunderlich23721382012-01-22 20:00:19 +010089 hash_entry);
90
91 return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0);
92}
93
94/* free a backbone gw */
Sven Eckelmann56303d32012-06-05 22:31:31 +020095static void batadv_backbone_gw_free_ref(struct batadv_backbone_gw *backbone_gw)
Simon Wunderlich23721382012-01-22 20:00:19 +010096{
97 if (atomic_dec_and_test(&backbone_gw->refcount))
98 kfree_rcu(backbone_gw, rcu);
99}
100
101/* finally deinitialize the claim */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200102static void batadv_claim_free_rcu(struct rcu_head *rcu)
Simon Wunderlich23721382012-01-22 20:00:19 +0100103{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200104 struct batadv_claim *claim;
Simon Wunderlich23721382012-01-22 20:00:19 +0100105
Sven Eckelmann56303d32012-06-05 22:31:31 +0200106 claim = container_of(rcu, struct batadv_claim, rcu);
Simon Wunderlich23721382012-01-22 20:00:19 +0100107
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200108 batadv_backbone_gw_free_ref(claim->backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100109 kfree(claim);
110}
111
112/* free a claim, call claim_free_rcu if its the last reference */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200113static void batadv_claim_free_ref(struct batadv_claim *claim)
Simon Wunderlich23721382012-01-22 20:00:19 +0100114{
115 if (atomic_dec_and_test(&claim->refcount))
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200116 call_rcu(&claim->rcu, batadv_claim_free_rcu);
Simon Wunderlich23721382012-01-22 20:00:19 +0100117}
118
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200119/* @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100120 * @data: search data (may be local/static data)
121 *
122 * looks for a claim in the hash, and returns it if found
123 * or NULL otherwise.
124 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200125static struct batadv_claim *batadv_claim_hash_find(struct batadv_priv *bat_priv,
126 struct batadv_claim *data)
Simon Wunderlich23721382012-01-22 20:00:19 +0100127{
Sven Eckelmann807736f2012-07-15 22:26:51 +0200128 struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100129 struct hlist_head *head;
130 struct hlist_node *node;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200131 struct batadv_claim *claim;
132 struct batadv_claim *claim_tmp = NULL;
Simon Wunderlich23721382012-01-22 20:00:19 +0100133 int index;
134
135 if (!hash)
136 return NULL;
137
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200138 index = batadv_choose_claim(data, hash->size);
Simon Wunderlich23721382012-01-22 20:00:19 +0100139 head = &hash->table[index];
140
141 rcu_read_lock();
142 hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200143 if (!batadv_compare_claim(&claim->hash_entry, data))
Simon Wunderlich23721382012-01-22 20:00:19 +0100144 continue;
145
146 if (!atomic_inc_not_zero(&claim->refcount))
147 continue;
148
149 claim_tmp = claim;
150 break;
151 }
152 rcu_read_unlock();
153
154 return claim_tmp;
155}
156
Ben Hutchings2c530402012-07-10 10:55:09 +0000157/**
158 * batadv_backbone_hash_find - looks for a claim in the hash
159 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100160 * @addr: the address of the originator
161 * @vid: the VLAN ID
162 *
Ben Hutchings2c530402012-07-10 10:55:09 +0000163 * Returns claim if found or NULL otherwise.
Simon Wunderlich23721382012-01-22 20:00:19 +0100164 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200165static struct batadv_backbone_gw *
166batadv_backbone_hash_find(struct batadv_priv *bat_priv,
167 uint8_t *addr, short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100168{
Sven Eckelmann807736f2012-07-15 22:26:51 +0200169 struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100170 struct hlist_head *head;
171 struct hlist_node *node;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200172 struct batadv_backbone_gw search_entry, *backbone_gw;
173 struct batadv_backbone_gw *backbone_gw_tmp = NULL;
Simon Wunderlich23721382012-01-22 20:00:19 +0100174 int index;
175
176 if (!hash)
177 return NULL;
178
179 memcpy(search_entry.orig, addr, ETH_ALEN);
180 search_entry.vid = vid;
181
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200182 index = batadv_choose_backbone_gw(&search_entry, hash->size);
Simon Wunderlich23721382012-01-22 20:00:19 +0100183 head = &hash->table[index];
184
185 rcu_read_lock();
186 hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200187 if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
188 &search_entry))
Simon Wunderlich23721382012-01-22 20:00:19 +0100189 continue;
190
191 if (!atomic_inc_not_zero(&backbone_gw->refcount))
192 continue;
193
194 backbone_gw_tmp = backbone_gw;
195 break;
196 }
197 rcu_read_unlock();
198
199 return backbone_gw_tmp;
200}
201
202/* delete all claims for a backbone */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200203static void
204batadv_bla_del_backbone_claims(struct batadv_backbone_gw *backbone_gw)
Simon Wunderlich23721382012-01-22 20:00:19 +0100205{
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200206 struct batadv_hashtable *hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100207 struct hlist_node *node, *node_tmp;
208 struct hlist_head *head;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200209 struct batadv_claim *claim;
Simon Wunderlich23721382012-01-22 20:00:19 +0100210 int i;
211 spinlock_t *list_lock; /* protects write access to the hash lists */
212
Sven Eckelmann807736f2012-07-15 22:26:51 +0200213 hash = backbone_gw->bat_priv->bla.claim_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100214 if (!hash)
215 return;
216
217 for (i = 0; i < hash->size; i++) {
218 head = &hash->table[i];
219 list_lock = &hash->list_locks[i];
220
221 spin_lock_bh(list_lock);
222 hlist_for_each_entry_safe(claim, node, node_tmp,
223 head, hash_entry) {
224
225 if (claim->backbone_gw != backbone_gw)
226 continue;
227
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200228 batadv_claim_free_ref(claim);
Simon Wunderlich23721382012-01-22 20:00:19 +0100229 hlist_del_rcu(node);
230 }
231 spin_unlock_bh(list_lock);
232 }
233
234 /* all claims gone, intialize CRC */
Sven Eckelmann3964f722012-06-03 22:19:10 +0200235 backbone_gw->crc = BATADV_BLA_CRC_INIT;
Simon Wunderlich23721382012-01-22 20:00:19 +0100236}
237
Ben Hutchings2c530402012-07-10 10:55:09 +0000238/**
239 * batadv_bla_send_claim - sends a claim frame according to the provided info
240 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100241 * @orig: the mac address to be announced within the claim
242 * @vid: the VLAN ID
243 * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
Simon Wunderlich23721382012-01-22 20:00:19 +0100244 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200245static void batadv_bla_send_claim(struct batadv_priv *bat_priv, uint8_t *mac,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200246 short vid, int claimtype)
Simon Wunderlich23721382012-01-22 20:00:19 +0100247{
248 struct sk_buff *skb;
249 struct ethhdr *ethhdr;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200250 struct batadv_hard_iface *primary_if;
Simon Wunderlich23721382012-01-22 20:00:19 +0100251 struct net_device *soft_iface;
252 uint8_t *hw_src;
Sven Eckelmann96412692012-06-05 22:31:30 +0200253 struct batadv_bla_claim_dst local_claim_dest;
Al Viro3e2f1a12012-04-22 07:47:50 +0100254 __be32 zeroip = 0;
Simon Wunderlich23721382012-01-22 20:00:19 +0100255
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200256 primary_if = batadv_primary_if_get_selected(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +0100257 if (!primary_if)
258 return;
259
Sven Eckelmann807736f2012-07-15 22:26:51 +0200260 memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100261 sizeof(local_claim_dest));
Simon Wunderlich23721382012-01-22 20:00:19 +0100262 local_claim_dest.type = claimtype;
263
264 soft_iface = primary_if->soft_iface;
265
266 skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
267 /* IP DST: 0.0.0.0 */
268 zeroip,
269 primary_if->soft_iface,
270 /* IP SRC: 0.0.0.0 */
271 zeroip,
272 /* Ethernet DST: Broadcast */
273 NULL,
274 /* Ethernet SRC/HW SRC: originator mac */
275 primary_if->net_dev->dev_addr,
Simon Wunderlich99e966f2012-06-23 12:34:17 +0200276 /* HW DST: FF:43:05:XX:YY:YY
Simon Wunderlich23721382012-01-22 20:00:19 +0100277 * with XX = claim type
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100278 * and YY:YY = group id
Simon Wunderlich23721382012-01-22 20:00:19 +0100279 */
280 (uint8_t *)&local_claim_dest);
281
282 if (!skb)
283 goto out;
284
285 ethhdr = (struct ethhdr *)skb->data;
Antonio Quartulli0d125072012-02-18 11:27:34 +0100286 hw_src = (uint8_t *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
Simon Wunderlich23721382012-01-22 20:00:19 +0100287
288 /* now we pretend that the client would have sent this ... */
289 switch (claimtype) {
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200290 case BATADV_CLAIM_TYPE_CLAIM:
Simon Wunderlich23721382012-01-22 20:00:19 +0100291 /* normal claim frame
292 * set Ethernet SRC to the clients mac
293 */
294 memcpy(ethhdr->h_source, mac, ETH_ALEN);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200295 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200296 "bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100297 break;
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200298 case BATADV_CLAIM_TYPE_UNCLAIM:
Simon Wunderlich23721382012-01-22 20:00:19 +0100299 /* unclaim frame
300 * set HW SRC to the clients mac
301 */
302 memcpy(hw_src, mac, ETH_ALEN);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200303 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200304 "bla_send_claim(): UNCLAIM %pM on vid %d\n", mac,
305 vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100306 break;
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200307 case BATADV_CLAIM_TYPE_ANNOUNCE:
Simon Wunderlich23721382012-01-22 20:00:19 +0100308 /* announcement frame
309 * set HW SRC to the special mac containg the crc
310 */
311 memcpy(hw_src, mac, ETH_ALEN);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200312 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200313 "bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
314 ethhdr->h_source, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100315 break;
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200316 case BATADV_CLAIM_TYPE_REQUEST:
Simon Wunderlich23721382012-01-22 20:00:19 +0100317 /* request frame
Simon Wunderlich99e966f2012-06-23 12:34:17 +0200318 * set HW SRC and header destination to the receiving backbone
319 * gws mac
Simon Wunderlich23721382012-01-22 20:00:19 +0100320 */
321 memcpy(hw_src, mac, ETH_ALEN);
322 memcpy(ethhdr->h_dest, mac, ETH_ALEN);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200323 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200324 "bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",
325 ethhdr->h_source, ethhdr->h_dest, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100326 break;
327
328 }
329
330 if (vid != -1)
331 skb = vlan_insert_tag(skb, vid);
332
333 skb_reset_mac_header(skb);
334 skb->protocol = eth_type_trans(skb, soft_iface);
Marek Lindner1c9b0552012-06-23 11:47:53 +0200335 batadv_inc_counter(bat_priv, BATADV_CNT_RX);
336 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
337 skb->len + ETH_HLEN);
Simon Wunderlich23721382012-01-22 20:00:19 +0100338 soft_iface->last_rx = jiffies;
339
340 netif_rx(skb);
341out:
342 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +0200343 batadv_hardif_free_ref(primary_if);
Simon Wunderlich23721382012-01-22 20:00:19 +0100344}
345
Ben Hutchings2c530402012-07-10 10:55:09 +0000346/**
347 * batadv_bla_get_backbone_gw
348 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100349 * @orig: the mac address of the originator
350 * @vid: the VLAN ID
351 *
352 * searches for the backbone gw or creates a new one if it could not
353 * be found.
354 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200355static struct batadv_backbone_gw *
356batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, uint8_t *orig,
Simon Wunderlich52aebd62012-09-08 18:02:53 +0200357 short vid, bool own_backbone)
Simon Wunderlich23721382012-01-22 20:00:19 +0100358{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200359 struct batadv_backbone_gw *entry;
360 struct batadv_orig_node *orig_node;
Simon Wunderlich23721382012-01-22 20:00:19 +0100361 int hash_added;
362
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200363 entry = batadv_backbone_hash_find(bat_priv, orig, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100364
365 if (entry)
366 return entry;
367
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200368 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200369 "bla_get_backbone_gw(): not found (%pM, %d), creating new entry\n",
370 orig, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100371
372 entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
373 if (!entry)
374 return NULL;
375
376 entry->vid = vid;
377 entry->lasttime = jiffies;
Sven Eckelmann3964f722012-06-03 22:19:10 +0200378 entry->crc = BATADV_BLA_CRC_INIT;
Simon Wunderlich23721382012-01-22 20:00:19 +0100379 entry->bat_priv = bat_priv;
380 atomic_set(&entry->request_sent, 0);
381 memcpy(entry->orig, orig, ETH_ALEN);
382
383 /* one for the hash, one for returning */
384 atomic_set(&entry->refcount, 2);
385
Sven Eckelmann807736f2012-07-15 22:26:51 +0200386 hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200387 batadv_compare_backbone_gw,
388 batadv_choose_backbone_gw, entry,
389 &entry->hash_entry);
Simon Wunderlich23721382012-01-22 20:00:19 +0100390
391 if (unlikely(hash_added != 0)) {
392 /* hash failed, free the structure */
393 kfree(entry);
394 return NULL;
395 }
396
Simon Wunderlich20ff9d52012-01-22 20:00:23 +0100397 /* this is a gateway now, remove any tt entries */
Sven Eckelmannda641192012-05-12 13:48:56 +0200398 orig_node = batadv_orig_hash_find(bat_priv, orig);
Simon Wunderlich20ff9d52012-01-22 20:00:23 +0100399 if (orig_node) {
Sven Eckelmann08c36d32012-05-12 02:09:39 +0200400 batadv_tt_global_del_orig(bat_priv, orig_node,
401 "became a backbone gateway");
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200402 batadv_orig_node_free_ref(orig_node);
Simon Wunderlich20ff9d52012-01-22 20:00:23 +0100403 }
Simon Wunderlich52aebd62012-09-08 18:02:53 +0200404
405 if (own_backbone)
406 batadv_bla_send_announce(bat_priv, entry);
407
Simon Wunderlich23721382012-01-22 20:00:19 +0100408 return entry;
409}
410
411/* update or add the own backbone gw to make sure we announce
412 * where we receive other backbone gws
413 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200414static void
415batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
416 struct batadv_hard_iface *primary_if,
417 short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100418{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200419 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +0100420
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200421 backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
422 primary_if->net_dev->dev_addr,
Simon Wunderlich52aebd62012-09-08 18:02:53 +0200423 vid, true);
Simon Wunderlich23721382012-01-22 20:00:19 +0100424 if (unlikely(!backbone_gw))
425 return;
426
427 backbone_gw->lasttime = jiffies;
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200428 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100429}
430
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200431/* @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100432 * @vid: the vid where the request came on
433 *
434 * Repeat all of our own claims, and finally send an ANNOUNCE frame
435 * to allow the requester another check if the CRC is correct now.
436 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200437static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
438 struct batadv_hard_iface *primary_if,
439 short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100440{
441 struct hlist_node *node;
442 struct hlist_head *head;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200443 struct batadv_hashtable *hash;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200444 struct batadv_claim *claim;
445 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +0100446 int i;
447
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200448 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200449 "bla_answer_request(): received a claim request, send all of our own claims again\n");
Simon Wunderlich23721382012-01-22 20:00:19 +0100450
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200451 backbone_gw = batadv_backbone_hash_find(bat_priv,
452 primary_if->net_dev->dev_addr,
453 vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100454 if (!backbone_gw)
455 return;
456
Sven Eckelmann807736f2012-07-15 22:26:51 +0200457 hash = bat_priv->bla.claim_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100458 for (i = 0; i < hash->size; i++) {
459 head = &hash->table[i];
460
461 rcu_read_lock();
462 hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
463 /* only own claims are interesting */
464 if (claim->backbone_gw != backbone_gw)
465 continue;
466
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200467 batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200468 BATADV_CLAIM_TYPE_CLAIM);
Simon Wunderlich23721382012-01-22 20:00:19 +0100469 }
470 rcu_read_unlock();
471 }
472
473 /* finally, send an announcement frame */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200474 batadv_bla_send_announce(bat_priv, backbone_gw);
475 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100476}
477
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200478/* @backbone_gw: the backbone gateway from whom we are out of sync
Simon Wunderlich23721382012-01-22 20:00:19 +0100479 *
480 * When the crc is wrong, ask the backbone gateway for a full table update.
481 * After the request, it will repeat all of his own claims and finally
482 * send an announcement claim with which we can check again.
483 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200484static void batadv_bla_send_request(struct batadv_backbone_gw *backbone_gw)
Simon Wunderlich23721382012-01-22 20:00:19 +0100485{
486 /* first, remove all old entries */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200487 batadv_bla_del_backbone_claims(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100488
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200489 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
490 "Sending REQUEST to %pM\n", backbone_gw->orig);
Simon Wunderlich23721382012-01-22 20:00:19 +0100491
492 /* send request */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200493 batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200494 backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
Simon Wunderlich23721382012-01-22 20:00:19 +0100495
496 /* no local broadcasts should be sent or received, for now. */
497 if (!atomic_read(&backbone_gw->request_sent)) {
Sven Eckelmann807736f2012-07-15 22:26:51 +0200498 atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
Simon Wunderlich23721382012-01-22 20:00:19 +0100499 atomic_set(&backbone_gw->request_sent, 1);
500 }
501}
502
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200503/* @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100504 * @backbone_gw: our backbone gateway which should be announced
505 *
506 * This function sends an announcement. It is called from multiple
507 * places.
508 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200509static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
510 struct batadv_backbone_gw *backbone_gw)
Simon Wunderlich23721382012-01-22 20:00:19 +0100511{
512 uint8_t mac[ETH_ALEN];
Al Viro3e2f1a12012-04-22 07:47:50 +0100513 __be16 crc;
Simon Wunderlich23721382012-01-22 20:00:19 +0100514
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200515 memcpy(mac, batadv_announce_mac, 4);
Simon Wunderlich23721382012-01-22 20:00:19 +0100516 crc = htons(backbone_gw->crc);
Al Viro1a5852d2012-04-22 07:50:29 +0100517 memcpy(&mac[4], &crc, 2);
Simon Wunderlich23721382012-01-22 20:00:19 +0100518
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200519 batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200520 BATADV_CLAIM_TYPE_ANNOUNCE);
Simon Wunderlich23721382012-01-22 20:00:19 +0100521
522}
523
Ben Hutchings2c530402012-07-10 10:55:09 +0000524/**
525 * batadv_bla_add_claim - Adds a claim in the claim hash
526 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100527 * @mac: the mac address of the claim
528 * @vid: the VLAN ID of the frame
529 * @backbone_gw: the backbone gateway which claims it
Simon Wunderlich23721382012-01-22 20:00:19 +0100530 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200531static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
532 const uint8_t *mac, const short vid,
533 struct batadv_backbone_gw *backbone_gw)
Simon Wunderlich23721382012-01-22 20:00:19 +0100534{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200535 struct batadv_claim *claim;
536 struct batadv_claim search_claim;
Simon Wunderlich23721382012-01-22 20:00:19 +0100537 int hash_added;
538
539 memcpy(search_claim.addr, mac, ETH_ALEN);
540 search_claim.vid = vid;
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200541 claim = batadv_claim_hash_find(bat_priv, &search_claim);
Simon Wunderlich23721382012-01-22 20:00:19 +0100542
543 /* create a new claim entry if it does not exist yet. */
544 if (!claim) {
545 claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
546 if (!claim)
547 return;
548
549 memcpy(claim->addr, mac, ETH_ALEN);
550 claim->vid = vid;
551 claim->lasttime = jiffies;
552 claim->backbone_gw = backbone_gw;
553
554 atomic_set(&claim->refcount, 2);
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200555 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200556 "bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
557 mac, vid);
Sven Eckelmann807736f2012-07-15 22:26:51 +0200558 hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200559 batadv_compare_claim,
560 batadv_choose_claim, claim,
561 &claim->hash_entry);
Simon Wunderlich23721382012-01-22 20:00:19 +0100562
563 if (unlikely(hash_added != 0)) {
564 /* only local changes happened. */
565 kfree(claim);
566 return;
567 }
568 } else {
569 claim->lasttime = jiffies;
570 if (claim->backbone_gw == backbone_gw)
571 /* no need to register a new backbone */
572 goto claim_free_ref;
573
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200574 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200575 "bla_add_claim(): changing ownership for %pM, vid %d\n",
576 mac, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100577
Sven Eckelmannbbb1f902012-07-08 17:13:15 +0200578 claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200579 batadv_backbone_gw_free_ref(claim->backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100580
581 }
582 /* set (new) backbone gw */
583 atomic_inc(&backbone_gw->refcount);
584 claim->backbone_gw = backbone_gw;
585
586 backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
587 backbone_gw->lasttime = jiffies;
588
589claim_free_ref:
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200590 batadv_claim_free_ref(claim);
Simon Wunderlich23721382012-01-22 20:00:19 +0100591}
592
593/* Delete a claim from the claim hash which has the
594 * given mac address and vid.
595 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200596static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
597 const uint8_t *mac, const short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100598{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200599 struct batadv_claim search_claim, *claim;
Simon Wunderlich23721382012-01-22 20:00:19 +0100600
601 memcpy(search_claim.addr, mac, ETH_ALEN);
602 search_claim.vid = vid;
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200603 claim = batadv_claim_hash_find(bat_priv, &search_claim);
Simon Wunderlich23721382012-01-22 20:00:19 +0100604 if (!claim)
605 return;
606
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200607 batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n",
608 mac, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100609
Sven Eckelmann807736f2012-07-15 22:26:51 +0200610 batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200611 batadv_choose_claim, claim);
612 batadv_claim_free_ref(claim); /* reference from the hash is gone */
Simon Wunderlich23721382012-01-22 20:00:19 +0100613
614 claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
615
616 /* don't need the reference from hash_find() anymore */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200617 batadv_claim_free_ref(claim);
Simon Wunderlich23721382012-01-22 20:00:19 +0100618}
619
620/* check for ANNOUNCE frame, return 1 if handled */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200621static int batadv_handle_announce(struct batadv_priv *bat_priv,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200622 uint8_t *an_addr, uint8_t *backbone_addr,
623 short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100624{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200625 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +0100626 uint16_t crc;
627
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200628 if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
Simon Wunderlich23721382012-01-22 20:00:19 +0100629 return 0;
630
Simon Wunderlich52aebd62012-09-08 18:02:53 +0200631 backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
632 false);
Simon Wunderlich23721382012-01-22 20:00:19 +0100633
634 if (unlikely(!backbone_gw))
635 return 1;
636
637
638 /* handle as ANNOUNCE frame */
639 backbone_gw->lasttime = jiffies;
Al Viro3e2f1a12012-04-22 07:47:50 +0100640 crc = ntohs(*((__be16 *)(&an_addr[4])));
Simon Wunderlich23721382012-01-22 20:00:19 +0100641
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200642 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200643 "handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %04x\n",
644 vid, backbone_gw->orig, crc);
Simon Wunderlich23721382012-01-22 20:00:19 +0100645
646 if (backbone_gw->crc != crc) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200647 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200648 "handle_announce(): CRC FAILED for %pM/%d (my = %04x, sent = %04x)\n",
649 backbone_gw->orig, backbone_gw->vid,
650 backbone_gw->crc, crc);
Simon Wunderlich23721382012-01-22 20:00:19 +0100651
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200652 batadv_bla_send_request(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100653 } else {
654 /* if we have sent a request and the crc was OK,
655 * we can allow traffic again.
656 */
657 if (atomic_read(&backbone_gw->request_sent)) {
Sven Eckelmann807736f2012-07-15 22:26:51 +0200658 atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
Simon Wunderlich23721382012-01-22 20:00:19 +0100659 atomic_set(&backbone_gw->request_sent, 0);
660 }
661 }
662
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200663 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100664 return 1;
665}
666
667/* check for REQUEST frame, return 1 if handled */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200668static int batadv_handle_request(struct batadv_priv *bat_priv,
669 struct batadv_hard_iface *primary_if,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200670 uint8_t *backbone_addr,
671 struct ethhdr *ethhdr, short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100672{
673 /* check for REQUEST frame */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200674 if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
Simon Wunderlich23721382012-01-22 20:00:19 +0100675 return 0;
676
677 /* sanity check, this should not happen on a normal switch,
678 * we ignore it in this case.
679 */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200680 if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
Simon Wunderlich23721382012-01-22 20:00:19 +0100681 return 1;
682
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200683 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200684 "handle_request(): REQUEST vid %d (sent by %pM)...\n",
685 vid, ethhdr->h_source);
Simon Wunderlich23721382012-01-22 20:00:19 +0100686
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200687 batadv_bla_answer_request(bat_priv, primary_if, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100688 return 1;
689}
690
691/* check for UNCLAIM frame, return 1 if handled */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200692static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
693 struct batadv_hard_iface *primary_if,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200694 uint8_t *backbone_addr,
695 uint8_t *claim_addr, short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100696{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200697 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +0100698
699 /* unclaim in any case if it is our own */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200700 if (primary_if && batadv_compare_eth(backbone_addr,
701 primary_if->net_dev->dev_addr))
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200702 batadv_bla_send_claim(bat_priv, claim_addr, vid,
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200703 BATADV_CLAIM_TYPE_UNCLAIM);
Simon Wunderlich23721382012-01-22 20:00:19 +0100704
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200705 backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100706
707 if (!backbone_gw)
708 return 1;
709
710 /* this must be an UNCLAIM frame */
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200711 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200712 "handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
713 claim_addr, vid, backbone_gw->orig);
Simon Wunderlich23721382012-01-22 20:00:19 +0100714
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200715 batadv_bla_del_claim(bat_priv, claim_addr, vid);
716 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100717 return 1;
718}
719
720/* check for CLAIM frame, return 1 if handled */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200721static int batadv_handle_claim(struct batadv_priv *bat_priv,
722 struct batadv_hard_iface *primary_if,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200723 uint8_t *backbone_addr, uint8_t *claim_addr,
724 short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +0100725{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200726 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +0100727
728 /* register the gateway if not yet available, and add the claim. */
729
Simon Wunderlich52aebd62012-09-08 18:02:53 +0200730 backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
731 false);
Simon Wunderlich23721382012-01-22 20:00:19 +0100732
733 if (unlikely(!backbone_gw))
734 return 1;
735
736 /* this must be a CLAIM frame */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200737 batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200738 if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200739 batadv_bla_send_claim(bat_priv, claim_addr, vid,
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200740 BATADV_CLAIM_TYPE_CLAIM);
Simon Wunderlich23721382012-01-22 20:00:19 +0100741
742 /* TODO: we could call something like tt_local_del() here. */
743
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200744 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100745 return 1;
746}
747
Ben Hutchings2c530402012-07-10 10:55:09 +0000748/**
749 * batadv_check_claim_group
750 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100751 * @hw_src: the Hardware source in the ARP Header
752 * @hw_dst: the Hardware destination in the ARP Header
753 * @ethhdr: pointer to the Ethernet header of the claim frame
754 *
755 * checks if it is a claim packet and if its on the same group.
756 * This function also applies the group ID of the sender
757 * if it is in the same mesh.
758 *
759 * returns:
760 * 2 - if it is a claim packet and on the same group
761 * 1 - if is a claim packet from another group
762 * 0 - if it is not a claim packet
763 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200764static int batadv_check_claim_group(struct batadv_priv *bat_priv,
765 struct batadv_hard_iface *primary_if,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200766 uint8_t *hw_src, uint8_t *hw_dst,
767 struct ethhdr *ethhdr)
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100768{
769 uint8_t *backbone_addr;
Sven Eckelmann56303d32012-06-05 22:31:31 +0200770 struct batadv_orig_node *orig_node;
Sven Eckelmann96412692012-06-05 22:31:30 +0200771 struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100772
Sven Eckelmann96412692012-06-05 22:31:30 +0200773 bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
Sven Eckelmann807736f2012-07-15 22:26:51 +0200774 bla_dst_own = &bat_priv->bla.claim_dest;
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100775
776 /* check if it is a claim packet in general */
777 if (memcmp(bla_dst->magic, bla_dst_own->magic,
778 sizeof(bla_dst->magic)) != 0)
779 return 0;
780
781 /* if announcement packet, use the source,
782 * otherwise assume it is in the hw_src
783 */
784 switch (bla_dst->type) {
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200785 case BATADV_CLAIM_TYPE_CLAIM:
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100786 backbone_addr = hw_src;
787 break;
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200788 case BATADV_CLAIM_TYPE_REQUEST:
789 case BATADV_CLAIM_TYPE_ANNOUNCE:
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200790 case BATADV_CLAIM_TYPE_UNCLAIM:
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100791 backbone_addr = ethhdr->h_source;
792 break;
793 default:
794 return 0;
795 }
796
797 /* don't accept claim frames from ourselves */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200798 if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100799 return 0;
800
801 /* if its already the same group, it is fine. */
802 if (bla_dst->group == bla_dst_own->group)
803 return 2;
804
805 /* lets see if this originator is in our mesh */
Sven Eckelmannda641192012-05-12 13:48:56 +0200806 orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100807
808 /* dont accept claims from gateways which are not in
809 * the same mesh or group.
810 */
811 if (!orig_node)
812 return 1;
813
814 /* if our mesh friends mac is bigger, use it for ourselves. */
815 if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200816 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200817 "taking other backbones claim group: %04x\n",
818 ntohs(bla_dst->group));
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100819 bla_dst_own->group = bla_dst->group;
820 }
821
Sven Eckelmann7d211ef2012-05-12 02:09:34 +0200822 batadv_orig_node_free_ref(orig_node);
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100823
824 return 2;
825}
826
827
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +0200828/* @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100829 * @skb: the frame to be checked
830 *
831 * Check if this is a claim frame, and process it accordingly.
832 *
833 * returns 1 if it was a claim frame, otherwise return 0 to
834 * tell the callee that it can use the frame on its own.
835 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200836static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
837 struct batadv_hard_iface *primary_if,
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200838 struct sk_buff *skb)
Simon Wunderlich23721382012-01-22 20:00:19 +0100839{
840 struct ethhdr *ethhdr;
841 struct vlan_ethhdr *vhdr;
842 struct arphdr *arphdr;
843 uint8_t *hw_src, *hw_dst;
Sven Eckelmann96412692012-06-05 22:31:30 +0200844 struct batadv_bla_claim_dst *bla_dst;
Simon Wunderlich23721382012-01-22 20:00:19 +0100845 uint16_t proto;
846 int headlen;
847 short vid = -1;
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100848 int ret;
Simon Wunderlich23721382012-01-22 20:00:19 +0100849
850 ethhdr = (struct ethhdr *)skb_mac_header(skb);
851
852 if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
853 vhdr = (struct vlan_ethhdr *)ethhdr;
854 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
855 proto = ntohs(vhdr->h_vlan_encapsulated_proto);
856 headlen = sizeof(*vhdr);
857 } else {
858 proto = ntohs(ethhdr->h_proto);
Antonio Quartulli0d125072012-02-18 11:27:34 +0100859 headlen = ETH_HLEN;
Simon Wunderlich23721382012-01-22 20:00:19 +0100860 }
861
862 if (proto != ETH_P_ARP)
863 return 0; /* not a claim frame */
864
865 /* this must be a ARP frame. check if it is a claim. */
866
867 if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
868 return 0;
869
870 /* pskb_may_pull() may have modified the pointers, get ethhdr again */
871 ethhdr = (struct ethhdr *)skb_mac_header(skb);
872 arphdr = (struct arphdr *)((uint8_t *)ethhdr + headlen);
873
874 /* Check whether the ARP frame carries a valid
875 * IP information
876 */
Simon Wunderlich23721382012-01-22 20:00:19 +0100877 if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
878 return 0;
879 if (arphdr->ar_pro != htons(ETH_P_IP))
880 return 0;
881 if (arphdr->ar_hln != ETH_ALEN)
882 return 0;
883 if (arphdr->ar_pln != 4)
884 return 0;
885
886 hw_src = (uint8_t *)arphdr + sizeof(struct arphdr);
887 hw_dst = hw_src + ETH_ALEN + 4;
Sven Eckelmann96412692012-06-05 22:31:30 +0200888 bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
Simon Wunderlich23721382012-01-22 20:00:19 +0100889
890 /* check if it is a claim frame. */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200891 ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
892 ethhdr);
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100893 if (ret == 1)
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200894 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200895 "bla_process_claim(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
896 ethhdr->h_source, vid, hw_src, hw_dst);
Simon Wunderlich38ef3d12012-01-22 20:00:26 +0100897
898 if (ret < 2)
899 return ret;
Simon Wunderlich23721382012-01-22 20:00:19 +0100900
901 /* become a backbone gw ourselves on this vlan if not happened yet */
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200902 batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +0100903
904 /* check for the different types of claim frames ... */
905 switch (bla_dst->type) {
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200906 case BATADV_CLAIM_TYPE_CLAIM:
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200907 if (batadv_handle_claim(bat_priv, primary_if, hw_src,
908 ethhdr->h_source, vid))
Simon Wunderlich23721382012-01-22 20:00:19 +0100909 return 1;
910 break;
Simon Wunderlich3eb87732012-06-23 12:34:18 +0200911 case BATADV_CLAIM_TYPE_UNCLAIM:
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200912 if (batadv_handle_unclaim(bat_priv, primary_if,
913 ethhdr->h_source, hw_src, vid))
Simon Wunderlich23721382012-01-22 20:00:19 +0100914 return 1;
915 break;
916
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200917 case BATADV_CLAIM_TYPE_ANNOUNCE:
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200918 if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
919 vid))
Simon Wunderlich23721382012-01-22 20:00:19 +0100920 return 1;
921 break;
Sven Eckelmannacd34af2012-06-03 22:19:21 +0200922 case BATADV_CLAIM_TYPE_REQUEST:
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200923 if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
924 vid))
Simon Wunderlich23721382012-01-22 20:00:19 +0100925 return 1;
926 break;
927 }
928
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200929 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200930 "bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
931 ethhdr->h_source, vid, hw_src, hw_dst);
Simon Wunderlich23721382012-01-22 20:00:19 +0100932 return 1;
933}
934
935/* Check when we last heard from other nodes, and remove them in case of
936 * a time out, or clean all backbone gws if now is set.
937 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200938static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
Simon Wunderlich23721382012-01-22 20:00:19 +0100939{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200940 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +0100941 struct hlist_node *node, *node_tmp;
942 struct hlist_head *head;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200943 struct batadv_hashtable *hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100944 spinlock_t *list_lock; /* protects write access to the hash lists */
945 int i;
946
Sven Eckelmann807736f2012-07-15 22:26:51 +0200947 hash = bat_priv->bla.backbone_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100948 if (!hash)
949 return;
950
951 for (i = 0; i < hash->size; i++) {
952 head = &hash->table[i];
953 list_lock = &hash->list_locks[i];
954
955 spin_lock_bh(list_lock);
956 hlist_for_each_entry_safe(backbone_gw, node, node_tmp,
957 head, hash_entry) {
958 if (now)
959 goto purge_now;
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200960 if (!batadv_has_timed_out(backbone_gw->lasttime,
Sven Eckelmann42d0b042012-06-03 22:19:17 +0200961 BATADV_BLA_BACKBONE_TIMEOUT))
Simon Wunderlich23721382012-01-22 20:00:19 +0100962 continue;
963
Sven Eckelmann39c75a52012-06-03 22:19:22 +0200964 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +0200965 "bla_purge_backbone_gw(): backbone gw %pM timed out\n",
966 backbone_gw->orig);
Simon Wunderlich23721382012-01-22 20:00:19 +0100967
968purge_now:
969 /* don't wait for the pending request anymore */
970 if (atomic_read(&backbone_gw->request_sent))
Sven Eckelmann807736f2012-07-15 22:26:51 +0200971 atomic_dec(&bat_priv->bla.num_requests);
Simon Wunderlich23721382012-01-22 20:00:19 +0100972
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200973 batadv_bla_del_backbone_claims(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100974
975 hlist_del_rcu(node);
Sven Eckelmann3b300de2012-05-12 18:33:53 +0200976 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +0100977 }
978 spin_unlock_bh(list_lock);
979 }
980}
981
Ben Hutchings2c530402012-07-10 10:55:09 +0000982/**
983 * batadv_bla_purge_claims
984 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +0100985 * @primary_if: the selected primary interface, may be NULL if now is set
986 * @now: whether the whole hash shall be wiped now
987 *
988 * Check when we heard last time from our own claims, and remove them in case of
989 * a time out, or clean all claims if now is set
990 */
Sven Eckelmann56303d32012-06-05 22:31:31 +0200991static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
992 struct batadv_hard_iface *primary_if,
993 int now)
Simon Wunderlich23721382012-01-22 20:00:19 +0100994{
Sven Eckelmann56303d32012-06-05 22:31:31 +0200995 struct batadv_claim *claim;
Simon Wunderlich23721382012-01-22 20:00:19 +0100996 struct hlist_node *node;
997 struct hlist_head *head;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +0200998 struct batadv_hashtable *hash;
Simon Wunderlich23721382012-01-22 20:00:19 +0100999 int i;
1000
Sven Eckelmann807736f2012-07-15 22:26:51 +02001001 hash = bat_priv->bla.claim_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +01001002 if (!hash)
1003 return;
1004
1005 for (i = 0; i < hash->size; i++) {
1006 head = &hash->table[i];
1007
1008 rcu_read_lock();
1009 hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
1010 if (now)
1011 goto purge_now;
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001012 if (!batadv_compare_eth(claim->backbone_gw->orig,
1013 primary_if->net_dev->dev_addr))
Simon Wunderlich23721382012-01-22 20:00:19 +01001014 continue;
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001015 if (!batadv_has_timed_out(claim->lasttime,
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001016 BATADV_BLA_CLAIM_TIMEOUT))
Simon Wunderlich23721382012-01-22 20:00:19 +01001017 continue;
1018
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001019 batadv_dbg(BATADV_DBG_BLA, bat_priv,
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001020 "bla_purge_claims(): %pM, vid %d, time out\n",
1021 claim->addr, claim->vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001022
1023purge_now:
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001024 batadv_handle_unclaim(bat_priv, primary_if,
1025 claim->backbone_gw->orig,
1026 claim->addr, claim->vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001027 }
1028 rcu_read_unlock();
1029 }
1030}
1031
Ben Hutchings2c530402012-07-10 10:55:09 +00001032/**
1033 * batadv_bla_update_orig_address
1034 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +01001035 * @primary_if: the new selected primary_if
1036 * @oldif: the old primary interface, may be NULL
1037 *
1038 * Update the backbone gateways when the own orig address changes.
Simon Wunderlich23721382012-01-22 20:00:19 +01001039 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001040void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
1041 struct batadv_hard_iface *primary_if,
1042 struct batadv_hard_iface *oldif)
Simon Wunderlich23721382012-01-22 20:00:19 +01001043{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001044 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +01001045 struct hlist_node *node;
1046 struct hlist_head *head;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001047 struct batadv_hashtable *hash;
Sven Eckelmann807736f2012-07-15 22:26:51 +02001048 __be16 group;
Simon Wunderlich23721382012-01-22 20:00:19 +01001049 int i;
1050
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001051 /* reset bridge loop avoidance group id */
Sven Eckelmann807736f2012-07-15 22:26:51 +02001052 group = htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
1053 bat_priv->bla.claim_dest.group = group;
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001054
Simon Wunderlich23721382012-01-22 20:00:19 +01001055 if (!oldif) {
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001056 batadv_bla_purge_claims(bat_priv, NULL, 1);
1057 batadv_bla_purge_backbone_gw(bat_priv, 1);
Simon Wunderlich23721382012-01-22 20:00:19 +01001058 return;
1059 }
1060
Sven Eckelmann807736f2012-07-15 22:26:51 +02001061 hash = bat_priv->bla.backbone_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +01001062 if (!hash)
1063 return;
1064
1065 for (i = 0; i < hash->size; i++) {
1066 head = &hash->table[i];
1067
1068 rcu_read_lock();
1069 hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
1070 /* own orig still holds the old value. */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001071 if (!batadv_compare_eth(backbone_gw->orig,
1072 oldif->net_dev->dev_addr))
Simon Wunderlich23721382012-01-22 20:00:19 +01001073 continue;
1074
1075 memcpy(backbone_gw->orig,
1076 primary_if->net_dev->dev_addr, ETH_ALEN);
1077 /* send an announce frame so others will ask for our
1078 * claims and update their tables.
1079 */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001080 batadv_bla_send_announce(bat_priv, backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +01001081 }
1082 rcu_read_unlock();
1083 }
1084}
1085
1086
1087
1088/* (re)start the timer */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001089static void batadv_bla_start_timer(struct batadv_priv *bat_priv)
Simon Wunderlich23721382012-01-22 20:00:19 +01001090{
Sven Eckelmann807736f2012-07-15 22:26:51 +02001091 INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
1092 queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001093 msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
Simon Wunderlich23721382012-01-22 20:00:19 +01001094}
1095
1096/* periodic work to do:
1097 * * purge structures when they are too old
1098 * * send announcements
1099 */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001100static void batadv_bla_periodic_work(struct work_struct *work)
Simon Wunderlich23721382012-01-22 20:00:19 +01001101{
Sven Eckelmannbbb1f902012-07-08 17:13:15 +02001102 struct delayed_work *delayed_work;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001103 struct batadv_priv *bat_priv;
Sven Eckelmann807736f2012-07-15 22:26:51 +02001104 struct batadv_priv_bla *priv_bla;
Simon Wunderlich23721382012-01-22 20:00:19 +01001105 struct hlist_node *node;
1106 struct hlist_head *head;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001107 struct batadv_backbone_gw *backbone_gw;
Sven Eckelmann5bf74e92012-06-05 22:31:28 +02001108 struct batadv_hashtable *hash;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001109 struct batadv_hard_iface *primary_if;
Simon Wunderlich23721382012-01-22 20:00:19 +01001110 int i;
1111
Sven Eckelmannbbb1f902012-07-08 17:13:15 +02001112 delayed_work = container_of(work, struct delayed_work, work);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001113 priv_bla = container_of(delayed_work, struct batadv_priv_bla, work);
1114 bat_priv = container_of(priv_bla, struct batadv_priv, bla);
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001115 primary_if = batadv_primary_if_get_selected(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +01001116 if (!primary_if)
1117 goto out;
1118
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001119 batadv_bla_purge_claims(bat_priv, primary_if, 0);
1120 batadv_bla_purge_backbone_gw(bat_priv, 0);
Simon Wunderlich23721382012-01-22 20:00:19 +01001121
1122 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1123 goto out;
1124
Sven Eckelmann807736f2012-07-15 22:26:51 +02001125 hash = bat_priv->bla.backbone_hash;
Simon Wunderlich23721382012-01-22 20:00:19 +01001126 if (!hash)
1127 goto out;
1128
1129 for (i = 0; i < hash->size; i++) {
1130 head = &hash->table[i];
1131
1132 rcu_read_lock();
1133 hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001134 if (!batadv_compare_eth(backbone_gw->orig,
1135 primary_if->net_dev->dev_addr))
Simon Wunderlich23721382012-01-22 20:00:19 +01001136 continue;
1137
1138 backbone_gw->lasttime = jiffies;
1139
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001140 batadv_bla_send_announce(bat_priv, backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +01001141 }
1142 rcu_read_unlock();
1143 }
1144out:
1145 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001146 batadv_hardif_free_ref(primary_if);
Simon Wunderlich23721382012-01-22 20:00:19 +01001147
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001148 batadv_bla_start_timer(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +01001149}
1150
Sven Eckelmann5d52dad2012-03-29 12:38:20 +02001151/* The hash for claim and backbone hash receive the same key because they
1152 * are getting initialized by hash_new with the same key. Reinitializing
1153 * them with to different keys to allow nested locking without generating
1154 * lockdep warnings
1155 */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001156static struct lock_class_key batadv_claim_hash_lock_class_key;
1157static struct lock_class_key batadv_backbone_hash_lock_class_key;
Sven Eckelmann5d52dad2012-03-29 12:38:20 +02001158
Simon Wunderlich23721382012-01-22 20:00:19 +01001159/* initialize all bla structures */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001160int batadv_bla_init(struct batadv_priv *bat_priv)
Simon Wunderlich23721382012-01-22 20:00:19 +01001161{
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001162 int i;
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001163 uint8_t claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
Sven Eckelmann56303d32012-06-05 22:31:31 +02001164 struct batadv_hard_iface *primary_if;
Sven Eckelmann807736f2012-07-15 22:26:51 +02001165 uint16_t crc;
1166 unsigned long entrytime;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001167
Linus Lüssing7dac7b72012-10-17 14:53:05 +02001168 spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
1169
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001170 batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
Simon Wunderlich23721382012-01-22 20:00:19 +01001171
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001172 /* setting claim destination address */
Sven Eckelmann807736f2012-07-15 22:26:51 +02001173 memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
1174 bat_priv->bla.claim_dest.type = 0;
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001175 primary_if = batadv_primary_if_get_selected(bat_priv);
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001176 if (primary_if) {
Sven Eckelmann807736f2012-07-15 22:26:51 +02001177 crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
1178 bat_priv->bla.claim_dest.group = htons(crc);
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001179 batadv_hardif_free_ref(primary_if);
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001180 } else {
Sven Eckelmann807736f2012-07-15 22:26:51 +02001181 bat_priv->bla.claim_dest.group = 0; /* will be set later */
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001182 }
1183
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001184 /* initialize the duplicate list */
Sven Eckelmann807736f2012-07-15 22:26:51 +02001185 entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001186 for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
Sven Eckelmann807736f2012-07-15 22:26:51 +02001187 bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
1188 bat_priv->bla.bcast_duplist_curr = 0;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001189
Sven Eckelmann807736f2012-07-15 22:26:51 +02001190 if (bat_priv->bla.claim_hash)
Sven Eckelmann5346c352012-05-05 13:27:28 +02001191 return 0;
Simon Wunderlich23721382012-01-22 20:00:19 +01001192
Sven Eckelmann807736f2012-07-15 22:26:51 +02001193 bat_priv->bla.claim_hash = batadv_hash_new(128);
1194 bat_priv->bla.backbone_hash = batadv_hash_new(32);
Simon Wunderlich23721382012-01-22 20:00:19 +01001195
Sven Eckelmann807736f2012-07-15 22:26:51 +02001196 if (!bat_priv->bla.claim_hash || !bat_priv->bla.backbone_hash)
Sven Eckelmann5346c352012-05-05 13:27:28 +02001197 return -ENOMEM;
Simon Wunderlich23721382012-01-22 20:00:19 +01001198
Sven Eckelmann807736f2012-07-15 22:26:51 +02001199 batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001200 &batadv_claim_hash_lock_class_key);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001201 batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001202 &batadv_backbone_hash_lock_class_key);
Sven Eckelmann5d52dad2012-03-29 12:38:20 +02001203
Sven Eckelmann39c75a52012-06-03 22:19:22 +02001204 batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
Simon Wunderlich23721382012-01-22 20:00:19 +01001205
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001206 batadv_bla_start_timer(bat_priv);
Sven Eckelmann5346c352012-05-05 13:27:28 +02001207 return 0;
Simon Wunderlich23721382012-01-22 20:00:19 +01001208}
1209
Ben Hutchings2c530402012-07-10 10:55:09 +00001210/**
1211 * batadv_bla_check_bcast_duplist
1212 * @bat_priv: the bat priv with all the soft interface information
Linus Lüssing7f112af2012-10-17 14:53:04 +02001213 * @bcast_packet: encapsulated broadcast frame plus batman header
1214 * @bcast_packet_len: length of encapsulated broadcast frame plus batman header
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001215 *
1216 * check if it is on our broadcast list. Another gateway might
1217 * have sent the same packet because it is connected to the same backbone,
1218 * so we have to remove this duplicate.
1219 *
1220 * This is performed by checking the CRC, which will tell us
1221 * with a good chance that it is the same packet. If it is furthermore
1222 * sent by another host, drop it. We allow equal packets from
1223 * the same host however as this might be intended.
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001224 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001225int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
Sven Eckelmann96412692012-06-05 22:31:30 +02001226 struct batadv_bcast_packet *bcast_packet,
Linus Lüssing7f112af2012-10-17 14:53:04 +02001227 int bcast_packet_len)
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001228{
Linus Lüssing7dac7b72012-10-17 14:53:05 +02001229 int i, length, curr, ret = 0;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001230 uint8_t *content;
1231 uint16_t crc;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001232 struct batadv_bcast_duplist_entry *entry;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001233
Linus Lüssing7f112af2012-10-17 14:53:04 +02001234 length = bcast_packet_len - sizeof(*bcast_packet);
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001235 content = (uint8_t *)bcast_packet;
1236 content += sizeof(*bcast_packet);
1237
1238 /* calculate the crc ... */
1239 crc = crc16(0, content, length);
1240
Linus Lüssing7dac7b72012-10-17 14:53:05 +02001241 spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1242
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001243 for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
Sven Eckelmann807736f2012-07-15 22:26:51 +02001244 curr = (bat_priv->bla.bcast_duplist_curr + i);
1245 curr %= BATADV_DUPLIST_SIZE;
1246 entry = &bat_priv->bla.bcast_duplist[curr];
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001247
1248 /* we can stop searching if the entry is too old ;
1249 * later entries will be even older
1250 */
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001251 if (batadv_has_timed_out(entry->entrytime,
1252 BATADV_DUPLIST_TIMEOUT))
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001253 break;
1254
1255 if (entry->crc != crc)
1256 continue;
1257
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001258 if (batadv_compare_eth(entry->orig, bcast_packet->orig))
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001259 continue;
1260
1261 /* this entry seems to match: same crc, not too old,
1262 * and from another gw. therefore return 1 to forbid it.
1263 */
Linus Lüssing7dac7b72012-10-17 14:53:05 +02001264 ret = 1;
1265 goto out;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001266 }
Linus Lüssing7dac7b72012-10-17 14:53:05 +02001267 /* not found, add a new entry (overwrite the oldest entry)
1268 * and allow it, its the first occurence.
1269 */
Sven Eckelmann807736f2012-07-15 22:26:51 +02001270 curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
Sven Eckelmann42d0b042012-06-03 22:19:17 +02001271 curr %= BATADV_DUPLIST_SIZE;
Sven Eckelmann807736f2012-07-15 22:26:51 +02001272 entry = &bat_priv->bla.bcast_duplist[curr];
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001273 entry->crc = crc;
1274 entry->entrytime = jiffies;
1275 memcpy(entry->orig, bcast_packet->orig, ETH_ALEN);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001276 bat_priv->bla.bcast_duplist_curr = curr;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001277
Linus Lüssing7dac7b72012-10-17 14:53:05 +02001278out:
1279 spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1280
1281 return ret;
Simon Wunderlichfe2da6f2012-01-22 20:00:24 +01001282}
1283
1284
1285
Sven Eckelmann9cfc7bd2012-05-12 02:09:43 +02001286/* @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich20ff9d52012-01-22 20:00:23 +01001287 * @orig: originator mac address
1288 *
1289 * check if the originator is a gateway for any VLAN ID.
1290 *
1291 * returns 1 if it is found, 0 otherwise
Simon Wunderlich20ff9d52012-01-22 20:00:23 +01001292 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001293int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig)
Simon Wunderlich20ff9d52012-01-22 20:00:23 +01001294{
Sven Eckelmann807736f2012-07-15 22:26:51 +02001295 struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
Simon Wunderlich20ff9d52012-01-22 20:00:23 +01001296 struct hlist_head *head;
1297 struct hlist_node *node;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001298 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich20ff9d52012-01-22 20:00:23 +01001299 int i;
1300
1301 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1302 return 0;
1303
1304 if (!hash)
1305 return 0;
1306
1307 for (i = 0; i < hash->size; i++) {
1308 head = &hash->table[i];
1309
1310 rcu_read_lock();
1311 hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001312 if (batadv_compare_eth(backbone_gw->orig, orig)) {
Simon Wunderlich20ff9d52012-01-22 20:00:23 +01001313 rcu_read_unlock();
1314 return 1;
1315 }
1316 }
1317 rcu_read_unlock();
1318 }
1319
1320 return 0;
1321}
1322
1323
Ben Hutchings2c530402012-07-10 10:55:09 +00001324/**
1325 * batadv_bla_is_backbone_gw
1326 * @skb: the frame to be checked
Simon Wunderlich23721382012-01-22 20:00:19 +01001327 * @orig_node: the orig_node of the frame
1328 * @hdr_size: maximum length of the frame
1329 *
1330 * bla_is_backbone_gw inspects the skb for the VLAN ID and returns 1
1331 * if the orig_node is also a gateway on the soft interface, otherwise it
1332 * returns 0.
Simon Wunderlich23721382012-01-22 20:00:19 +01001333 */
Sven Eckelmann08adf152012-05-12 13:38:47 +02001334int batadv_bla_is_backbone_gw(struct sk_buff *skb,
Sven Eckelmann56303d32012-06-05 22:31:31 +02001335 struct batadv_orig_node *orig_node, int hdr_size)
Simon Wunderlich23721382012-01-22 20:00:19 +01001336{
1337 struct ethhdr *ethhdr;
1338 struct vlan_ethhdr *vhdr;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001339 struct batadv_backbone_gw *backbone_gw;
Simon Wunderlich23721382012-01-22 20:00:19 +01001340 short vid = -1;
1341
1342 if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1343 return 0;
1344
1345 /* first, find out the vid. */
Antonio Quartulli0d125072012-02-18 11:27:34 +01001346 if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
Simon Wunderlich23721382012-01-22 20:00:19 +01001347 return 0;
1348
1349 ethhdr = (struct ethhdr *)(((uint8_t *)skb->data) + hdr_size);
1350
1351 if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) {
1352 if (!pskb_may_pull(skb, hdr_size + sizeof(struct vlan_ethhdr)))
1353 return 0;
1354
Sven Eckelmannc67893d2012-07-08 18:33:51 +02001355 vhdr = (struct vlan_ethhdr *)(skb->data + hdr_size);
Simon Wunderlich23721382012-01-22 20:00:19 +01001356 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
1357 }
1358
1359 /* see if this originator is a backbone gw for this VLAN */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001360 backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1361 orig_node->orig, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001362 if (!backbone_gw)
1363 return 0;
1364
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001365 batadv_backbone_gw_free_ref(backbone_gw);
Simon Wunderlich23721382012-01-22 20:00:19 +01001366 return 1;
1367}
1368
1369/* free all bla structures (for softinterface free or module unload) */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001370void batadv_bla_free(struct batadv_priv *bat_priv)
Simon Wunderlich23721382012-01-22 20:00:19 +01001371{
Sven Eckelmann56303d32012-06-05 22:31:31 +02001372 struct batadv_hard_iface *primary_if;
Simon Wunderlich23721382012-01-22 20:00:19 +01001373
Sven Eckelmann807736f2012-07-15 22:26:51 +02001374 cancel_delayed_work_sync(&bat_priv->bla.work);
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001375 primary_if = batadv_primary_if_get_selected(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +01001376
Sven Eckelmann807736f2012-07-15 22:26:51 +02001377 if (bat_priv->bla.claim_hash) {
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001378 batadv_bla_purge_claims(bat_priv, primary_if, 1);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001379 batadv_hash_destroy(bat_priv->bla.claim_hash);
1380 bat_priv->bla.claim_hash = NULL;
Simon Wunderlich23721382012-01-22 20:00:19 +01001381 }
Sven Eckelmann807736f2012-07-15 22:26:51 +02001382 if (bat_priv->bla.backbone_hash) {
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001383 batadv_bla_purge_backbone_gw(bat_priv, 1);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001384 batadv_hash_destroy(bat_priv->bla.backbone_hash);
1385 bat_priv->bla.backbone_hash = NULL;
Simon Wunderlich23721382012-01-22 20:00:19 +01001386 }
1387 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001388 batadv_hardif_free_ref(primary_if);
Simon Wunderlich23721382012-01-22 20:00:19 +01001389}
1390
Ben Hutchings2c530402012-07-10 10:55:09 +00001391/**
1392 * batadv_bla_rx
1393 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +01001394 * @skb: the frame to be checked
1395 * @vid: the VLAN ID of the frame
Simon Wunderlich2d3f6cc2012-07-04 20:38:19 +02001396 * @is_bcast: the packet came in a broadcast packet type.
Simon Wunderlich23721382012-01-22 20:00:19 +01001397 *
1398 * bla_rx avoidance checks if:
1399 * * we have to race for a claim
1400 * * if the frame is allowed on the LAN
1401 *
1402 * in these cases, the skb is further handled by this function and
1403 * returns 1, otherwise it returns 0 and the caller shall further
1404 * process the skb.
Simon Wunderlich23721382012-01-22 20:00:19 +01001405 */
David S. Miller04c9f412012-07-10 23:56:33 -07001406int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid,
1407 bool is_bcast)
Simon Wunderlich23721382012-01-22 20:00:19 +01001408{
1409 struct ethhdr *ethhdr;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001410 struct batadv_claim search_claim, *claim = NULL;
1411 struct batadv_hard_iface *primary_if;
Simon Wunderlich23721382012-01-22 20:00:19 +01001412 int ret;
1413
1414 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1415
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001416 primary_if = batadv_primary_if_get_selected(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +01001417 if (!primary_if)
1418 goto handled;
1419
1420 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1421 goto allow;
1422
1423
Sven Eckelmann807736f2012-07-15 22:26:51 +02001424 if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
Simon Wunderlich23721382012-01-22 20:00:19 +01001425 /* don't allow broadcasts while requests are in flight */
Simon Wunderlich2d3f6cc2012-07-04 20:38:19 +02001426 if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast)
Simon Wunderlich23721382012-01-22 20:00:19 +01001427 goto handled;
1428
1429 memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN);
1430 search_claim.vid = vid;
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001431 claim = batadv_claim_hash_find(bat_priv, &search_claim);
Simon Wunderlich23721382012-01-22 20:00:19 +01001432
1433 if (!claim) {
1434 /* possible optimization: race for a claim */
1435 /* No claim exists yet, claim it for us!
1436 */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001437 batadv_handle_claim(bat_priv, primary_if,
1438 primary_if->net_dev->dev_addr,
1439 ethhdr->h_source, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001440 goto allow;
1441 }
1442
1443 /* if it is our own claim ... */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001444 if (batadv_compare_eth(claim->backbone_gw->orig,
1445 primary_if->net_dev->dev_addr)) {
Simon Wunderlich23721382012-01-22 20:00:19 +01001446 /* ... allow it in any case */
1447 claim->lasttime = jiffies;
1448 goto allow;
1449 }
1450
1451 /* if it is a broadcast ... */
Simon Wunderlich2d3f6cc2012-07-04 20:38:19 +02001452 if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast) {
1453 /* ... drop it. the responsible gateway is in charge.
1454 *
1455 * We need to check is_bcast because with the gateway
1456 * feature, broadcasts (like DHCP requests) may be sent
1457 * using a unicast packet type.
1458 */
Simon Wunderlich23721382012-01-22 20:00:19 +01001459 goto handled;
1460 } else {
1461 /* seems the client considers us as its best gateway.
1462 * send a claim and update the claim table
1463 * immediately.
1464 */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001465 batadv_handle_claim(bat_priv, primary_if,
1466 primary_if->net_dev->dev_addr,
1467 ethhdr->h_source, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001468 goto allow;
1469 }
1470allow:
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001471 batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001472 ret = 0;
1473 goto out;
1474
1475handled:
1476 kfree_skb(skb);
1477 ret = 1;
1478
1479out:
1480 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001481 batadv_hardif_free_ref(primary_if);
Simon Wunderlich23721382012-01-22 20:00:19 +01001482 if (claim)
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001483 batadv_claim_free_ref(claim);
Simon Wunderlich23721382012-01-22 20:00:19 +01001484 return ret;
1485}
1486
Ben Hutchings2c530402012-07-10 10:55:09 +00001487/**
1488 * batadv_bla_tx
1489 * @bat_priv: the bat priv with all the soft interface information
Simon Wunderlich23721382012-01-22 20:00:19 +01001490 * @skb: the frame to be checked
1491 * @vid: the VLAN ID of the frame
1492 *
1493 * bla_tx checks if:
1494 * * a claim was received which has to be processed
1495 * * the frame is allowed on the mesh
1496 *
1497 * in these cases, the skb is further handled by this function and
1498 * returns 1, otherwise it returns 0 and the caller shall further
1499 * process the skb.
Simon Wunderlich23721382012-01-22 20:00:19 +01001500 */
Sven Eckelmann56303d32012-06-05 22:31:31 +02001501int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid)
Simon Wunderlich23721382012-01-22 20:00:19 +01001502{
1503 struct ethhdr *ethhdr;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001504 struct batadv_claim search_claim, *claim = NULL;
1505 struct batadv_hard_iface *primary_if;
Simon Wunderlich23721382012-01-22 20:00:19 +01001506 int ret = 0;
1507
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001508 primary_if = batadv_primary_if_get_selected(bat_priv);
Simon Wunderlich23721382012-01-22 20:00:19 +01001509 if (!primary_if)
1510 goto out;
1511
1512 if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1513 goto allow;
1514
1515 /* in VLAN case, the mac header might not be set. */
1516 skb_reset_mac_header(skb);
1517
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001518 if (batadv_bla_process_claim(bat_priv, primary_if, skb))
Simon Wunderlich23721382012-01-22 20:00:19 +01001519 goto handled;
1520
1521 ethhdr = (struct ethhdr *)skb_mac_header(skb);
1522
Sven Eckelmann807736f2012-07-15 22:26:51 +02001523 if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
Simon Wunderlich23721382012-01-22 20:00:19 +01001524 /* don't allow broadcasts while requests are in flight */
1525 if (is_multicast_ether_addr(ethhdr->h_dest))
1526 goto handled;
1527
1528 memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN);
1529 search_claim.vid = vid;
1530
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001531 claim = batadv_claim_hash_find(bat_priv, &search_claim);
Simon Wunderlich23721382012-01-22 20:00:19 +01001532
1533 /* if no claim exists, allow it. */
1534 if (!claim)
1535 goto allow;
1536
1537 /* check if we are responsible. */
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001538 if (batadv_compare_eth(claim->backbone_gw->orig,
1539 primary_if->net_dev->dev_addr)) {
Simon Wunderlich23721382012-01-22 20:00:19 +01001540 /* if yes, the client has roamed and we have
1541 * to unclaim it.
1542 */
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001543 batadv_handle_unclaim(bat_priv, primary_if,
1544 primary_if->net_dev->dev_addr,
1545 ethhdr->h_source, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001546 goto allow;
1547 }
1548
1549 /* check if it is a multicast/broadcast frame */
1550 if (is_multicast_ether_addr(ethhdr->h_dest)) {
1551 /* drop it. the responsible gateway has forwarded it into
1552 * the backbone network.
1553 */
1554 goto handled;
1555 } else {
1556 /* we must allow it. at least if we are
1557 * responsible for the DESTINATION.
1558 */
1559 goto allow;
1560 }
1561allow:
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001562 batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
Simon Wunderlich23721382012-01-22 20:00:19 +01001563 ret = 0;
1564 goto out;
1565handled:
1566 ret = 1;
1567out:
1568 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001569 batadv_hardif_free_ref(primary_if);
Simon Wunderlich23721382012-01-22 20:00:19 +01001570 if (claim)
Sven Eckelmann3b300de2012-05-12 18:33:53 +02001571 batadv_claim_free_ref(claim);
Simon Wunderlich23721382012-01-22 20:00:19 +01001572 return ret;
1573}
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001574
Sven Eckelmann08adf152012-05-12 13:38:47 +02001575int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001576{
1577 struct net_device *net_dev = (struct net_device *)seq->private;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001578 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001579 struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
Sven Eckelmann56303d32012-06-05 22:31:31 +02001580 struct batadv_claim *claim;
1581 struct batadv_hard_iface *primary_if;
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001582 struct hlist_node *node;
1583 struct hlist_head *head;
1584 uint32_t i;
1585 bool is_own;
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001586 uint8_t *primary_addr;
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001587
Marek Lindner30da63a2012-08-03 17:15:46 +02001588 primary_if = batadv_seq_print_text_primary_if_get(seq);
1589 if (!primary_if)
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001590 goto out;
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001591
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001592 primary_addr = primary_if->net_dev->dev_addr;
Simon Wunderlich38ef3d12012-01-22 20:00:26 +01001593 seq_printf(seq,
1594 "Claims announced for the mesh %s (orig %pM, group id %04x)\n",
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001595 net_dev->name, primary_addr,
Sven Eckelmann807736f2012-07-15 22:26:51 +02001596 ntohs(bat_priv->bla.claim_dest.group));
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001597 seq_printf(seq, " %-17s %-5s %-17s [o] (%-4s)\n",
1598 "Client", "VID", "Originator", "CRC");
1599 for (i = 0; i < hash->size; i++) {
1600 head = &hash->table[i];
1601
1602 rcu_read_lock();
1603 hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
Sven Eckelmann1eda58b2012-05-12 13:48:58 +02001604 is_own = batadv_compare_eth(claim->backbone_gw->orig,
1605 primary_addr);
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001606 seq_printf(seq, " * %pM on % 5d by %pM [%c] (%04x)\n",
1607 claim->addr, claim->vid,
1608 claim->backbone_gw->orig,
1609 (is_own ? 'x' : ' '),
1610 claim->backbone_gw->crc);
1611 }
1612 rcu_read_unlock();
1613 }
1614out:
1615 if (primary_if)
Sven Eckelmanne5d89252012-05-12 13:48:54 +02001616 batadv_hardif_free_ref(primary_if);
Marek Lindner30da63a2012-08-03 17:15:46 +02001617 return 0;
Simon Wunderlich9bf8e4d2012-01-22 20:00:21 +01001618}
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001619
1620int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq, void *offset)
1621{
1622 struct net_device *net_dev = (struct net_device *)seq->private;
1623 struct batadv_priv *bat_priv = netdev_priv(net_dev);
Sven Eckelmann807736f2012-07-15 22:26:51 +02001624 struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001625 struct batadv_backbone_gw *backbone_gw;
1626 struct batadv_hard_iface *primary_if;
1627 struct hlist_node *node;
1628 struct hlist_head *head;
1629 int secs, msecs;
1630 uint32_t i;
1631 bool is_own;
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001632 uint8_t *primary_addr;
1633
Marek Lindner30da63a2012-08-03 17:15:46 +02001634 primary_if = batadv_seq_print_text_primary_if_get(seq);
1635 if (!primary_if)
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001636 goto out;
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001637
1638 primary_addr = primary_if->net_dev->dev_addr;
1639 seq_printf(seq,
1640 "Backbones announced for the mesh %s (orig %pM, group id %04x)\n",
1641 net_dev->name, primary_addr,
Sven Eckelmann807736f2012-07-15 22:26:51 +02001642 ntohs(bat_priv->bla.claim_dest.group));
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001643 seq_printf(seq, " %-17s %-5s %-9s (%-4s)\n",
1644 "Originator", "VID", "last seen", "CRC");
1645 for (i = 0; i < hash->size; i++) {
1646 head = &hash->table[i];
1647
1648 rcu_read_lock();
1649 hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
1650 msecs = jiffies_to_msecs(jiffies -
1651 backbone_gw->lasttime);
1652 secs = msecs / 1000;
1653 msecs = msecs % 1000;
1654
1655 is_own = batadv_compare_eth(backbone_gw->orig,
1656 primary_addr);
1657 if (is_own)
1658 continue;
1659
1660 seq_printf(seq,
1661 " * %pM on % 5d % 4i.%03is (%04x)\n",
1662 backbone_gw->orig, backbone_gw->vid,
1663 secs, msecs, backbone_gw->crc);
1664 }
1665 rcu_read_unlock();
1666 }
1667out:
1668 if (primary_if)
1669 batadv_hardif_free_ref(primary_if);
Marek Lindner30da63a2012-08-03 17:15:46 +02001670 return 0;
Simon Wunderlich536a23f2012-06-18 18:39:26 +02001671}