17db7d9f3SSven Eckelmann // SPDX-License-Identifier: GPL-2.0
2cfa55c6dSSven Eckelmann /* Copyright (C) B.A.T.M.A.N. contributors:
323721387SSimon Wunderlich *
423721387SSimon Wunderlich * Simon Wunderlich
523721387SSimon Wunderlich */
623721387SSimon Wunderlich
723721387SSimon Wunderlich #include "bridge_loop_avoidance.h"
81e2c2a4fSSven Eckelmann #include "main.h"
923721387SSimon Wunderlich
101e2c2a4fSSven Eckelmann #include <linux/atomic.h>
111e2c2a4fSSven Eckelmann #include <linux/byteorder/generic.h>
121e2c2a4fSSven Eckelmann #include <linux/compiler.h>
13eb7da4f1SSven Eckelmann #include <linux/container_of.h>
1423721387SSimon Wunderlich #include <linux/crc16.h>
151e2c2a4fSSven Eckelmann #include <linux/errno.h>
161e2c2a4fSSven Eckelmann #include <linux/etherdevice.h>
17b92b94acSSven Eckelmann #include <linux/gfp.h>
1823721387SSimon Wunderlich #include <linux/if_arp.h>
191e2c2a4fSSven Eckelmann #include <linux/if_ether.h>
2023721387SSimon Wunderlich #include <linux/if_vlan.h>
211e2c2a4fSSven Eckelmann #include <linux/jhash.h>
221e2c2a4fSSven Eckelmann #include <linux/jiffies.h>
2306e56dedSSven Eckelmann #include <linux/kref.h>
241e2c2a4fSSven Eckelmann #include <linux/list.h>
251e2c2a4fSSven Eckelmann #include <linux/lockdep.h>
261e2c2a4fSSven Eckelmann #include <linux/netdevice.h>
2704f3f5bfSAndrew Lunn #include <linux/netlink.h>
281e2c2a4fSSven Eckelmann #include <linux/rculist.h>
291e2c2a4fSSven Eckelmann #include <linux/rcupdate.h>
301e2c2a4fSSven Eckelmann #include <linux/skbuff.h>
311e2c2a4fSSven Eckelmann #include <linux/slab.h>
321e2c2a4fSSven Eckelmann #include <linux/spinlock.h>
33*69f9aff2SSven Eckelmann #include <linux/sprintf.h>
341e2c2a4fSSven Eckelmann #include <linux/stddef.h>
351e2c2a4fSSven Eckelmann #include <linux/string.h>
361e2c2a4fSSven Eckelmann #include <linux/workqueue.h>
371e2c2a4fSSven Eckelmann #include <net/arp.h>
3804f3f5bfSAndrew Lunn #include <net/genetlink.h>
3904f3f5bfSAndrew Lunn #include <net/netlink.h>
4004f3f5bfSAndrew Lunn #include <net/sock.h>
41fec149f5SSven Eckelmann #include <uapi/linux/batadv_packet.h>
4204f3f5bfSAndrew Lunn #include <uapi/linux/batman_adv.h>
431e2c2a4fSSven Eckelmann
441e2c2a4fSSven Eckelmann #include "hard-interface.h"
451e2c2a4fSSven Eckelmann #include "hash.h"
46ba412080SSven Eckelmann #include "log.h"
4704f3f5bfSAndrew Lunn #include "netlink.h"
481e2c2a4fSSven Eckelmann #include "originator.h"
4904f3f5bfSAndrew Lunn #include "soft-interface.h"
501e2c2a4fSSven Eckelmann #include "translation-table.h"
5123721387SSimon Wunderlich
526b5e971aSSven Eckelmann static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
5323721387SSimon Wunderlich
543b300de3SSven Eckelmann static void batadv_bla_periodic_work(struct work_struct *work);
55bae98774SMarek Lindner static void
56bae98774SMarek Lindner batadv_bla_send_announce(struct batadv_priv *bat_priv,
57bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw);
5823721387SSimon Wunderlich
5962fe710fSSven Eckelmann /**
607e9a8c2cSSven Eckelmann * batadv_choose_claim() - choose the right bucket for a claim.
6104e14be6SSimon Wunderlich * @data: data to hash
6204e14be6SSimon Wunderlich * @size: size of the hash table
6362fe710fSSven Eckelmann *
6404e14be6SSimon Wunderlich * Return: the hash index of the claim
6562fe710fSSven Eckelmann */
batadv_choose_claim(const void * data,u32 size)666b5e971aSSven Eckelmann static inline u32 batadv_choose_claim(const void *data, u32 size)
6723721387SSimon Wunderlich {
688864d2fcSYu Zhe const struct batadv_bla_claim *claim = data;
696b5e971aSSven Eckelmann u32 hash = 0;
7023721387SSimon Wunderlich
7136fd61cbSSven Eckelmann hash = jhash(&claim->addr, sizeof(claim->addr), hash);
7236fd61cbSSven Eckelmann hash = jhash(&claim->vid, sizeof(claim->vid), hash);
7323721387SSimon Wunderlich
7423721387SSimon Wunderlich return hash % size;
7523721387SSimon Wunderlich }
7623721387SSimon Wunderlich
7762fe710fSSven Eckelmann /**
787e9a8c2cSSven Eckelmann * batadv_choose_backbone_gw() - choose the right bucket for a backbone gateway.
7904e14be6SSimon Wunderlich * @data: data to hash
8004e14be6SSimon Wunderlich * @size: size of the hash table
8162fe710fSSven Eckelmann *
8204e14be6SSimon Wunderlich * Return: the hash index of the backbone gateway
8362fe710fSSven Eckelmann */
batadv_choose_backbone_gw(const void * data,u32 size)846b5e971aSSven Eckelmann static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
8523721387SSimon Wunderlich {
86097930e8SLinus Lüssing const struct batadv_bla_backbone_gw *gw;
876b5e971aSSven Eckelmann u32 hash = 0;
8823721387SSimon Wunderlich
898864d2fcSYu Zhe gw = data;
90097930e8SLinus Lüssing hash = jhash(&gw->orig, sizeof(gw->orig), hash);
91097930e8SLinus Lüssing hash = jhash(&gw->vid, sizeof(gw->vid), hash);
9223721387SSimon Wunderlich
9323721387SSimon Wunderlich return hash % size;
9423721387SSimon Wunderlich }
9523721387SSimon Wunderlich
9604e14be6SSimon Wunderlich /**
977e9a8c2cSSven Eckelmann * batadv_compare_backbone_gw() - compare address and vid of two backbone gws
9804e14be6SSimon Wunderlich * @node: list node of the first entry to compare
9904e14be6SSimon Wunderlich * @data2: pointer to the second backbone gateway
10004e14be6SSimon Wunderlich *
1014b426b10SSven Eckelmann * Return: true if the backbones have the same data, false otherwise
10204e14be6SSimon Wunderlich */
batadv_compare_backbone_gw(const struct hlist_node * node,const void * data2)1034b426b10SSven Eckelmann static bool batadv_compare_backbone_gw(const struct hlist_node *node,
1043b300de3SSven Eckelmann const void *data2)
10523721387SSimon Wunderlich {
106bae98774SMarek Lindner const void *data1 = container_of(node, struct batadv_bla_backbone_gw,
10723721387SSimon Wunderlich hash_entry);
1084f248cffSSven Eckelmann const struct batadv_bla_backbone_gw *gw1 = data1;
1094f248cffSSven Eckelmann const struct batadv_bla_backbone_gw *gw2 = data2;
11023721387SSimon Wunderlich
111c76d1525SSimon Wunderlich if (!batadv_compare_eth(gw1->orig, gw2->orig))
1124b426b10SSven Eckelmann return false;
113c76d1525SSimon Wunderlich
114c76d1525SSimon Wunderlich if (gw1->vid != gw2->vid)
1154b426b10SSven Eckelmann return false;
116c76d1525SSimon Wunderlich
1174b426b10SSven Eckelmann return true;
11823721387SSimon Wunderlich }
11923721387SSimon Wunderlich
12004e14be6SSimon Wunderlich /**
1217e9a8c2cSSven Eckelmann * batadv_compare_claim() - compare address and vid of two claims
12204e14be6SSimon Wunderlich * @node: list node of the first entry to compare
12304e14be6SSimon Wunderlich * @data2: pointer to the second claims
12404e14be6SSimon Wunderlich *
1254b426b10SSven Eckelmann * Return: true if the claim have the same data, 0 otherwise
12604e14be6SSimon Wunderlich */
batadv_compare_claim(const struct hlist_node * node,const void * data2)1274b426b10SSven Eckelmann static bool batadv_compare_claim(const struct hlist_node *node,
1283b300de3SSven Eckelmann const void *data2)
12923721387SSimon Wunderlich {
130712bbfe4SMarek Lindner const void *data1 = container_of(node, struct batadv_bla_claim,
13123721387SSimon Wunderlich hash_entry);
1324f248cffSSven Eckelmann const struct batadv_bla_claim *cl1 = data1;
1334f248cffSSven Eckelmann const struct batadv_bla_claim *cl2 = data2;
13423721387SSimon Wunderlich
135c76d1525SSimon Wunderlich if (!batadv_compare_eth(cl1->addr, cl2->addr))
1364b426b10SSven Eckelmann return false;
137c76d1525SSimon Wunderlich
138c76d1525SSimon Wunderlich if (cl1->vid != cl2->vid)
1394b426b10SSven Eckelmann return false;
140c76d1525SSimon Wunderlich
1414b426b10SSven Eckelmann return true;
14223721387SSimon Wunderlich }
14323721387SSimon Wunderlich
14404e14be6SSimon Wunderlich /**
1457e9a8c2cSSven Eckelmann * batadv_backbone_gw_release() - release backbone gw from lists and queue for
14606e56dedSSven Eckelmann * free after rcu grace period
14706e56dedSSven Eckelmann * @ref: kref pointer of the backbone gw
14806e56dedSSven Eckelmann */
batadv_backbone_gw_release(struct kref * ref)14906e56dedSSven Eckelmann static void batadv_backbone_gw_release(struct kref *ref)
15006e56dedSSven Eckelmann {
15106e56dedSSven Eckelmann struct batadv_bla_backbone_gw *backbone_gw;
15206e56dedSSven Eckelmann
15306e56dedSSven Eckelmann backbone_gw = container_of(ref, struct batadv_bla_backbone_gw,
15406e56dedSSven Eckelmann refcount);
15506e56dedSSven Eckelmann
15606e56dedSSven Eckelmann kfree_rcu(backbone_gw, rcu);
15706e56dedSSven Eckelmann }
15806e56dedSSven Eckelmann
15906e56dedSSven Eckelmann /**
1607e9a8c2cSSven Eckelmann * batadv_backbone_gw_put() - decrement the backbone gw refcounter and possibly
161c8b86c12SSven Eckelmann * release it
16204e14be6SSimon Wunderlich * @backbone_gw: backbone gateway to be free'd
16304e14be6SSimon Wunderlich */
batadv_backbone_gw_put(struct batadv_bla_backbone_gw * backbone_gw)164c8b86c12SSven Eckelmann static void batadv_backbone_gw_put(struct batadv_bla_backbone_gw *backbone_gw)
16523721387SSimon Wunderlich {
1666340dcbdSSven Eckelmann if (!backbone_gw)
1676340dcbdSSven Eckelmann return;
1686340dcbdSSven Eckelmann
16906e56dedSSven Eckelmann kref_put(&backbone_gw->refcount, batadv_backbone_gw_release);
17023721387SSimon Wunderlich }
17123721387SSimon Wunderlich
17204e14be6SSimon Wunderlich /**
1737e9a8c2cSSven Eckelmann * batadv_claim_release() - release claim from lists and queue for free after
1747e9a8c2cSSven Eckelmann * rcu grace period
17504e14be6SSimon Wunderlich * @ref: kref pointer of the claim
17604e14be6SSimon Wunderlich */
batadv_claim_release(struct kref * ref)17771b7e3d3SSven Eckelmann static void batadv_claim_release(struct kref *ref)
17823721387SSimon Wunderlich {
17971b7e3d3SSven Eckelmann struct batadv_bla_claim *claim;
1803db0decfSSven Eckelmann struct batadv_bla_backbone_gw *old_backbone_gw;
18171b7e3d3SSven Eckelmann
18271b7e3d3SSven Eckelmann claim = container_of(ref, struct batadv_bla_claim, refcount);
18371b7e3d3SSven Eckelmann
1843db0decfSSven Eckelmann spin_lock_bh(&claim->backbone_lock);
1853db0decfSSven Eckelmann old_backbone_gw = claim->backbone_gw;
1863db0decfSSven Eckelmann claim->backbone_gw = NULL;
1873db0decfSSven Eckelmann spin_unlock_bh(&claim->backbone_lock);
1883db0decfSSven Eckelmann
1893db0decfSSven Eckelmann spin_lock_bh(&old_backbone_gw->crc_lock);
1903db0decfSSven Eckelmann old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
1913db0decfSSven Eckelmann spin_unlock_bh(&old_backbone_gw->crc_lock);
1923db0decfSSven Eckelmann
1933db0decfSSven Eckelmann batadv_backbone_gw_put(old_backbone_gw);
1943db0decfSSven Eckelmann
19563b39927SSven Eckelmann kfree_rcu(claim, rcu);
19623721387SSimon Wunderlich }
19723721387SSimon Wunderlich
19804e14be6SSimon Wunderlich /**
1997e9a8c2cSSven Eckelmann * batadv_claim_put() - decrement the claim refcounter and possibly release it
20004e14be6SSimon Wunderlich * @claim: claim to be free'd
20104e14be6SSimon Wunderlich */
batadv_claim_put(struct batadv_bla_claim * claim)202321e3e08SSven Eckelmann static void batadv_claim_put(struct batadv_bla_claim *claim)
20323721387SSimon Wunderlich {
2046340dcbdSSven Eckelmann if (!claim)
2056340dcbdSSven Eckelmann return;
2066340dcbdSSven Eckelmann
20771b7e3d3SSven Eckelmann kref_put(&claim->refcount, batadv_claim_release);
20823721387SSimon Wunderlich }
20923721387SSimon Wunderlich
2101b371d13SSimon Wunderlich /**
2117e9a8c2cSSven Eckelmann * batadv_claim_hash_find() - looks for a claim in the claim hash
2121b371d13SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
21323721387SSimon Wunderlich * @data: search data (may be local/static data)
21423721387SSimon Wunderlich *
21562fe710fSSven Eckelmann * Return: claim if found or NULL otherwise.
21623721387SSimon Wunderlich */
2176fc77a54SSven Eckelmann static struct batadv_bla_claim *
batadv_claim_hash_find(struct batadv_priv * bat_priv,struct batadv_bla_claim * data)2186fc77a54SSven Eckelmann batadv_claim_hash_find(struct batadv_priv *bat_priv,
219712bbfe4SMarek Lindner struct batadv_bla_claim *data)
22023721387SSimon Wunderlich {
221807736f6SSven Eckelmann struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
22223721387SSimon Wunderlich struct hlist_head *head;
223712bbfe4SMarek Lindner struct batadv_bla_claim *claim;
224712bbfe4SMarek Lindner struct batadv_bla_claim *claim_tmp = NULL;
22523721387SSimon Wunderlich int index;
22623721387SSimon Wunderlich
22723721387SSimon Wunderlich if (!hash)
22823721387SSimon Wunderlich return NULL;
22923721387SSimon Wunderlich
2303b300de3SSven Eckelmann index = batadv_choose_claim(data, hash->size);
23123721387SSimon Wunderlich head = &hash->table[index];
23223721387SSimon Wunderlich
23323721387SSimon Wunderlich rcu_read_lock();
234b67bfe0dSSasha Levin hlist_for_each_entry_rcu(claim, head, hash_entry) {
2353b300de3SSven Eckelmann if (!batadv_compare_claim(&claim->hash_entry, data))
23623721387SSimon Wunderlich continue;
23723721387SSimon Wunderlich
23871b7e3d3SSven Eckelmann if (!kref_get_unless_zero(&claim->refcount))
23923721387SSimon Wunderlich continue;
24023721387SSimon Wunderlich
24123721387SSimon Wunderlich claim_tmp = claim;
24223721387SSimon Wunderlich break;
24323721387SSimon Wunderlich }
24423721387SSimon Wunderlich rcu_read_unlock();
24523721387SSimon Wunderlich
24623721387SSimon Wunderlich return claim_tmp;
24723721387SSimon Wunderlich }
24823721387SSimon Wunderlich
2492c53040fSBen Hutchings /**
2507e9a8c2cSSven Eckelmann * batadv_backbone_hash_find() - looks for a backbone gateway in the hash
2512c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
25223721387SSimon Wunderlich * @addr: the address of the originator
25323721387SSimon Wunderlich * @vid: the VLAN ID
25423721387SSimon Wunderlich *
25504e14be6SSimon Wunderlich * Return: backbone gateway if found or NULL otherwise
25623721387SSimon Wunderlich */
257bae98774SMarek Lindner static struct batadv_bla_backbone_gw *
batadv_backbone_hash_find(struct batadv_priv * bat_priv,const u8 * addr,unsigned short vid)25847ce5f1eSJakub Kicinski batadv_backbone_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
2596b5e971aSSven Eckelmann unsigned short vid)
26023721387SSimon Wunderlich {
261807736f6SSven Eckelmann struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
26223721387SSimon Wunderlich struct hlist_head *head;
263bae98774SMarek Lindner struct batadv_bla_backbone_gw search_entry, *backbone_gw;
264bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw_tmp = NULL;
26523721387SSimon Wunderlich int index;
26623721387SSimon Wunderlich
26723721387SSimon Wunderlich if (!hash)
26823721387SSimon Wunderlich return NULL;
26923721387SSimon Wunderlich
2708fdd0153SAntonio Quartulli ether_addr_copy(search_entry.orig, addr);
27123721387SSimon Wunderlich search_entry.vid = vid;
27223721387SSimon Wunderlich
2733b300de3SSven Eckelmann index = batadv_choose_backbone_gw(&search_entry, hash->size);
27423721387SSimon Wunderlich head = &hash->table[index];
27523721387SSimon Wunderlich
27623721387SSimon Wunderlich rcu_read_lock();
277b67bfe0dSSasha Levin hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
2783b300de3SSven Eckelmann if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
27923721387SSimon Wunderlich &search_entry))
28023721387SSimon Wunderlich continue;
28123721387SSimon Wunderlich
28206e56dedSSven Eckelmann if (!kref_get_unless_zero(&backbone_gw->refcount))
28323721387SSimon Wunderlich continue;
28423721387SSimon Wunderlich
28523721387SSimon Wunderlich backbone_gw_tmp = backbone_gw;
28623721387SSimon Wunderlich break;
28723721387SSimon Wunderlich }
28823721387SSimon Wunderlich rcu_read_unlock();
28923721387SSimon Wunderlich
29023721387SSimon Wunderlich return backbone_gw_tmp;
29123721387SSimon Wunderlich }
29223721387SSimon Wunderlich
29304e14be6SSimon Wunderlich /**
2947e9a8c2cSSven Eckelmann * batadv_bla_del_backbone_claims() - delete all claims for a backbone
29504e14be6SSimon Wunderlich * @backbone_gw: backbone gateway where the claims should be removed
29604e14be6SSimon Wunderlich */
29756303d34SSven Eckelmann static void
batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw * backbone_gw)298bae98774SMarek Lindner batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
29923721387SSimon Wunderlich {
3005bf74e9cSSven Eckelmann struct batadv_hashtable *hash;
301b67bfe0dSSasha Levin struct hlist_node *node_tmp;
30223721387SSimon Wunderlich struct hlist_head *head;
303712bbfe4SMarek Lindner struct batadv_bla_claim *claim;
30423721387SSimon Wunderlich int i;
30523721387SSimon Wunderlich spinlock_t *list_lock; /* protects write access to the hash lists */
30623721387SSimon Wunderlich
307807736f6SSven Eckelmann hash = backbone_gw->bat_priv->bla.claim_hash;
30823721387SSimon Wunderlich if (!hash)
30923721387SSimon Wunderlich return;
31023721387SSimon Wunderlich
31123721387SSimon Wunderlich for (i = 0; i < hash->size; i++) {
31223721387SSimon Wunderlich head = &hash->table[i];
31323721387SSimon Wunderlich list_lock = &hash->list_locks[i];
31423721387SSimon Wunderlich
31523721387SSimon Wunderlich spin_lock_bh(list_lock);
316b67bfe0dSSasha Levin hlist_for_each_entry_safe(claim, node_tmp,
31723721387SSimon Wunderlich head, hash_entry) {
31823721387SSimon Wunderlich if (claim->backbone_gw != backbone_gw)
31923721387SSimon Wunderlich continue;
32023721387SSimon Wunderlich
321321e3e08SSven Eckelmann batadv_claim_put(claim);
322b67bfe0dSSasha Levin hlist_del_rcu(&claim->hash_entry);
32323721387SSimon Wunderlich }
32423721387SSimon Wunderlich spin_unlock_bh(list_lock);
32523721387SSimon Wunderlich }
32623721387SSimon Wunderlich
3273f68785eSAntonio Quartulli /* all claims gone, initialize CRC */
3285a1dd8a4SSimon Wunderlich spin_lock_bh(&backbone_gw->crc_lock);
3293964f728SSven Eckelmann backbone_gw->crc = BATADV_BLA_CRC_INIT;
3305a1dd8a4SSimon Wunderlich spin_unlock_bh(&backbone_gw->crc_lock);
33123721387SSimon Wunderlich }
33223721387SSimon Wunderlich
3332c53040fSBen Hutchings /**
3347e9a8c2cSSven Eckelmann * batadv_bla_send_claim() - sends a claim frame according to the provided info
3352c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
336e3357189SMartin Hundebøll * @mac: the mac address to be announced within the claim
33723721387SSimon Wunderlich * @vid: the VLAN ID
33823721387SSimon Wunderlich * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
33923721387SSimon Wunderlich */
batadv_bla_send_claim(struct batadv_priv * bat_priv,const u8 * mac,unsigned short vid,int claimtype)34047ce5f1eSJakub Kicinski static void batadv_bla_send_claim(struct batadv_priv *bat_priv, const u8 *mac,
341eb2deb6bSAntonio Quartulli unsigned short vid, int claimtype)
34223721387SSimon Wunderlich {
34323721387SSimon Wunderlich struct sk_buff *skb;
34423721387SSimon Wunderlich struct ethhdr *ethhdr;
34556303d34SSven Eckelmann struct batadv_hard_iface *primary_if;
34623721387SSimon Wunderlich struct net_device *soft_iface;
3476b5e971aSSven Eckelmann u8 *hw_src;
34896412690SSven Eckelmann struct batadv_bla_claim_dst local_claim_dest;
3493e2f1a1bSAl Viro __be32 zeroip = 0;
35023721387SSimon Wunderlich
351e5d89254SSven Eckelmann primary_if = batadv_primary_if_get_selected(bat_priv);
35223721387SSimon Wunderlich if (!primary_if)
35323721387SSimon Wunderlich return;
35423721387SSimon Wunderlich
355807736f6SSven Eckelmann memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
35638ef3d1dSSimon Wunderlich sizeof(local_claim_dest));
35723721387SSimon Wunderlich local_claim_dest.type = claimtype;
35823721387SSimon Wunderlich
35923721387SSimon Wunderlich soft_iface = primary_if->soft_iface;
36023721387SSimon Wunderlich
36123721387SSimon Wunderlich skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
36223721387SSimon Wunderlich /* IP DST: 0.0.0.0 */
36323721387SSimon Wunderlich zeroip,
36423721387SSimon Wunderlich primary_if->soft_iface,
36523721387SSimon Wunderlich /* IP SRC: 0.0.0.0 */
36623721387SSimon Wunderlich zeroip,
36723721387SSimon Wunderlich /* Ethernet DST: Broadcast */
36823721387SSimon Wunderlich NULL,
36923721387SSimon Wunderlich /* Ethernet SRC/HW SRC: originator mac */
37023721387SSimon Wunderlich primary_if->net_dev->dev_addr,
37199e966fcSSimon Wunderlich /* HW DST: FF:43:05:XX:YY:YY
37223721387SSimon Wunderlich * with XX = claim type
37338ef3d1dSSimon Wunderlich * and YY:YY = group id
37423721387SSimon Wunderlich */
3756b5e971aSSven Eckelmann (u8 *)&local_claim_dest);
37623721387SSimon Wunderlich
37723721387SSimon Wunderlich if (!skb)
37823721387SSimon Wunderlich goto out;
37923721387SSimon Wunderlich
38023721387SSimon Wunderlich ethhdr = (struct ethhdr *)skb->data;
3816b5e971aSSven Eckelmann hw_src = (u8 *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
38223721387SSimon Wunderlich
38323721387SSimon Wunderlich /* now we pretend that the client would have sent this ... */
38423721387SSimon Wunderlich switch (claimtype) {
3853eb8773eSSimon Wunderlich case BATADV_CLAIM_TYPE_CLAIM:
38623721387SSimon Wunderlich /* normal claim frame
38723721387SSimon Wunderlich * set Ethernet SRC to the clients mac
38823721387SSimon Wunderlich */
3898fdd0153SAntonio Quartulli ether_addr_copy(ethhdr->h_source, mac);
39039c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
39122f0502eSSven Eckelmann "%s(): CLAIM %pM on vid %d\n", __func__, mac,
392f7a2bd65SSven Eckelmann batadv_print_vid(vid));
39323721387SSimon Wunderlich break;
3943eb8773eSSimon Wunderlich case BATADV_CLAIM_TYPE_UNCLAIM:
39523721387SSimon Wunderlich /* unclaim frame
39623721387SSimon Wunderlich * set HW SRC to the clients mac
39723721387SSimon Wunderlich */
3988fdd0153SAntonio Quartulli ether_addr_copy(hw_src, mac);
39939c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
40022f0502eSSven Eckelmann "%s(): UNCLAIM %pM on vid %d\n", __func__, mac,
401f7a2bd65SSven Eckelmann batadv_print_vid(vid));
40223721387SSimon Wunderlich break;
403acd34afaSSven Eckelmann case BATADV_CLAIM_TYPE_ANNOUNCE:
40423721387SSimon Wunderlich /* announcement frame
405791ad7f5SZheng Yongjun * set HW SRC to the special mac containing the crc
40623721387SSimon Wunderlich */
4078fdd0153SAntonio Quartulli ether_addr_copy(hw_src, mac);
40839c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
40922f0502eSSven Eckelmann "%s(): ANNOUNCE of %pM on vid %d\n", __func__,
410f7a2bd65SSven Eckelmann ethhdr->h_source, batadv_print_vid(vid));
41123721387SSimon Wunderlich break;
412acd34afaSSven Eckelmann case BATADV_CLAIM_TYPE_REQUEST:
41323721387SSimon Wunderlich /* request frame
41499e966fcSSimon Wunderlich * set HW SRC and header destination to the receiving backbone
41599e966fcSSimon Wunderlich * gws mac
41623721387SSimon Wunderlich */
4178fdd0153SAntonio Quartulli ether_addr_copy(hw_src, mac);
4188fdd0153SAntonio Quartulli ether_addr_copy(ethhdr->h_dest, mac);
41939c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
42022f0502eSSven Eckelmann "%s(): REQUEST of %pM to %pM on vid %d\n", __func__,
4215f80df67SAntonio Quartulli ethhdr->h_source, ethhdr->h_dest,
422f7a2bd65SSven Eckelmann batadv_print_vid(vid));
42323721387SSimon Wunderlich break;
424cd9c7bfbSSimon Wunderlich case BATADV_CLAIM_TYPE_LOOPDETECT:
425cd9c7bfbSSimon Wunderlich ether_addr_copy(ethhdr->h_source, mac);
426cd9c7bfbSSimon Wunderlich batadv_dbg(BATADV_DBG_BLA, bat_priv,
42722f0502eSSven Eckelmann "%s(): LOOPDETECT of %pM to %pM on vid %d\n",
42822f0502eSSven Eckelmann __func__, ethhdr->h_source, ethhdr->h_dest,
429f7a2bd65SSven Eckelmann batadv_print_vid(vid));
430cd9c7bfbSSimon Wunderlich
431cd9c7bfbSSimon Wunderlich break;
43223721387SSimon Wunderlich }
43323721387SSimon Wunderlich
43410c78f58SSven Eckelmann if (vid & BATADV_VLAN_HAS_TAG) {
435eb2deb6bSAntonio Quartulli skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
436eb2deb6bSAntonio Quartulli vid & VLAN_VID_MASK);
43710c78f58SSven Eckelmann if (!skb)
43810c78f58SSven Eckelmann goto out;
43910c78f58SSven Eckelmann }
44023721387SSimon Wunderlich
44123721387SSimon Wunderlich skb_reset_mac_header(skb);
44223721387SSimon Wunderlich skb->protocol = eth_type_trans(skb, soft_iface);
4431c9b0550SMarek Lindner batadv_inc_counter(bat_priv, BATADV_CNT_RX);
4441c9b0550SMarek Lindner batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
4451c9b0550SMarek Lindner skb->len + ETH_HLEN);
44623721387SSimon Wunderlich
44794da81e2SSebastian Andrzej Siewior netif_rx(skb);
44823721387SSimon Wunderlich out:
44982047ad7SSven Eckelmann batadv_hardif_put(primary_if);
45023721387SSimon Wunderlich }
45123721387SSimon Wunderlich
4522c53040fSBen Hutchings /**
4537e9a8c2cSSven Eckelmann * batadv_bla_loopdetect_report() - worker for reporting the loop
454cd9c7bfbSSimon Wunderlich * @work: work queue item
455cd9c7bfbSSimon Wunderlich *
456cd9c7bfbSSimon Wunderlich * Throws an uevent, as the loopdetect check function can't do that itself
457cd9c7bfbSSimon Wunderlich * since the kernel may sleep while throwing uevents.
458cd9c7bfbSSimon Wunderlich */
batadv_bla_loopdetect_report(struct work_struct * work)459cd9c7bfbSSimon Wunderlich static void batadv_bla_loopdetect_report(struct work_struct *work)
460cd9c7bfbSSimon Wunderlich {
461cd9c7bfbSSimon Wunderlich struct batadv_bla_backbone_gw *backbone_gw;
462cd9c7bfbSSimon Wunderlich struct batadv_priv *bat_priv;
463cd9c7bfbSSimon Wunderlich char vid_str[6] = { '\0' };
464cd9c7bfbSSimon Wunderlich
465cd9c7bfbSSimon Wunderlich backbone_gw = container_of(work, struct batadv_bla_backbone_gw,
466cd9c7bfbSSimon Wunderlich report_work);
467cd9c7bfbSSimon Wunderlich bat_priv = backbone_gw->bat_priv;
468cd9c7bfbSSimon Wunderlich
469cd9c7bfbSSimon Wunderlich batadv_info(bat_priv->soft_iface,
470cd9c7bfbSSimon Wunderlich "Possible loop on VLAN %d detected which can't be handled by BLA - please check your network setup!\n",
471f7a2bd65SSven Eckelmann batadv_print_vid(backbone_gw->vid));
472cd9c7bfbSSimon Wunderlich snprintf(vid_str, sizeof(vid_str), "%d",
473f7a2bd65SSven Eckelmann batadv_print_vid(backbone_gw->vid));
474cd9c7bfbSSimon Wunderlich vid_str[sizeof(vid_str) - 1] = 0;
475cd9c7bfbSSimon Wunderlich
476cd9c7bfbSSimon Wunderlich batadv_throw_uevent(bat_priv, BATADV_UEV_BLA, BATADV_UEV_LOOPDETECT,
477cd9c7bfbSSimon Wunderlich vid_str);
478cd9c7bfbSSimon Wunderlich
479cd9c7bfbSSimon Wunderlich batadv_backbone_gw_put(backbone_gw);
480cd9c7bfbSSimon Wunderlich }
481cd9c7bfbSSimon Wunderlich
482cd9c7bfbSSimon Wunderlich /**
4837e9a8c2cSSven Eckelmann * batadv_bla_get_backbone_gw() - finds or creates a backbone gateway
4842c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
48523721387SSimon Wunderlich * @orig: the mac address of the originator
48623721387SSimon Wunderlich * @vid: the VLAN ID
487e3357189SMartin Hundebøll * @own_backbone: set if the requested backbone is local
48823721387SSimon Wunderlich *
48904e14be6SSimon Wunderlich * Return: the (possibly created) backbone gateway or NULL on error
49023721387SSimon Wunderlich */
491bae98774SMarek Lindner static struct batadv_bla_backbone_gw *
batadv_bla_get_backbone_gw(struct batadv_priv * bat_priv,const u8 * orig,unsigned short vid,bool own_backbone)49247ce5f1eSJakub Kicinski batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, const u8 *orig,
493eb2deb6bSAntonio Quartulli unsigned short vid, bool own_backbone)
49423721387SSimon Wunderlich {
495bae98774SMarek Lindner struct batadv_bla_backbone_gw *entry;
49656303d34SSven Eckelmann struct batadv_orig_node *orig_node;
49723721387SSimon Wunderlich int hash_added;
49823721387SSimon Wunderlich
4993b300de3SSven Eckelmann entry = batadv_backbone_hash_find(bat_priv, orig, vid);
50023721387SSimon Wunderlich
50123721387SSimon Wunderlich if (entry)
50223721387SSimon Wunderlich return entry;
50323721387SSimon Wunderlich
50439c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
50522f0502eSSven Eckelmann "%s(): not found (%pM, %d), creating new entry\n", __func__,
506f7a2bd65SSven Eckelmann orig, batadv_print_vid(vid));
50723721387SSimon Wunderlich
50823721387SSimon Wunderlich entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
50923721387SSimon Wunderlich if (!entry)
51023721387SSimon Wunderlich return NULL;
51123721387SSimon Wunderlich
51223721387SSimon Wunderlich entry->vid = vid;
51323721387SSimon Wunderlich entry->lasttime = jiffies;
5143964f728SSven Eckelmann entry->crc = BATADV_BLA_CRC_INIT;
51523721387SSimon Wunderlich entry->bat_priv = bat_priv;
5165a1dd8a4SSimon Wunderlich spin_lock_init(&entry->crc_lock);
51723721387SSimon Wunderlich atomic_set(&entry->request_sent, 0);
51828709878SSimon Wunderlich atomic_set(&entry->wait_periods, 0);
5198fdd0153SAntonio Quartulli ether_addr_copy(entry->orig, orig);
520cd9c7bfbSSimon Wunderlich INIT_WORK(&entry->report_work, batadv_bla_loopdetect_report);
52106e56dedSSven Eckelmann kref_init(&entry->refcount);
52223721387SSimon Wunderlich
5234e8389e1SSven Eckelmann kref_get(&entry->refcount);
524807736f6SSven Eckelmann hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
5253b300de3SSven Eckelmann batadv_compare_backbone_gw,
5263b300de3SSven Eckelmann batadv_choose_backbone_gw, entry,
5273b300de3SSven Eckelmann &entry->hash_entry);
52823721387SSimon Wunderlich
52923721387SSimon Wunderlich if (unlikely(hash_added != 0)) {
53023721387SSimon Wunderlich /* hash failed, free the structure */
53123721387SSimon Wunderlich kfree(entry);
53223721387SSimon Wunderlich return NULL;
53323721387SSimon Wunderlich }
53423721387SSimon Wunderlich
53595fb130dSAntonio Quartulli /* this is a gateway now, remove any TT entry on this VLAN */
536da641193SSven Eckelmann orig_node = batadv_orig_hash_find(bat_priv, orig);
53720ff9d59SSimon Wunderlich if (orig_node) {
53895fb130dSAntonio Quartulli batadv_tt_global_del_orig(bat_priv, orig_node, vid,
53920ff9d59SSimon Wunderlich "became a backbone gateway");
5405d967310SSven Eckelmann batadv_orig_node_put(orig_node);
54120ff9d59SSimon Wunderlich }
54252aebd6aSSimon Wunderlich
543d807f272SSimon Wunderlich if (own_backbone) {
54452aebd6aSSimon Wunderlich batadv_bla_send_announce(bat_priv, entry);
54552aebd6aSSimon Wunderlich
546d807f272SSimon Wunderlich /* this will be decreased in the worker thread */
547d807f272SSimon Wunderlich atomic_inc(&entry->request_sent);
54828709878SSimon Wunderlich atomic_set(&entry->wait_periods, BATADV_BLA_WAIT_PERIODS);
549d807f272SSimon Wunderlich atomic_inc(&bat_priv->bla.num_requests);
550d807f272SSimon Wunderlich }
551d807f272SSimon Wunderlich
55223721387SSimon Wunderlich return entry;
55323721387SSimon Wunderlich }
55423721387SSimon Wunderlich
55504e14be6SSimon Wunderlich /**
5567e9a8c2cSSven Eckelmann * batadv_bla_update_own_backbone_gw() - updates the own backbone gw for a VLAN
55704e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
55804e14be6SSimon Wunderlich * @primary_if: the selected primary interface
55904e14be6SSimon Wunderlich * @vid: VLAN identifier
56004e14be6SSimon Wunderlich *
56104e14be6SSimon Wunderlich * update or add the own backbone gw to make sure we announce
56223721387SSimon Wunderlich * where we receive other backbone gws
56323721387SSimon Wunderlich */
56456303d34SSven Eckelmann static void
batadv_bla_update_own_backbone_gw(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,unsigned short vid)56556303d34SSven Eckelmann batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
56656303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
567eb2deb6bSAntonio Quartulli unsigned short vid)
56823721387SSimon Wunderlich {
569bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
57023721387SSimon Wunderlich
5713b300de3SSven Eckelmann backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
5723b300de3SSven Eckelmann primary_if->net_dev->dev_addr,
57352aebd6aSSimon Wunderlich vid, true);
57423721387SSimon Wunderlich if (unlikely(!backbone_gw))
57523721387SSimon Wunderlich return;
57623721387SSimon Wunderlich
57723721387SSimon Wunderlich backbone_gw->lasttime = jiffies;
578c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
57923721387SSimon Wunderlich }
58023721387SSimon Wunderlich
5811b371d13SSimon Wunderlich /**
5827e9a8c2cSSven Eckelmann * batadv_bla_answer_request() - answer a bla request by sending own claims
5831b371d13SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
584e3357189SMartin Hundebøll * @primary_if: interface where the request came on
58523721387SSimon Wunderlich * @vid: the vid where the request came on
58623721387SSimon Wunderlich *
58723721387SSimon Wunderlich * Repeat all of our own claims, and finally send an ANNOUNCE frame
58823721387SSimon Wunderlich * to allow the requester another check if the CRC is correct now.
58923721387SSimon Wunderlich */
batadv_bla_answer_request(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,unsigned short vid)59056303d34SSven Eckelmann static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
59156303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
592eb2deb6bSAntonio Quartulli unsigned short vid)
59323721387SSimon Wunderlich {
59423721387SSimon Wunderlich struct hlist_head *head;
5955bf74e9cSSven Eckelmann struct batadv_hashtable *hash;
596712bbfe4SMarek Lindner struct batadv_bla_claim *claim;
597bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
59823721387SSimon Wunderlich int i;
59923721387SSimon Wunderlich
60039c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
60122f0502eSSven Eckelmann "%s(): received a claim request, send all of our own claims again\n",
60222f0502eSSven Eckelmann __func__);
60323721387SSimon Wunderlich
6043b300de3SSven Eckelmann backbone_gw = batadv_backbone_hash_find(bat_priv,
6053b300de3SSven Eckelmann primary_if->net_dev->dev_addr,
6063b300de3SSven Eckelmann vid);
60723721387SSimon Wunderlich if (!backbone_gw)
60823721387SSimon Wunderlich return;
60923721387SSimon Wunderlich
610807736f6SSven Eckelmann hash = bat_priv->bla.claim_hash;
61123721387SSimon Wunderlich for (i = 0; i < hash->size; i++) {
61223721387SSimon Wunderlich head = &hash->table[i];
61323721387SSimon Wunderlich
61423721387SSimon Wunderlich rcu_read_lock();
615b67bfe0dSSasha Levin hlist_for_each_entry_rcu(claim, head, hash_entry) {
61623721387SSimon Wunderlich /* only own claims are interesting */
61723721387SSimon Wunderlich if (claim->backbone_gw != backbone_gw)
61823721387SSimon Wunderlich continue;
61923721387SSimon Wunderlich
6203b300de3SSven Eckelmann batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
6213eb8773eSSimon Wunderlich BATADV_CLAIM_TYPE_CLAIM);
62223721387SSimon Wunderlich }
62323721387SSimon Wunderlich rcu_read_unlock();
62423721387SSimon Wunderlich }
62523721387SSimon Wunderlich
62623721387SSimon Wunderlich /* finally, send an announcement frame */
6273b300de3SSven Eckelmann batadv_bla_send_announce(bat_priv, backbone_gw);
628c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
62923721387SSimon Wunderlich }
63023721387SSimon Wunderlich
6311b371d13SSimon Wunderlich /**
6327e9a8c2cSSven Eckelmann * batadv_bla_send_request() - send a request to repeat claims
6331b371d13SSimon Wunderlich * @backbone_gw: the backbone gateway from whom we are out of sync
63423721387SSimon Wunderlich *
63523721387SSimon Wunderlich * When the crc is wrong, ask the backbone gateway for a full table update.
63623721387SSimon Wunderlich * After the request, it will repeat all of his own claims and finally
63723721387SSimon Wunderlich * send an announcement claim with which we can check again.
63823721387SSimon Wunderlich */
batadv_bla_send_request(struct batadv_bla_backbone_gw * backbone_gw)639bae98774SMarek Lindner static void batadv_bla_send_request(struct batadv_bla_backbone_gw *backbone_gw)
64023721387SSimon Wunderlich {
64123721387SSimon Wunderlich /* first, remove all old entries */
6423b300de3SSven Eckelmann batadv_bla_del_backbone_claims(backbone_gw);
64323721387SSimon Wunderlich
64439c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
64539c75a51SSven Eckelmann "Sending REQUEST to %pM\n", backbone_gw->orig);
64623721387SSimon Wunderlich
64723721387SSimon Wunderlich /* send request */
6483b300de3SSven Eckelmann batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
649acd34afaSSven Eckelmann backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
65023721387SSimon Wunderlich
65123721387SSimon Wunderlich /* no local broadcasts should be sent or received, for now. */
65223721387SSimon Wunderlich if (!atomic_read(&backbone_gw->request_sent)) {
653807736f6SSven Eckelmann atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
65423721387SSimon Wunderlich atomic_set(&backbone_gw->request_sent, 1);
65523721387SSimon Wunderlich }
65623721387SSimon Wunderlich }
65723721387SSimon Wunderlich
6581b371d13SSimon Wunderlich /**
6597e9a8c2cSSven Eckelmann * batadv_bla_send_announce() - Send an announcement frame
6601b371d13SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
66123721387SSimon Wunderlich * @backbone_gw: our backbone gateway which should be announced
66223721387SSimon Wunderlich */
batadv_bla_send_announce(struct batadv_priv * bat_priv,struct batadv_bla_backbone_gw * backbone_gw)66356303d34SSven Eckelmann static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
664bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw)
66523721387SSimon Wunderlich {
6666b5e971aSSven Eckelmann u8 mac[ETH_ALEN];
6673e2f1a1bSAl Viro __be16 crc;
66823721387SSimon Wunderlich
6693b300de3SSven Eckelmann memcpy(mac, batadv_announce_mac, 4);
6705a1dd8a4SSimon Wunderlich spin_lock_bh(&backbone_gw->crc_lock);
67123721387SSimon Wunderlich crc = htons(backbone_gw->crc);
6725a1dd8a4SSimon Wunderlich spin_unlock_bh(&backbone_gw->crc_lock);
6731a5852d8SAl Viro memcpy(&mac[4], &crc, 2);
67423721387SSimon Wunderlich
6753b300de3SSven Eckelmann batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
676acd34afaSSven Eckelmann BATADV_CLAIM_TYPE_ANNOUNCE);
67723721387SSimon Wunderlich }
67823721387SSimon Wunderlich
6792c53040fSBen Hutchings /**
6807e9a8c2cSSven Eckelmann * batadv_bla_add_claim() - Adds a claim in the claim hash
6812c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
68223721387SSimon Wunderlich * @mac: the mac address of the claim
68323721387SSimon Wunderlich * @vid: the VLAN ID of the frame
68423721387SSimon Wunderlich * @backbone_gw: the backbone gateway which claims it
68523721387SSimon Wunderlich */
batadv_bla_add_claim(struct batadv_priv * bat_priv,const u8 * mac,const unsigned short vid,struct batadv_bla_backbone_gw * backbone_gw)68656303d34SSven Eckelmann static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
6876b5e971aSSven Eckelmann const u8 *mac, const unsigned short vid,
688bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw)
68923721387SSimon Wunderlich {
6903db0decfSSven Eckelmann struct batadv_bla_backbone_gw *old_backbone_gw;
691712bbfe4SMarek Lindner struct batadv_bla_claim *claim;
692712bbfe4SMarek Lindner struct batadv_bla_claim search_claim;
6933db0decfSSven Eckelmann bool remove_crc = false;
69423721387SSimon Wunderlich int hash_added;
69523721387SSimon Wunderlich
6968fdd0153SAntonio Quartulli ether_addr_copy(search_claim.addr, mac);
69723721387SSimon Wunderlich search_claim.vid = vid;
6983b300de3SSven Eckelmann claim = batadv_claim_hash_find(bat_priv, &search_claim);
69923721387SSimon Wunderlich
70023721387SSimon Wunderlich /* create a new claim entry if it does not exist yet. */
70123721387SSimon Wunderlich if (!claim) {
70223721387SSimon Wunderlich claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
70323721387SSimon Wunderlich if (!claim)
70423721387SSimon Wunderlich return;
70523721387SSimon Wunderlich
7068fdd0153SAntonio Quartulli ether_addr_copy(claim->addr, mac);
7073db0decfSSven Eckelmann spin_lock_init(&claim->backbone_lock);
70823721387SSimon Wunderlich claim->vid = vid;
70923721387SSimon Wunderlich claim->lasttime = jiffies;
7103db0decfSSven Eckelmann kref_get(&backbone_gw->refcount);
71123721387SSimon Wunderlich claim->backbone_gw = backbone_gw;
71271b7e3d3SSven Eckelmann kref_init(&claim->refcount);
7137282ac39SSven Eckelmann
71439c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
71522f0502eSSven Eckelmann "%s(): adding new entry %pM, vid %d to hash ...\n",
71622f0502eSSven Eckelmann __func__, mac, batadv_print_vid(vid));
7177282ac39SSven Eckelmann
7187282ac39SSven Eckelmann kref_get(&claim->refcount);
719807736f6SSven Eckelmann hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
7203b300de3SSven Eckelmann batadv_compare_claim,
7213b300de3SSven Eckelmann batadv_choose_claim, claim,
7223b300de3SSven Eckelmann &claim->hash_entry);
72323721387SSimon Wunderlich
72423721387SSimon Wunderlich if (unlikely(hash_added != 0)) {
72523721387SSimon Wunderlich /* only local changes happened. */
72623721387SSimon Wunderlich kfree(claim);
72723721387SSimon Wunderlich return;
72823721387SSimon Wunderlich }
72923721387SSimon Wunderlich } else {
73023721387SSimon Wunderlich claim->lasttime = jiffies;
73123721387SSimon Wunderlich if (claim->backbone_gw == backbone_gw)
73223721387SSimon Wunderlich /* no need to register a new backbone */
73323721387SSimon Wunderlich goto claim_free_ref;
73423721387SSimon Wunderlich
73539c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
73622f0502eSSven Eckelmann "%s(): changing ownership for %pM, vid %d to gw %pM\n",
73722f0502eSSven Eckelmann __func__, mac, batadv_print_vid(vid),
73822f0502eSSven Eckelmann backbone_gw->orig);
73923721387SSimon Wunderlich
7403db0decfSSven Eckelmann remove_crc = true;
74123721387SSimon Wunderlich }
7423db0decfSSven Eckelmann
7433db0decfSSven Eckelmann /* replace backbone_gw atomically and adjust reference counters */
7443db0decfSSven Eckelmann spin_lock_bh(&claim->backbone_lock);
7453db0decfSSven Eckelmann old_backbone_gw = claim->backbone_gw;
74606e56dedSSven Eckelmann kref_get(&backbone_gw->refcount);
74723721387SSimon Wunderlich claim->backbone_gw = backbone_gw;
7483db0decfSSven Eckelmann spin_unlock_bh(&claim->backbone_lock);
74923721387SSimon Wunderlich
7503db0decfSSven Eckelmann if (remove_crc) {
7513db0decfSSven Eckelmann /* remove claim address from old backbone_gw */
7523db0decfSSven Eckelmann spin_lock_bh(&old_backbone_gw->crc_lock);
7533db0decfSSven Eckelmann old_backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
7543db0decfSSven Eckelmann spin_unlock_bh(&old_backbone_gw->crc_lock);
7553db0decfSSven Eckelmann }
7563db0decfSSven Eckelmann
7573db0decfSSven Eckelmann batadv_backbone_gw_put(old_backbone_gw);
7583db0decfSSven Eckelmann
7593db0decfSSven Eckelmann /* add claim address to new backbone_gw */
7605a1dd8a4SSimon Wunderlich spin_lock_bh(&backbone_gw->crc_lock);
76123721387SSimon Wunderlich backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
7625a1dd8a4SSimon Wunderlich spin_unlock_bh(&backbone_gw->crc_lock);
76323721387SSimon Wunderlich backbone_gw->lasttime = jiffies;
76423721387SSimon Wunderlich
76523721387SSimon Wunderlich claim_free_ref:
766321e3e08SSven Eckelmann batadv_claim_put(claim);
76723721387SSimon Wunderlich }
76823721387SSimon Wunderlich
76904e14be6SSimon Wunderlich /**
7707e9a8c2cSSven Eckelmann * batadv_bla_claim_get_backbone_gw() - Get valid reference for backbone_gw of
7713db0decfSSven Eckelmann * claim
7723db0decfSSven Eckelmann * @claim: claim whose backbone_gw should be returned
7733db0decfSSven Eckelmann *
7743db0decfSSven Eckelmann * Return: valid reference to claim::backbone_gw
7753db0decfSSven Eckelmann */
7763db0decfSSven Eckelmann static struct batadv_bla_backbone_gw *
batadv_bla_claim_get_backbone_gw(struct batadv_bla_claim * claim)7773db0decfSSven Eckelmann batadv_bla_claim_get_backbone_gw(struct batadv_bla_claim *claim)
7783db0decfSSven Eckelmann {
7793db0decfSSven Eckelmann struct batadv_bla_backbone_gw *backbone_gw;
7803db0decfSSven Eckelmann
7813db0decfSSven Eckelmann spin_lock_bh(&claim->backbone_lock);
7823db0decfSSven Eckelmann backbone_gw = claim->backbone_gw;
7833db0decfSSven Eckelmann kref_get(&backbone_gw->refcount);
7843db0decfSSven Eckelmann spin_unlock_bh(&claim->backbone_lock);
7853db0decfSSven Eckelmann
7863db0decfSSven Eckelmann return backbone_gw;
7873db0decfSSven Eckelmann }
7883db0decfSSven Eckelmann
7893db0decfSSven Eckelmann /**
7907e9a8c2cSSven Eckelmann * batadv_bla_del_claim() - delete a claim from the claim hash
79104e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
79204e14be6SSimon Wunderlich * @mac: mac address of the claim to be removed
79304e14be6SSimon Wunderlich * @vid: VLAN id for the claim to be removed
79423721387SSimon Wunderlich */
batadv_bla_del_claim(struct batadv_priv * bat_priv,const u8 * mac,const unsigned short vid)79556303d34SSven Eckelmann static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
7966b5e971aSSven Eckelmann const u8 *mac, const unsigned short vid)
79723721387SSimon Wunderlich {
798712bbfe4SMarek Lindner struct batadv_bla_claim search_claim, *claim;
7994ba104f4SSven Eckelmann struct batadv_bla_claim *claim_removed_entry;
8004ba104f4SSven Eckelmann struct hlist_node *claim_removed_node;
80123721387SSimon Wunderlich
8028fdd0153SAntonio Quartulli ether_addr_copy(search_claim.addr, mac);
80323721387SSimon Wunderlich search_claim.vid = vid;
8043b300de3SSven Eckelmann claim = batadv_claim_hash_find(bat_priv, &search_claim);
80523721387SSimon Wunderlich if (!claim)
80623721387SSimon Wunderlich return;
80723721387SSimon Wunderlich
80822f0502eSSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): %pM, vid %d\n", __func__,
809f7a2bd65SSven Eckelmann mac, batadv_print_vid(vid));
81023721387SSimon Wunderlich
8114ba104f4SSven Eckelmann claim_removed_node = batadv_hash_remove(bat_priv->bla.claim_hash,
8124ba104f4SSven Eckelmann batadv_compare_claim,
8133b300de3SSven Eckelmann batadv_choose_claim, claim);
8144ba104f4SSven Eckelmann if (!claim_removed_node)
8154ba104f4SSven Eckelmann goto free_claim;
81623721387SSimon Wunderlich
8174ba104f4SSven Eckelmann /* reference from the hash is gone */
8184ba104f4SSven Eckelmann claim_removed_entry = hlist_entry(claim_removed_node,
8194ba104f4SSven Eckelmann struct batadv_bla_claim, hash_entry);
8204ba104f4SSven Eckelmann batadv_claim_put(claim_removed_entry);
8214ba104f4SSven Eckelmann
8224ba104f4SSven Eckelmann free_claim:
82323721387SSimon Wunderlich /* don't need the reference from hash_find() anymore */
824321e3e08SSven Eckelmann batadv_claim_put(claim);
82523721387SSimon Wunderlich }
82623721387SSimon Wunderlich
82762fe710fSSven Eckelmann /**
8287e9a8c2cSSven Eckelmann * batadv_handle_announce() - check for ANNOUNCE frame
82904e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
83004e14be6SSimon Wunderlich * @an_addr: announcement mac address (ARP Sender HW address)
83104e14be6SSimon Wunderlich * @backbone_addr: originator address of the sender (Ethernet source MAC)
83204e14be6SSimon Wunderlich * @vid: the VLAN ID of the frame
83362fe710fSSven Eckelmann *
8344b426b10SSven Eckelmann * Return: true if handled
83562fe710fSSven Eckelmann */
batadv_handle_announce(struct batadv_priv * bat_priv,u8 * an_addr,u8 * backbone_addr,unsigned short vid)8364b426b10SSven Eckelmann static bool batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
8376b5e971aSSven Eckelmann u8 *backbone_addr, unsigned short vid)
83823721387SSimon Wunderlich {
839bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
8405a1dd8a4SSimon Wunderlich u16 backbone_crc, crc;
84123721387SSimon Wunderlich
8423b300de3SSven Eckelmann if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
8434b426b10SSven Eckelmann return false;
84423721387SSimon Wunderlich
84552aebd6aSSimon Wunderlich backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
84652aebd6aSSimon Wunderlich false);
84723721387SSimon Wunderlich
84823721387SSimon Wunderlich if (unlikely(!backbone_gw))
8494b426b10SSven Eckelmann return true;
85023721387SSimon Wunderlich
85123721387SSimon Wunderlich /* handle as ANNOUNCE frame */
85223721387SSimon Wunderlich backbone_gw->lasttime = jiffies;
85361a29286SSven Eckelmann crc = ntohs(*((__force __be16 *)(&an_addr[4])));
85423721387SSimon Wunderlich
85539c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
85622f0502eSSven Eckelmann "%s(): ANNOUNCE vid %d (sent by %pM)... CRC = %#.4x\n",
85722f0502eSSven Eckelmann __func__, batadv_print_vid(vid), backbone_gw->orig, crc);
85823721387SSimon Wunderlich
8595a1dd8a4SSimon Wunderlich spin_lock_bh(&backbone_gw->crc_lock);
8605a1dd8a4SSimon Wunderlich backbone_crc = backbone_gw->crc;
8615a1dd8a4SSimon Wunderlich spin_unlock_bh(&backbone_gw->crc_lock);
8625a1dd8a4SSimon Wunderlich
8635a1dd8a4SSimon Wunderlich if (backbone_crc != crc) {
86439c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
86522f0502eSSven Eckelmann "%s(): CRC FAILED for %pM/%d (my = %#.4x, sent = %#.4x)\n",
86622f0502eSSven Eckelmann __func__, backbone_gw->orig,
867f7a2bd65SSven Eckelmann batadv_print_vid(backbone_gw->vid),
8685a1dd8a4SSimon Wunderlich backbone_crc, crc);
86923721387SSimon Wunderlich
8703b300de3SSven Eckelmann batadv_bla_send_request(backbone_gw);
87123721387SSimon Wunderlich } else {
87223721387SSimon Wunderlich /* if we have sent a request and the crc was OK,
87323721387SSimon Wunderlich * we can allow traffic again.
87423721387SSimon Wunderlich */
87523721387SSimon Wunderlich if (atomic_read(&backbone_gw->request_sent)) {
876807736f6SSven Eckelmann atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
87723721387SSimon Wunderlich atomic_set(&backbone_gw->request_sent, 0);
87823721387SSimon Wunderlich }
87923721387SSimon Wunderlich }
88023721387SSimon Wunderlich
881c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
8824b426b10SSven Eckelmann return true;
88323721387SSimon Wunderlich }
88423721387SSimon Wunderlich
88562fe710fSSven Eckelmann /**
8867e9a8c2cSSven Eckelmann * batadv_handle_request() - check for REQUEST frame
88704e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
88804e14be6SSimon Wunderlich * @primary_if: the primary hard interface of this batman soft interface
88904e14be6SSimon Wunderlich * @backbone_addr: backbone address to be requested (ARP sender HW MAC)
89004e14be6SSimon Wunderlich * @ethhdr: ethernet header of a packet
89104e14be6SSimon Wunderlich * @vid: the VLAN ID of the frame
89262fe710fSSven Eckelmann *
8934b426b10SSven Eckelmann * Return: true if handled
89462fe710fSSven Eckelmann */
batadv_handle_request(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,u8 * backbone_addr,struct ethhdr * ethhdr,unsigned short vid)8954b426b10SSven Eckelmann static bool batadv_handle_request(struct batadv_priv *bat_priv,
89656303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
8976b5e971aSSven Eckelmann u8 *backbone_addr, struct ethhdr *ethhdr,
8986b5e971aSSven Eckelmann unsigned short vid)
89923721387SSimon Wunderlich {
90023721387SSimon Wunderlich /* check for REQUEST frame */
9011eda58bfSSven Eckelmann if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
9024b426b10SSven Eckelmann return false;
90323721387SSimon Wunderlich
90423721387SSimon Wunderlich /* sanity check, this should not happen on a normal switch,
90523721387SSimon Wunderlich * we ignore it in this case.
90623721387SSimon Wunderlich */
9071eda58bfSSven Eckelmann if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
9084b426b10SSven Eckelmann return true;
90923721387SSimon Wunderlich
91039c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
91122f0502eSSven Eckelmann "%s(): REQUEST vid %d (sent by %pM)...\n",
91222f0502eSSven Eckelmann __func__, batadv_print_vid(vid), ethhdr->h_source);
91323721387SSimon Wunderlich
9143b300de3SSven Eckelmann batadv_bla_answer_request(bat_priv, primary_if, vid);
9154b426b10SSven Eckelmann return true;
91623721387SSimon Wunderlich }
91723721387SSimon Wunderlich
91862fe710fSSven Eckelmann /**
9197e9a8c2cSSven Eckelmann * batadv_handle_unclaim() - check for UNCLAIM frame
92004e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
92104e14be6SSimon Wunderlich * @primary_if: the primary hard interface of this batman soft interface
92204e14be6SSimon Wunderlich * @backbone_addr: originator address of the backbone (Ethernet source)
92304e14be6SSimon Wunderlich * @claim_addr: Client to be unclaimed (ARP sender HW MAC)
92404e14be6SSimon Wunderlich * @vid: the VLAN ID of the frame
92562fe710fSSven Eckelmann *
9264b426b10SSven Eckelmann * Return: true if handled
92762fe710fSSven Eckelmann */
batadv_handle_unclaim(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,const u8 * backbone_addr,const u8 * claim_addr,unsigned short vid)9284b426b10SSven Eckelmann static bool batadv_handle_unclaim(struct batadv_priv *bat_priv,
92956303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
93047ce5f1eSJakub Kicinski const u8 *backbone_addr, const u8 *claim_addr,
9316b5e971aSSven Eckelmann unsigned short vid)
93223721387SSimon Wunderlich {
933bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
93423721387SSimon Wunderlich
93523721387SSimon Wunderlich /* unclaim in any case if it is our own */
9361eda58bfSSven Eckelmann if (primary_if && batadv_compare_eth(backbone_addr,
93723721387SSimon Wunderlich primary_if->net_dev->dev_addr))
9383b300de3SSven Eckelmann batadv_bla_send_claim(bat_priv, claim_addr, vid,
9393eb8773eSSimon Wunderlich BATADV_CLAIM_TYPE_UNCLAIM);
94023721387SSimon Wunderlich
9413b300de3SSven Eckelmann backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
94223721387SSimon Wunderlich
94323721387SSimon Wunderlich if (!backbone_gw)
9444b426b10SSven Eckelmann return true;
94523721387SSimon Wunderlich
94623721387SSimon Wunderlich /* this must be an UNCLAIM frame */
94739c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
94822f0502eSSven Eckelmann "%s(): UNCLAIM %pM on vid %d (sent by %pM)...\n", __func__,
949f7a2bd65SSven Eckelmann claim_addr, batadv_print_vid(vid), backbone_gw->orig);
95023721387SSimon Wunderlich
9513b300de3SSven Eckelmann batadv_bla_del_claim(bat_priv, claim_addr, vid);
952c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
9534b426b10SSven Eckelmann return true;
95423721387SSimon Wunderlich }
95523721387SSimon Wunderlich
95662fe710fSSven Eckelmann /**
9577e9a8c2cSSven Eckelmann * batadv_handle_claim() - check for CLAIM frame
95804e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
95904e14be6SSimon Wunderlich * @primary_if: the primary hard interface of this batman soft interface
96004e14be6SSimon Wunderlich * @backbone_addr: originator address of the backbone (Ethernet Source)
96104e14be6SSimon Wunderlich * @claim_addr: client mac address to be claimed (ARP sender HW MAC)
96204e14be6SSimon Wunderlich * @vid: the VLAN ID of the frame
96362fe710fSSven Eckelmann *
9644b426b10SSven Eckelmann * Return: true if handled
96562fe710fSSven Eckelmann */
batadv_handle_claim(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,const u8 * backbone_addr,const u8 * claim_addr,unsigned short vid)9664b426b10SSven Eckelmann static bool batadv_handle_claim(struct batadv_priv *bat_priv,
96756303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
96847ce5f1eSJakub Kicinski const u8 *backbone_addr, const u8 *claim_addr,
969eb2deb6bSAntonio Quartulli unsigned short vid)
97023721387SSimon Wunderlich {
971bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
97223721387SSimon Wunderlich
97323721387SSimon Wunderlich /* register the gateway if not yet available, and add the claim. */
97423721387SSimon Wunderlich
97552aebd6aSSimon Wunderlich backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
97652aebd6aSSimon Wunderlich false);
97723721387SSimon Wunderlich
97823721387SSimon Wunderlich if (unlikely(!backbone_gw))
9794b426b10SSven Eckelmann return true;
98023721387SSimon Wunderlich
98123721387SSimon Wunderlich /* this must be a CLAIM frame */
9823b300de3SSven Eckelmann batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
9831eda58bfSSven Eckelmann if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
9843b300de3SSven Eckelmann batadv_bla_send_claim(bat_priv, claim_addr, vid,
9853eb8773eSSimon Wunderlich BATADV_CLAIM_TYPE_CLAIM);
98623721387SSimon Wunderlich
98723721387SSimon Wunderlich /* TODO: we could call something like tt_local_del() here. */
98823721387SSimon Wunderlich
989c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
9904b426b10SSven Eckelmann return true;
99123721387SSimon Wunderlich }
99223721387SSimon Wunderlich
9932c53040fSBen Hutchings /**
9947e9a8c2cSSven Eckelmann * batadv_check_claim_group() - check for claim group membership
9952c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
996e3357189SMartin Hundebøll * @primary_if: the primary interface of this batman interface
99738ef3d1dSSimon Wunderlich * @hw_src: the Hardware source in the ARP Header
99838ef3d1dSSimon Wunderlich * @hw_dst: the Hardware destination in the ARP Header
99938ef3d1dSSimon Wunderlich * @ethhdr: pointer to the Ethernet header of the claim frame
100038ef3d1dSSimon Wunderlich *
1001bccb48c8SSven Eckelmann * checks if it is a claim packet and if it's on the same group.
100238ef3d1dSSimon Wunderlich * This function also applies the group ID of the sender
100338ef3d1dSSimon Wunderlich * if it is in the same mesh.
100438ef3d1dSSimon Wunderlich *
100562fe710fSSven Eckelmann * Return:
100638ef3d1dSSimon Wunderlich * 2 - if it is a claim packet and on the same group
100738ef3d1dSSimon Wunderlich * 1 - if is a claim packet from another group
100838ef3d1dSSimon Wunderlich * 0 - if it is not a claim packet
100938ef3d1dSSimon Wunderlich */
batadv_check_claim_group(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,u8 * hw_src,u8 * hw_dst,struct ethhdr * ethhdr)101056303d34SSven Eckelmann static int batadv_check_claim_group(struct batadv_priv *bat_priv,
101156303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
10126b5e971aSSven Eckelmann u8 *hw_src, u8 *hw_dst,
101338ef3d1dSSimon Wunderlich struct ethhdr *ethhdr)
101438ef3d1dSSimon Wunderlich {
10156b5e971aSSven Eckelmann u8 *backbone_addr;
101656303d34SSven Eckelmann struct batadv_orig_node *orig_node;
101796412690SSven Eckelmann struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
101838ef3d1dSSimon Wunderlich
101996412690SSven Eckelmann bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1020807736f6SSven Eckelmann bla_dst_own = &bat_priv->bla.claim_dest;
102138ef3d1dSSimon Wunderlich
102238ef3d1dSSimon Wunderlich /* if announcement packet, use the source,
102338ef3d1dSSimon Wunderlich * otherwise assume it is in the hw_src
102438ef3d1dSSimon Wunderlich */
102538ef3d1dSSimon Wunderlich switch (bla_dst->type) {
10263eb8773eSSimon Wunderlich case BATADV_CLAIM_TYPE_CLAIM:
102738ef3d1dSSimon Wunderlich backbone_addr = hw_src;
102838ef3d1dSSimon Wunderlich break;
1029acd34afaSSven Eckelmann case BATADV_CLAIM_TYPE_REQUEST:
1030acd34afaSSven Eckelmann case BATADV_CLAIM_TYPE_ANNOUNCE:
10313eb8773eSSimon Wunderlich case BATADV_CLAIM_TYPE_UNCLAIM:
103238ef3d1dSSimon Wunderlich backbone_addr = ethhdr->h_source;
103338ef3d1dSSimon Wunderlich break;
103438ef3d1dSSimon Wunderlich default:
103538ef3d1dSSimon Wunderlich return 0;
103638ef3d1dSSimon Wunderlich }
103738ef3d1dSSimon Wunderlich
103838ef3d1dSSimon Wunderlich /* don't accept claim frames from ourselves */
10391eda58bfSSven Eckelmann if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
104038ef3d1dSSimon Wunderlich return 0;
104138ef3d1dSSimon Wunderlich
104238ef3d1dSSimon Wunderlich /* if its already the same group, it is fine. */
104338ef3d1dSSimon Wunderlich if (bla_dst->group == bla_dst_own->group)
104438ef3d1dSSimon Wunderlich return 2;
104538ef3d1dSSimon Wunderlich
104638ef3d1dSSimon Wunderlich /* lets see if this originator is in our mesh */
1047da641193SSven Eckelmann orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
104838ef3d1dSSimon Wunderlich
1049791ad7f5SZheng Yongjun /* don't accept claims from gateways which are not in
105038ef3d1dSSimon Wunderlich * the same mesh or group.
105138ef3d1dSSimon Wunderlich */
105238ef3d1dSSimon Wunderlich if (!orig_node)
105338ef3d1dSSimon Wunderlich return 1;
105438ef3d1dSSimon Wunderlich
105538ef3d1dSSimon Wunderlich /* if our mesh friends mac is bigger, use it for ourselves. */
105638ef3d1dSSimon Wunderlich if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
105739c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
105839a32991SAntonio Quartulli "taking other backbones claim group: %#.4x\n",
105938ef3d1dSSimon Wunderlich ntohs(bla_dst->group));
106038ef3d1dSSimon Wunderlich bla_dst_own->group = bla_dst->group;
106138ef3d1dSSimon Wunderlich }
106238ef3d1dSSimon Wunderlich
10635d967310SSven Eckelmann batadv_orig_node_put(orig_node);
106438ef3d1dSSimon Wunderlich
106538ef3d1dSSimon Wunderlich return 2;
106638ef3d1dSSimon Wunderlich }
106738ef3d1dSSimon Wunderlich
10681b371d13SSimon Wunderlich /**
10697e9a8c2cSSven Eckelmann * batadv_bla_process_claim() - Check if this is a claim frame, and process it
10701b371d13SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
1071e3357189SMartin Hundebøll * @primary_if: the primary hard interface of this batman soft interface
107223721387SSimon Wunderlich * @skb: the frame to be checked
107323721387SSimon Wunderlich *
10744b426b10SSven Eckelmann * Return: true if it was a claim frame, otherwise return false to
107523721387SSimon Wunderlich * tell the callee that it can use the frame on its own.
107623721387SSimon Wunderlich */
batadv_bla_process_claim(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,struct sk_buff * skb)10774b426b10SSven Eckelmann static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,
107856303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
107923721387SSimon Wunderlich struct sk_buff *skb)
108023721387SSimon Wunderlich {
1081d46b6bfaSSimon Wunderlich struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
10826b5e971aSSven Eckelmann u8 *hw_src, *hw_dst;
1083d46b6bfaSSimon Wunderlich struct vlan_hdr *vhdr, vhdr_buf;
1084c018ad3dSAntonio Quartulli struct ethhdr *ethhdr;
1085c018ad3dSAntonio Quartulli struct arphdr *arphdr;
1086c018ad3dSAntonio Quartulli unsigned short vid;
1087d46b6bfaSSimon Wunderlich int vlan_depth = 0;
1088293e9338SAntonio Quartulli __be16 proto;
108923721387SSimon Wunderlich int headlen;
109038ef3d1dSSimon Wunderlich int ret;
109123721387SSimon Wunderlich
1092c018ad3dSAntonio Quartulli vid = batadv_get_vid(skb, 0);
10937ed4be95SAntonio Quartulli ethhdr = eth_hdr(skb);
109423721387SSimon Wunderlich
1095293e9338SAntonio Quartulli proto = ethhdr->h_proto;
10960d125074SAntonio Quartulli headlen = ETH_HLEN;
1097c018ad3dSAntonio Quartulli if (vid & BATADV_VLAN_HAS_TAG) {
1098d46b6bfaSSimon Wunderlich /* Traverse the VLAN/Ethertypes.
1099d46b6bfaSSimon Wunderlich *
1100d46b6bfaSSimon Wunderlich * At this point it is known that the first protocol is a VLAN
1101d46b6bfaSSimon Wunderlich * header, so start checking at the encapsulated protocol.
1102d46b6bfaSSimon Wunderlich *
1103d46b6bfaSSimon Wunderlich * The depth of the VLAN headers is recorded to drop BLA claim
1104d46b6bfaSSimon Wunderlich * frames encapsulated into multiple VLAN headers (QinQ).
1105d46b6bfaSSimon Wunderlich */
1106d46b6bfaSSimon Wunderlich do {
1107d46b6bfaSSimon Wunderlich vhdr = skb_header_pointer(skb, headlen, VLAN_HLEN,
1108d46b6bfaSSimon Wunderlich &vhdr_buf);
1109d46b6bfaSSimon Wunderlich if (!vhdr)
11104b426b10SSven Eckelmann return false;
1111d46b6bfaSSimon Wunderlich
1112c018ad3dSAntonio Quartulli proto = vhdr->h_vlan_encapsulated_proto;
1113c018ad3dSAntonio Quartulli headlen += VLAN_HLEN;
1114d46b6bfaSSimon Wunderlich vlan_depth++;
1115d46b6bfaSSimon Wunderlich } while (proto == htons(ETH_P_8021Q));
111623721387SSimon Wunderlich }
111723721387SSimon Wunderlich
1118293e9338SAntonio Quartulli if (proto != htons(ETH_P_ARP))
11194b426b10SSven Eckelmann return false; /* not a claim frame */
112023721387SSimon Wunderlich
112123721387SSimon Wunderlich /* this must be a ARP frame. check if it is a claim. */
112223721387SSimon Wunderlich
112323721387SSimon Wunderlich if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
11244b426b10SSven Eckelmann return false;
112523721387SSimon Wunderlich
112623721387SSimon Wunderlich /* pskb_may_pull() may have modified the pointers, get ethhdr again */
11277ed4be95SAntonio Quartulli ethhdr = eth_hdr(skb);
11286b5e971aSSven Eckelmann arphdr = (struct arphdr *)((u8 *)ethhdr + headlen);
112923721387SSimon Wunderlich
113023721387SSimon Wunderlich /* Check whether the ARP frame carries a valid
113123721387SSimon Wunderlich * IP information
113223721387SSimon Wunderlich */
113323721387SSimon Wunderlich if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
11344b426b10SSven Eckelmann return false;
113523721387SSimon Wunderlich if (arphdr->ar_pro != htons(ETH_P_IP))
11364b426b10SSven Eckelmann return false;
113723721387SSimon Wunderlich if (arphdr->ar_hln != ETH_ALEN)
11384b426b10SSven Eckelmann return false;
113923721387SSimon Wunderlich if (arphdr->ar_pln != 4)
11404b426b10SSven Eckelmann return false;
114123721387SSimon Wunderlich
11426b5e971aSSven Eckelmann hw_src = (u8 *)arphdr + sizeof(struct arphdr);
114323721387SSimon Wunderlich hw_dst = hw_src + ETH_ALEN + 4;
114496412690SSven Eckelmann bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1145d46b6bfaSSimon Wunderlich bla_dst_own = &bat_priv->bla.claim_dest;
1146d46b6bfaSSimon Wunderlich
1147d46b6bfaSSimon Wunderlich /* check if it is a claim frame in general */
1148d46b6bfaSSimon Wunderlich if (memcmp(bla_dst->magic, bla_dst_own->magic,
1149d46b6bfaSSimon Wunderlich sizeof(bla_dst->magic)) != 0)
11504b426b10SSven Eckelmann return false;
1151d46b6bfaSSimon Wunderlich
1152d46b6bfaSSimon Wunderlich /* check if there is a claim frame encapsulated deeper in (QinQ) and
1153d46b6bfaSSimon Wunderlich * drop that, as this is not supported by BLA but should also not be
1154d46b6bfaSSimon Wunderlich * sent via the mesh.
1155d46b6bfaSSimon Wunderlich */
1156d46b6bfaSSimon Wunderlich if (vlan_depth > 1)
11574b426b10SSven Eckelmann return true;
115823721387SSimon Wunderlich
1159cd9c7bfbSSimon Wunderlich /* Let the loopdetect frames on the mesh in any case. */
1160cd9c7bfbSSimon Wunderlich if (bla_dst->type == BATADV_CLAIM_TYPE_LOOPDETECT)
11614fd261bfSkbuild test robot return false;
1162cd9c7bfbSSimon Wunderlich
116323721387SSimon Wunderlich /* check if it is a claim frame. */
11643b300de3SSven Eckelmann ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
11653b300de3SSven Eckelmann ethhdr);
116638ef3d1dSSimon Wunderlich if (ret == 1)
116739c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
116822f0502eSSven Eckelmann "%s(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
116922f0502eSSven Eckelmann __func__, ethhdr->h_source, batadv_print_vid(vid),
117022f0502eSSven Eckelmann hw_src, hw_dst);
117138ef3d1dSSimon Wunderlich
117238ef3d1dSSimon Wunderlich if (ret < 2)
11734b426b10SSven Eckelmann return !!ret;
117423721387SSimon Wunderlich
117523721387SSimon Wunderlich /* become a backbone gw ourselves on this vlan if not happened yet */
11763b300de3SSven Eckelmann batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
117723721387SSimon Wunderlich
117823721387SSimon Wunderlich /* check for the different types of claim frames ... */
117923721387SSimon Wunderlich switch (bla_dst->type) {
11803eb8773eSSimon Wunderlich case BATADV_CLAIM_TYPE_CLAIM:
11813b300de3SSven Eckelmann if (batadv_handle_claim(bat_priv, primary_if, hw_src,
118223721387SSimon Wunderlich ethhdr->h_source, vid))
11834b426b10SSven Eckelmann return true;
118423721387SSimon Wunderlich break;
11853eb8773eSSimon Wunderlich case BATADV_CLAIM_TYPE_UNCLAIM:
11863b300de3SSven Eckelmann if (batadv_handle_unclaim(bat_priv, primary_if,
118723721387SSimon Wunderlich ethhdr->h_source, hw_src, vid))
11884b426b10SSven Eckelmann return true;
118923721387SSimon Wunderlich break;
119023721387SSimon Wunderlich
1191acd34afaSSven Eckelmann case BATADV_CLAIM_TYPE_ANNOUNCE:
11923b300de3SSven Eckelmann if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
11933b300de3SSven Eckelmann vid))
11944b426b10SSven Eckelmann return true;
119523721387SSimon Wunderlich break;
1196acd34afaSSven Eckelmann case BATADV_CLAIM_TYPE_REQUEST:
11973b300de3SSven Eckelmann if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
11983b300de3SSven Eckelmann vid))
11994b426b10SSven Eckelmann return true;
120023721387SSimon Wunderlich break;
120123721387SSimon Wunderlich }
120223721387SSimon Wunderlich
120339c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
120422f0502eSSven Eckelmann "%s(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
120522f0502eSSven Eckelmann __func__, ethhdr->h_source, batadv_print_vid(vid), hw_src,
120622f0502eSSven Eckelmann hw_dst);
12074b426b10SSven Eckelmann return true;
120823721387SSimon Wunderlich }
120923721387SSimon Wunderlich
121004e14be6SSimon Wunderlich /**
12117e9a8c2cSSven Eckelmann * batadv_bla_purge_backbone_gw() - Remove backbone gateways after a timeout or
121204e14be6SSimon Wunderlich * immediately
121304e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
121404e14be6SSimon Wunderlich * @now: whether the whole hash shall be wiped now
121504e14be6SSimon Wunderlich *
121604e14be6SSimon Wunderlich * Check when we last heard from other nodes, and remove them in case of
121723721387SSimon Wunderlich * a time out, or clean all backbone gws if now is set.
121823721387SSimon Wunderlich */
batadv_bla_purge_backbone_gw(struct batadv_priv * bat_priv,int now)121956303d34SSven Eckelmann static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
122023721387SSimon Wunderlich {
1221bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
1222b67bfe0dSSasha Levin struct hlist_node *node_tmp;
122323721387SSimon Wunderlich struct hlist_head *head;
12245bf74e9cSSven Eckelmann struct batadv_hashtable *hash;
122523721387SSimon Wunderlich spinlock_t *list_lock; /* protects write access to the hash lists */
122623721387SSimon Wunderlich int i;
122723721387SSimon Wunderlich
1228807736f6SSven Eckelmann hash = bat_priv->bla.backbone_hash;
122923721387SSimon Wunderlich if (!hash)
123023721387SSimon Wunderlich return;
123123721387SSimon Wunderlich
123223721387SSimon Wunderlich for (i = 0; i < hash->size; i++) {
123323721387SSimon Wunderlich head = &hash->table[i];
123423721387SSimon Wunderlich list_lock = &hash->list_locks[i];
123523721387SSimon Wunderlich
123623721387SSimon Wunderlich spin_lock_bh(list_lock);
1237b67bfe0dSSasha Levin hlist_for_each_entry_safe(backbone_gw, node_tmp,
123823721387SSimon Wunderlich head, hash_entry) {
123923721387SSimon Wunderlich if (now)
124023721387SSimon Wunderlich goto purge_now;
12411eda58bfSSven Eckelmann if (!batadv_has_timed_out(backbone_gw->lasttime,
124242d0b044SSven Eckelmann BATADV_BLA_BACKBONE_TIMEOUT))
124323721387SSimon Wunderlich continue;
124423721387SSimon Wunderlich
124539c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
124622f0502eSSven Eckelmann "%s(): backbone gw %pM timed out\n",
124722f0502eSSven Eckelmann __func__, backbone_gw->orig);
124823721387SSimon Wunderlich
124923721387SSimon Wunderlich purge_now:
125023721387SSimon Wunderlich /* don't wait for the pending request anymore */
125123721387SSimon Wunderlich if (atomic_read(&backbone_gw->request_sent))
1252807736f6SSven Eckelmann atomic_dec(&bat_priv->bla.num_requests);
125323721387SSimon Wunderlich
12543b300de3SSven Eckelmann batadv_bla_del_backbone_claims(backbone_gw);
125523721387SSimon Wunderlich
1256b67bfe0dSSasha Levin hlist_del_rcu(&backbone_gw->hash_entry);
1257c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
125823721387SSimon Wunderlich }
125923721387SSimon Wunderlich spin_unlock_bh(list_lock);
126023721387SSimon Wunderlich }
126123721387SSimon Wunderlich }
126223721387SSimon Wunderlich
12632c53040fSBen Hutchings /**
12647e9a8c2cSSven Eckelmann * batadv_bla_purge_claims() - Remove claims after a timeout or immediately
12652c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
126623721387SSimon Wunderlich * @primary_if: the selected primary interface, may be NULL if now is set
126723721387SSimon Wunderlich * @now: whether the whole hash shall be wiped now
126823721387SSimon Wunderlich *
126923721387SSimon Wunderlich * Check when we heard last time from our own claims, and remove them in case of
127023721387SSimon Wunderlich * a time out, or clean all claims if now is set
127123721387SSimon Wunderlich */
batadv_bla_purge_claims(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,int now)127256303d34SSven Eckelmann static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
127356303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
127456303d34SSven Eckelmann int now)
127523721387SSimon Wunderlich {
12763db0decfSSven Eckelmann struct batadv_bla_backbone_gw *backbone_gw;
1277712bbfe4SMarek Lindner struct batadv_bla_claim *claim;
127823721387SSimon Wunderlich struct hlist_head *head;
12795bf74e9cSSven Eckelmann struct batadv_hashtable *hash;
128023721387SSimon Wunderlich int i;
128123721387SSimon Wunderlich
1282807736f6SSven Eckelmann hash = bat_priv->bla.claim_hash;
128323721387SSimon Wunderlich if (!hash)
128423721387SSimon Wunderlich return;
128523721387SSimon Wunderlich
128623721387SSimon Wunderlich for (i = 0; i < hash->size; i++) {
128723721387SSimon Wunderlich head = &hash->table[i];
128823721387SSimon Wunderlich
128923721387SSimon Wunderlich rcu_read_lock();
1290b67bfe0dSSasha Levin hlist_for_each_entry_rcu(claim, head, hash_entry) {
12913db0decfSSven Eckelmann backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
129223721387SSimon Wunderlich if (now)
129323721387SSimon Wunderlich goto purge_now;
12943db0decfSSven Eckelmann
12953db0decfSSven Eckelmann if (!batadv_compare_eth(backbone_gw->orig,
129623721387SSimon Wunderlich primary_if->net_dev->dev_addr))
12973db0decfSSven Eckelmann goto skip;
12983db0decfSSven Eckelmann
12991eda58bfSSven Eckelmann if (!batadv_has_timed_out(claim->lasttime,
130042d0b044SSven Eckelmann BATADV_BLA_CLAIM_TIMEOUT))
13013db0decfSSven Eckelmann goto skip;
130223721387SSimon Wunderlich
130339c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv,
130422f0502eSSven Eckelmann "%s(): timed out.\n", __func__);
130523721387SSimon Wunderlich
130623721387SSimon Wunderlich purge_now:
13074dd72f73SAndreas Pape batadv_dbg(BATADV_DBG_BLA, bat_priv,
130822f0502eSSven Eckelmann "%s(): %pM, vid %d\n", __func__,
13094dd72f73SAndreas Pape claim->addr, claim->vid);
13104dd72f73SAndreas Pape
13113b300de3SSven Eckelmann batadv_handle_unclaim(bat_priv, primary_if,
13123db0decfSSven Eckelmann backbone_gw->orig,
131323721387SSimon Wunderlich claim->addr, claim->vid);
13143db0decfSSven Eckelmann skip:
13153db0decfSSven Eckelmann batadv_backbone_gw_put(backbone_gw);
131623721387SSimon Wunderlich }
131723721387SSimon Wunderlich rcu_read_unlock();
131823721387SSimon Wunderlich }
131923721387SSimon Wunderlich }
132023721387SSimon Wunderlich
13212c53040fSBen Hutchings /**
13227e9a8c2cSSven Eckelmann * batadv_bla_update_orig_address() - Update the backbone gateways when the own
132304e14be6SSimon Wunderlich * originator address changes
13242c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
132523721387SSimon Wunderlich * @primary_if: the new selected primary_if
132623721387SSimon Wunderlich * @oldif: the old primary interface, may be NULL
132723721387SSimon Wunderlich */
batadv_bla_update_orig_address(struct batadv_priv * bat_priv,struct batadv_hard_iface * primary_if,struct batadv_hard_iface * oldif)132856303d34SSven Eckelmann void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
132956303d34SSven Eckelmann struct batadv_hard_iface *primary_if,
133056303d34SSven Eckelmann struct batadv_hard_iface *oldif)
133123721387SSimon Wunderlich {
1332bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
133323721387SSimon Wunderlich struct hlist_head *head;
13345bf74e9cSSven Eckelmann struct batadv_hashtable *hash;
1335807736f6SSven Eckelmann __be16 group;
133623721387SSimon Wunderlich int i;
133723721387SSimon Wunderlich
133838ef3d1dSSimon Wunderlich /* reset bridge loop avoidance group id */
1339807736f6SSven Eckelmann group = htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
1340807736f6SSven Eckelmann bat_priv->bla.claim_dest.group = group;
134138ef3d1dSSimon Wunderlich
1342d5b4c93eSSimon Wunderlich /* purge everything when bridge loop avoidance is turned off */
1343d5b4c93eSSimon Wunderlich if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1344d5b4c93eSSimon Wunderlich oldif = NULL;
1345d5b4c93eSSimon Wunderlich
134623721387SSimon Wunderlich if (!oldif) {
13473b300de3SSven Eckelmann batadv_bla_purge_claims(bat_priv, NULL, 1);
13483b300de3SSven Eckelmann batadv_bla_purge_backbone_gw(bat_priv, 1);
134923721387SSimon Wunderlich return;
135023721387SSimon Wunderlich }
135123721387SSimon Wunderlich
1352807736f6SSven Eckelmann hash = bat_priv->bla.backbone_hash;
135323721387SSimon Wunderlich if (!hash)
135423721387SSimon Wunderlich return;
135523721387SSimon Wunderlich
135623721387SSimon Wunderlich for (i = 0; i < hash->size; i++) {
135723721387SSimon Wunderlich head = &hash->table[i];
135823721387SSimon Wunderlich
135923721387SSimon Wunderlich rcu_read_lock();
1360b67bfe0dSSasha Levin hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
136123721387SSimon Wunderlich /* own orig still holds the old value. */
13621eda58bfSSven Eckelmann if (!batadv_compare_eth(backbone_gw->orig,
136323721387SSimon Wunderlich oldif->net_dev->dev_addr))
136423721387SSimon Wunderlich continue;
136523721387SSimon Wunderlich
13668fdd0153SAntonio Quartulli ether_addr_copy(backbone_gw->orig,
13678fdd0153SAntonio Quartulli primary_if->net_dev->dev_addr);
136823721387SSimon Wunderlich /* send an announce frame so others will ask for our
136923721387SSimon Wunderlich * claims and update their tables.
137023721387SSimon Wunderlich */
13713b300de3SSven Eckelmann batadv_bla_send_announce(bat_priv, backbone_gw);
137223721387SSimon Wunderlich }
137323721387SSimon Wunderlich rcu_read_unlock();
137423721387SSimon Wunderlich }
137523721387SSimon Wunderlich }
137623721387SSimon Wunderlich
1377d68081a2SSimon Wunderlich /**
13787e9a8c2cSSven Eckelmann * batadv_bla_send_loopdetect() - send a loopdetect frame
1379cd9c7bfbSSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
1380cd9c7bfbSSimon Wunderlich * @backbone_gw: the backbone gateway for which a loop should be detected
1381cd9c7bfbSSimon Wunderlich *
1382cd9c7bfbSSimon Wunderlich * To detect loops that the bridge loop avoidance can't handle, send a loop
1383cd9c7bfbSSimon Wunderlich * detection packet on the backbone. Unlike other BLA frames, this frame will
1384cd9c7bfbSSimon Wunderlich * be allowed on the mesh by other nodes. If it is received on the mesh, this
1385cd9c7bfbSSimon Wunderlich * indicates that there is a loop.
1386cd9c7bfbSSimon Wunderlich */
1387cd9c7bfbSSimon Wunderlich static void
batadv_bla_send_loopdetect(struct batadv_priv * bat_priv,struct batadv_bla_backbone_gw * backbone_gw)1388cd9c7bfbSSimon Wunderlich batadv_bla_send_loopdetect(struct batadv_priv *bat_priv,
1389cd9c7bfbSSimon Wunderlich struct batadv_bla_backbone_gw *backbone_gw)
1390cd9c7bfbSSimon Wunderlich {
1391cd9c7bfbSSimon Wunderlich batadv_dbg(BATADV_DBG_BLA, bat_priv, "Send loopdetect frame for vid %d\n",
1392cd9c7bfbSSimon Wunderlich backbone_gw->vid);
1393cd9c7bfbSSimon Wunderlich batadv_bla_send_claim(bat_priv, bat_priv->bla.loopdetect_addr,
1394cd9c7bfbSSimon Wunderlich backbone_gw->vid, BATADV_CLAIM_TYPE_LOOPDETECT);
1395cd9c7bfbSSimon Wunderlich }
1396cd9c7bfbSSimon Wunderlich
1397cd9c7bfbSSimon Wunderlich /**
13987e9a8c2cSSven Eckelmann * batadv_bla_status_update() - purge bla interfaces if necessary
1399d68081a2SSimon Wunderlich * @net_dev: the soft interface net device
1400d68081a2SSimon Wunderlich */
batadv_bla_status_update(struct net_device * net_dev)1401d68081a2SSimon Wunderlich void batadv_bla_status_update(struct net_device *net_dev)
1402d68081a2SSimon Wunderlich {
1403d68081a2SSimon Wunderlich struct batadv_priv *bat_priv = netdev_priv(net_dev);
1404d68081a2SSimon Wunderlich struct batadv_hard_iface *primary_if;
1405d68081a2SSimon Wunderlich
1406d68081a2SSimon Wunderlich primary_if = batadv_primary_if_get_selected(bat_priv);
1407d68081a2SSimon Wunderlich if (!primary_if)
1408d68081a2SSimon Wunderlich return;
1409d68081a2SSimon Wunderlich
1410d68081a2SSimon Wunderlich /* this function already purges everything when bla is disabled,
1411d68081a2SSimon Wunderlich * so just call that one.
1412d68081a2SSimon Wunderlich */
1413d68081a2SSimon Wunderlich batadv_bla_update_orig_address(bat_priv, primary_if, primary_if);
141482047ad7SSven Eckelmann batadv_hardif_put(primary_if);
1415d68081a2SSimon Wunderlich }
1416d68081a2SSimon Wunderlich
141704e14be6SSimon Wunderlich /**
14187e9a8c2cSSven Eckelmann * batadv_bla_periodic_work() - performs periodic bla work
141904e14be6SSimon Wunderlich * @work: kernel work struct
142004e14be6SSimon Wunderlich *
142104e14be6SSimon Wunderlich * periodic work to do:
142223721387SSimon Wunderlich * * purge structures when they are too old
142323721387SSimon Wunderlich * * send announcements
142423721387SSimon Wunderlich */
batadv_bla_periodic_work(struct work_struct * work)14253b300de3SSven Eckelmann static void batadv_bla_periodic_work(struct work_struct *work)
142623721387SSimon Wunderlich {
1427bbb1f90eSSven Eckelmann struct delayed_work *delayed_work;
142856303d34SSven Eckelmann struct batadv_priv *bat_priv;
1429807736f6SSven Eckelmann struct batadv_priv_bla *priv_bla;
143023721387SSimon Wunderlich struct hlist_head *head;
1431bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
14325bf74e9cSSven Eckelmann struct batadv_hashtable *hash;
143356303d34SSven Eckelmann struct batadv_hard_iface *primary_if;
1434cd9c7bfbSSimon Wunderlich bool send_loopdetect = false;
143523721387SSimon Wunderlich int i;
143623721387SSimon Wunderlich
14374ba4bc0fSGeliang Tang delayed_work = to_delayed_work(work);
1438807736f6SSven Eckelmann priv_bla = container_of(delayed_work, struct batadv_priv_bla, work);
1439807736f6SSven Eckelmann bat_priv = container_of(priv_bla, struct batadv_priv, bla);
1440e5d89254SSven Eckelmann primary_if = batadv_primary_if_get_selected(bat_priv);
144123721387SSimon Wunderlich if (!primary_if)
144223721387SSimon Wunderlich goto out;
144323721387SSimon Wunderlich
14443b300de3SSven Eckelmann batadv_bla_purge_claims(bat_priv, primary_if, 0);
14453b300de3SSven Eckelmann batadv_bla_purge_backbone_gw(bat_priv, 0);
144623721387SSimon Wunderlich
144723721387SSimon Wunderlich if (!atomic_read(&bat_priv->bridge_loop_avoidance))
144823721387SSimon Wunderlich goto out;
144923721387SSimon Wunderlich
1450cd9c7bfbSSimon Wunderlich if (atomic_dec_and_test(&bat_priv->bla.loopdetect_next)) {
1451cd9c7bfbSSimon Wunderlich /* set a new random mac address for the next bridge loop
1452cd9c7bfbSSimon Wunderlich * detection frames. Set the locally administered bit to avoid
1453cd9c7bfbSSimon Wunderlich * collisions with users mac addresses.
1454cd9c7bfbSSimon Wunderlich */
14556c1f0a1fSJoe Perches eth_random_addr(bat_priv->bla.loopdetect_addr);
1456cd9c7bfbSSimon Wunderlich bat_priv->bla.loopdetect_addr[0] = 0xba;
1457cd9c7bfbSSimon Wunderlich bat_priv->bla.loopdetect_addr[1] = 0xbe;
1458cd9c7bfbSSimon Wunderlich bat_priv->bla.loopdetect_lasttime = jiffies;
1459cd9c7bfbSSimon Wunderlich atomic_set(&bat_priv->bla.loopdetect_next,
1460cd9c7bfbSSimon Wunderlich BATADV_BLA_LOOPDETECT_PERIODS);
1461cd9c7bfbSSimon Wunderlich
1462cd9c7bfbSSimon Wunderlich /* mark for sending loop detect on all VLANs */
1463cd9c7bfbSSimon Wunderlich send_loopdetect = true;
1464cd9c7bfbSSimon Wunderlich }
1465cd9c7bfbSSimon Wunderlich
1466807736f6SSven Eckelmann hash = bat_priv->bla.backbone_hash;
146723721387SSimon Wunderlich if (!hash)
146823721387SSimon Wunderlich goto out;
146923721387SSimon Wunderlich
147023721387SSimon Wunderlich for (i = 0; i < hash->size; i++) {
147123721387SSimon Wunderlich head = &hash->table[i];
147223721387SSimon Wunderlich
147323721387SSimon Wunderlich rcu_read_lock();
1474b67bfe0dSSasha Levin hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
14751eda58bfSSven Eckelmann if (!batadv_compare_eth(backbone_gw->orig,
147623721387SSimon Wunderlich primary_if->net_dev->dev_addr))
147723721387SSimon Wunderlich continue;
147823721387SSimon Wunderlich
147923721387SSimon Wunderlich backbone_gw->lasttime = jiffies;
148023721387SSimon Wunderlich
14813b300de3SSven Eckelmann batadv_bla_send_announce(bat_priv, backbone_gw);
1482cd9c7bfbSSimon Wunderlich if (send_loopdetect)
1483cd9c7bfbSSimon Wunderlich batadv_bla_send_loopdetect(bat_priv,
1484cd9c7bfbSSimon Wunderlich backbone_gw);
1485d807f272SSimon Wunderlich
1486d807f272SSimon Wunderlich /* request_sent is only set after creation to avoid
1487d807f272SSimon Wunderlich * problems when we are not yet known as backbone gw
1488d807f272SSimon Wunderlich * in the backbone.
1489d807f272SSimon Wunderlich *
149028709878SSimon Wunderlich * We can reset this now after we waited some periods
149128709878SSimon Wunderlich * to give bridge forward delays and bla group forming
149228709878SSimon Wunderlich * some grace time.
1493d807f272SSimon Wunderlich */
1494d807f272SSimon Wunderlich
1495d807f272SSimon Wunderlich if (atomic_read(&backbone_gw->request_sent) == 0)
1496d807f272SSimon Wunderlich continue;
1497d807f272SSimon Wunderlich
149828709878SSimon Wunderlich if (!atomic_dec_and_test(&backbone_gw->wait_periods))
149928709878SSimon Wunderlich continue;
150028709878SSimon Wunderlich
1501d807f272SSimon Wunderlich atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
1502d807f272SSimon Wunderlich atomic_set(&backbone_gw->request_sent, 0);
150323721387SSimon Wunderlich }
150423721387SSimon Wunderlich rcu_read_unlock();
150523721387SSimon Wunderlich }
150623721387SSimon Wunderlich out:
150782047ad7SSven Eckelmann batadv_hardif_put(primary_if);
150823721387SSimon Wunderlich
150972414442SAntonio Quartulli queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
151072414442SAntonio Quartulli msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
151123721387SSimon Wunderlich }
151223721387SSimon Wunderlich
15135d52dad2SSven Eckelmann /* The hash for claim and backbone hash receive the same key because they
15145d52dad2SSven Eckelmann * are getting initialized by hash_new with the same key. Reinitializing
15155d52dad2SSven Eckelmann * them with to different keys to allow nested locking without generating
15165d52dad2SSven Eckelmann * lockdep warnings
15175d52dad2SSven Eckelmann */
15183b300de3SSven Eckelmann static struct lock_class_key batadv_claim_hash_lock_class_key;
15193b300de3SSven Eckelmann static struct lock_class_key batadv_backbone_hash_lock_class_key;
15205d52dad2SSven Eckelmann
152104e14be6SSimon Wunderlich /**
15227e9a8c2cSSven Eckelmann * batadv_bla_init() - initialize all bla structures
152304e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
152404e14be6SSimon Wunderlich *
152504e14be6SSimon Wunderlich * Return: 0 on success, < 0 on error.
152604e14be6SSimon Wunderlich */
batadv_bla_init(struct batadv_priv * bat_priv)152756303d34SSven Eckelmann int batadv_bla_init(struct batadv_priv *bat_priv)
152823721387SSimon Wunderlich {
1529fe2da6ffSSimon Wunderlich int i;
15306b5e971aSSven Eckelmann u8 claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
153156303d34SSven Eckelmann struct batadv_hard_iface *primary_if;
15326b5e971aSSven Eckelmann u16 crc;
1533807736f6SSven Eckelmann unsigned long entrytime;
1534fe2da6ffSSimon Wunderlich
15357dac7b76SLinus Lüssing spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
15367dac7b76SLinus Lüssing
153739c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
153823721387SSimon Wunderlich
153938ef3d1dSSimon Wunderlich /* setting claim destination address */
1540807736f6SSven Eckelmann memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
1541807736f6SSven Eckelmann bat_priv->bla.claim_dest.type = 0;
1542e5d89254SSven Eckelmann primary_if = batadv_primary_if_get_selected(bat_priv);
154338ef3d1dSSimon Wunderlich if (primary_if) {
1544807736f6SSven Eckelmann crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
1545807736f6SSven Eckelmann bat_priv->bla.claim_dest.group = htons(crc);
154682047ad7SSven Eckelmann batadv_hardif_put(primary_if);
154738ef3d1dSSimon Wunderlich } else {
1548807736f6SSven Eckelmann bat_priv->bla.claim_dest.group = 0; /* will be set later */
154938ef3d1dSSimon Wunderlich }
155038ef3d1dSSimon Wunderlich
1551fe2da6ffSSimon Wunderlich /* initialize the duplicate list */
1552807736f6SSven Eckelmann entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
155342d0b044SSven Eckelmann for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
1554807736f6SSven Eckelmann bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
1555807736f6SSven Eckelmann bat_priv->bla.bcast_duplist_curr = 0;
1556fe2da6ffSSimon Wunderlich
1557cd9c7bfbSSimon Wunderlich atomic_set(&bat_priv->bla.loopdetect_next,
1558cd9c7bfbSSimon Wunderlich BATADV_BLA_LOOPDETECT_PERIODS);
1559cd9c7bfbSSimon Wunderlich
1560807736f6SSven Eckelmann if (bat_priv->bla.claim_hash)
15615346c35eSSven Eckelmann return 0;
156223721387SSimon Wunderlich
1563807736f6SSven Eckelmann bat_priv->bla.claim_hash = batadv_hash_new(128);
15646f68cd63SPavel Skripkin if (!bat_priv->bla.claim_hash)
15655346c35eSSven Eckelmann return -ENOMEM;
156623721387SSimon Wunderlich
15676f68cd63SPavel Skripkin bat_priv->bla.backbone_hash = batadv_hash_new(32);
15686f68cd63SPavel Skripkin if (!bat_priv->bla.backbone_hash) {
15696f68cd63SPavel Skripkin batadv_hash_destroy(bat_priv->bla.claim_hash);
15706f68cd63SPavel Skripkin return -ENOMEM;
15716f68cd63SPavel Skripkin }
15726f68cd63SPavel Skripkin
1573807736f6SSven Eckelmann batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
15743b300de3SSven Eckelmann &batadv_claim_hash_lock_class_key);
1575807736f6SSven Eckelmann batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
15763b300de3SSven Eckelmann &batadv_backbone_hash_lock_class_key);
15775d52dad2SSven Eckelmann
157839c75a51SSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
157923721387SSimon Wunderlich
158072414442SAntonio Quartulli INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
158172414442SAntonio Quartulli
158272414442SAntonio Quartulli queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
158372414442SAntonio Quartulli msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
15845346c35eSSven Eckelmann return 0;
158523721387SSimon Wunderlich }
158623721387SSimon Wunderlich
15872c53040fSBen Hutchings /**
15882369e827SLinus Lüssing * batadv_bla_check_duplist() - Check if a frame is in the broadcast dup.
15892c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
15902369e827SLinus Lüssing * @skb: contains the multicast packet to be checked
15912369e827SLinus Lüssing * @payload_ptr: pointer to position inside the head buffer of the skb
15922369e827SLinus Lüssing * marking the start of the data to be CRC'ed
15932369e827SLinus Lüssing * @orig: originator mac address, NULL if unknown
1594fe2da6ffSSimon Wunderlich *
15952369e827SLinus Lüssing * Check if it is on our broadcast list. Another gateway might have sent the
15962369e827SLinus Lüssing * same packet because it is connected to the same backbone, so we have to
15972369e827SLinus Lüssing * remove this duplicate.
1598fe2da6ffSSimon Wunderlich *
1599fe2da6ffSSimon Wunderlich * This is performed by checking the CRC, which will tell us
1600fe2da6ffSSimon Wunderlich * with a good chance that it is the same packet. If it is furthermore
1601fe2da6ffSSimon Wunderlich * sent by another host, drop it. We allow equal packets from
1602fe2da6ffSSimon Wunderlich * the same host however as this might be intended.
160304e14be6SSimon Wunderlich *
16044b426b10SSven Eckelmann * Return: true if a packet is in the duplicate list, false otherwise.
16059cfc7bd6SSven Eckelmann */
batadv_bla_check_duplist(struct batadv_priv * bat_priv,struct sk_buff * skb,u8 * payload_ptr,const u8 * orig)16062369e827SLinus Lüssing static bool batadv_bla_check_duplist(struct batadv_priv *bat_priv,
16072369e827SLinus Lüssing struct sk_buff *skb, u8 *payload_ptr,
16082369e827SLinus Lüssing const u8 *orig)
1609fe2da6ffSSimon Wunderlich {
161056303d34SSven Eckelmann struct batadv_bcast_duplist_entry *entry;
16114b426b10SSven Eckelmann bool ret = false;
16122369e827SLinus Lüssing int i, curr;
16132369e827SLinus Lüssing __be32 crc;
1614fe2da6ffSSimon Wunderlich
1615fe2da6ffSSimon Wunderlich /* calculate the crc ... */
16162369e827SLinus Lüssing crc = batadv_skb_crc32(skb, payload_ptr);
1617fe2da6ffSSimon Wunderlich
16187dac7b76SLinus Lüssing spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
16197dac7b76SLinus Lüssing
162042d0b044SSven Eckelmann for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1621807736f6SSven Eckelmann curr = (bat_priv->bla.bcast_duplist_curr + i);
1622807736f6SSven Eckelmann curr %= BATADV_DUPLIST_SIZE;
1623807736f6SSven Eckelmann entry = &bat_priv->bla.bcast_duplist[curr];
1624fe2da6ffSSimon Wunderlich
1625fe2da6ffSSimon Wunderlich /* we can stop searching if the entry is too old ;
1626fe2da6ffSSimon Wunderlich * later entries will be even older
1627fe2da6ffSSimon Wunderlich */
162842d0b044SSven Eckelmann if (batadv_has_timed_out(entry->entrytime,
162942d0b044SSven Eckelmann BATADV_DUPLIST_TIMEOUT))
1630fe2da6ffSSimon Wunderlich break;
1631fe2da6ffSSimon Wunderlich
1632fe2da6ffSSimon Wunderlich if (entry->crc != crc)
1633fe2da6ffSSimon Wunderlich continue;
1634fe2da6ffSSimon Wunderlich
16352369e827SLinus Lüssing /* are the originators both known and not anonymous? */
16362369e827SLinus Lüssing if (orig && !is_zero_ether_addr(orig) &&
16372369e827SLinus Lüssing !is_zero_ether_addr(entry->orig)) {
16382369e827SLinus Lüssing /* If known, check if the new frame came from
16392369e827SLinus Lüssing * the same originator:
16402369e827SLinus Lüssing * We are safe to take identical frames from the
16412369e827SLinus Lüssing * same orig, if known, as multiplications in
16422369e827SLinus Lüssing * the mesh are detected via the (orig, seqno) pair.
16432369e827SLinus Lüssing * So we can be a bit more liberal here and allow
16442369e827SLinus Lüssing * identical frames from the same orig which the source
16452369e827SLinus Lüssing * host might have sent multiple times on purpose.
16462369e827SLinus Lüssing */
16472369e827SLinus Lüssing if (batadv_compare_eth(entry->orig, orig))
1648fe2da6ffSSimon Wunderlich continue;
16492369e827SLinus Lüssing }
1650fe2da6ffSSimon Wunderlich
1651fe2da6ffSSimon Wunderlich /* this entry seems to match: same crc, not too old,
16524b426b10SSven Eckelmann * and from another gw. therefore return true to forbid it.
1653fe2da6ffSSimon Wunderlich */
16544b426b10SSven Eckelmann ret = true;
16557dac7b76SLinus Lüssing goto out;
1656fe2da6ffSSimon Wunderlich }
16577dac7b76SLinus Lüssing /* not found, add a new entry (overwrite the oldest entry)
16583f68785eSAntonio Quartulli * and allow it, its the first occurrence.
16597dac7b76SLinus Lüssing */
1660807736f6SSven Eckelmann curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
166142d0b044SSven Eckelmann curr %= BATADV_DUPLIST_SIZE;
1662807736f6SSven Eckelmann entry = &bat_priv->bla.bcast_duplist[curr];
1663fe2da6ffSSimon Wunderlich entry->crc = crc;
1664fe2da6ffSSimon Wunderlich entry->entrytime = jiffies;
16652369e827SLinus Lüssing
16662369e827SLinus Lüssing /* known originator */
16672369e827SLinus Lüssing if (orig)
16682369e827SLinus Lüssing ether_addr_copy(entry->orig, orig);
16692369e827SLinus Lüssing /* anonymous originator */
16702369e827SLinus Lüssing else
16712369e827SLinus Lüssing eth_zero_addr(entry->orig);
16722369e827SLinus Lüssing
1673807736f6SSven Eckelmann bat_priv->bla.bcast_duplist_curr = curr;
1674fe2da6ffSSimon Wunderlich
16757dac7b76SLinus Lüssing out:
16767dac7b76SLinus Lüssing spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
16777dac7b76SLinus Lüssing
16787dac7b76SLinus Lüssing return ret;
1679fe2da6ffSSimon Wunderlich }
1680fe2da6ffSSimon Wunderlich
16811b371d13SSimon Wunderlich /**
16822369e827SLinus Lüssing * batadv_bla_check_ucast_duplist() - Check if a frame is in the broadcast dup.
16832369e827SLinus Lüssing * @bat_priv: the bat priv with all the soft interface information
16842369e827SLinus Lüssing * @skb: contains the multicast packet to be checked, decapsulated from a
16852369e827SLinus Lüssing * unicast_packet
16862369e827SLinus Lüssing *
16872369e827SLinus Lüssing * Check if it is on our broadcast list. Another gateway might have sent the
16882369e827SLinus Lüssing * same packet because it is connected to the same backbone, so we have to
16892369e827SLinus Lüssing * remove this duplicate.
16902369e827SLinus Lüssing *
16912369e827SLinus Lüssing * Return: true if a packet is in the duplicate list, false otherwise.
16922369e827SLinus Lüssing */
batadv_bla_check_ucast_duplist(struct batadv_priv * bat_priv,struct sk_buff * skb)16932369e827SLinus Lüssing static bool batadv_bla_check_ucast_duplist(struct batadv_priv *bat_priv,
16942369e827SLinus Lüssing struct sk_buff *skb)
16952369e827SLinus Lüssing {
16962369e827SLinus Lüssing return batadv_bla_check_duplist(bat_priv, skb, (u8 *)skb->data, NULL);
16972369e827SLinus Lüssing }
16982369e827SLinus Lüssing
16992369e827SLinus Lüssing /**
17002369e827SLinus Lüssing * batadv_bla_check_bcast_duplist() - Check if a frame is in the broadcast dup.
17012369e827SLinus Lüssing * @bat_priv: the bat priv with all the soft interface information
17022369e827SLinus Lüssing * @skb: contains the bcast_packet to be checked
17032369e827SLinus Lüssing *
17042369e827SLinus Lüssing * Check if it is on our broadcast list. Another gateway might have sent the
17052369e827SLinus Lüssing * same packet because it is connected to the same backbone, so we have to
17062369e827SLinus Lüssing * remove this duplicate.
17072369e827SLinus Lüssing *
17082369e827SLinus Lüssing * Return: true if a packet is in the duplicate list, false otherwise.
17092369e827SLinus Lüssing */
batadv_bla_check_bcast_duplist(struct batadv_priv * bat_priv,struct sk_buff * skb)17102369e827SLinus Lüssing bool batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
17112369e827SLinus Lüssing struct sk_buff *skb)
17122369e827SLinus Lüssing {
17132369e827SLinus Lüssing struct batadv_bcast_packet *bcast_packet;
17142369e827SLinus Lüssing u8 *payload_ptr;
17152369e827SLinus Lüssing
17162369e827SLinus Lüssing bcast_packet = (struct batadv_bcast_packet *)skb->data;
17172369e827SLinus Lüssing payload_ptr = (u8 *)(bcast_packet + 1);
17182369e827SLinus Lüssing
17192369e827SLinus Lüssing return batadv_bla_check_duplist(bat_priv, skb, payload_ptr,
17202369e827SLinus Lüssing bcast_packet->orig);
17212369e827SLinus Lüssing }
17222369e827SLinus Lüssing
17232369e827SLinus Lüssing /**
17247e9a8c2cSSven Eckelmann * batadv_bla_is_backbone_gw_orig() - Check if the originator is a gateway for
172504e14be6SSimon Wunderlich * the VLAN identified by vid.
17261b371d13SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
172720ff9d59SSimon Wunderlich * @orig: originator mac address
1728cfd4f757SAntonio Quartulli * @vid: VLAN identifier
172920ff9d59SSimon Wunderlich *
173062fe710fSSven Eckelmann * Return: true if orig is a backbone for this vid, false otherwise.
173120ff9d59SSimon Wunderlich */
batadv_bla_is_backbone_gw_orig(struct batadv_priv * bat_priv,u8 * orig,unsigned short vid)17326b5e971aSSven Eckelmann bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1733cfd4f757SAntonio Quartulli unsigned short vid)
173420ff9d59SSimon Wunderlich {
1735807736f6SSven Eckelmann struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
173620ff9d59SSimon Wunderlich struct hlist_head *head;
1737bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
173820ff9d59SSimon Wunderlich int i;
173920ff9d59SSimon Wunderlich
174020ff9d59SSimon Wunderlich if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1741cfd4f757SAntonio Quartulli return false;
174220ff9d59SSimon Wunderlich
174320ff9d59SSimon Wunderlich if (!hash)
1744cfd4f757SAntonio Quartulli return false;
174520ff9d59SSimon Wunderlich
174620ff9d59SSimon Wunderlich for (i = 0; i < hash->size; i++) {
174720ff9d59SSimon Wunderlich head = &hash->table[i];
174820ff9d59SSimon Wunderlich
174920ff9d59SSimon Wunderlich rcu_read_lock();
1750b67bfe0dSSasha Levin hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1751cfd4f757SAntonio Quartulli if (batadv_compare_eth(backbone_gw->orig, orig) &&
1752cfd4f757SAntonio Quartulli backbone_gw->vid == vid) {
175320ff9d59SSimon Wunderlich rcu_read_unlock();
1754cfd4f757SAntonio Quartulli return true;
175520ff9d59SSimon Wunderlich }
175620ff9d59SSimon Wunderlich }
175720ff9d59SSimon Wunderlich rcu_read_unlock();
175820ff9d59SSimon Wunderlich }
175920ff9d59SSimon Wunderlich
1760cfd4f757SAntonio Quartulli return false;
176120ff9d59SSimon Wunderlich }
176220ff9d59SSimon Wunderlich
17632c53040fSBen Hutchings /**
17647e9a8c2cSSven Eckelmann * batadv_bla_is_backbone_gw() - check if originator is a backbone gw for a VLAN
17652c53040fSBen Hutchings * @skb: the frame to be checked
176623721387SSimon Wunderlich * @orig_node: the orig_node of the frame
176723721387SSimon Wunderlich * @hdr_size: maximum length of the frame
176823721387SSimon Wunderlich *
17694b426b10SSven Eckelmann * Return: true if the orig_node is also a gateway on the soft interface,
17704b426b10SSven Eckelmann * otherwise it returns false.
177123721387SSimon Wunderlich */
batadv_bla_is_backbone_gw(struct sk_buff * skb,struct batadv_orig_node * orig_node,int hdr_size)17724b426b10SSven Eckelmann bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
177356303d34SSven Eckelmann struct batadv_orig_node *orig_node, int hdr_size)
177423721387SSimon Wunderlich {
1775bae98774SMarek Lindner struct batadv_bla_backbone_gw *backbone_gw;
1776c018ad3dSAntonio Quartulli unsigned short vid;
177723721387SSimon Wunderlich
177823721387SSimon Wunderlich if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
17794b426b10SSven Eckelmann return false;
178023721387SSimon Wunderlich
178123721387SSimon Wunderlich /* first, find out the vid. */
17820d125074SAntonio Quartulli if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
17834b426b10SSven Eckelmann return false;
178423721387SSimon Wunderlich
1785c018ad3dSAntonio Quartulli vid = batadv_get_vid(skb, hdr_size);
178623721387SSimon Wunderlich
178723721387SSimon Wunderlich /* see if this originator is a backbone gw for this VLAN */
17883b300de3SSven Eckelmann backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
178923721387SSimon Wunderlich orig_node->orig, vid);
179023721387SSimon Wunderlich if (!backbone_gw)
17914b426b10SSven Eckelmann return false;
179223721387SSimon Wunderlich
1793c8b86c12SSven Eckelmann batadv_backbone_gw_put(backbone_gw);
17944b426b10SSven Eckelmann return true;
179523721387SSimon Wunderlich }
179623721387SSimon Wunderlich
179704e14be6SSimon Wunderlich /**
17987e9a8c2cSSven Eckelmann * batadv_bla_free() - free all bla structures
179904e14be6SSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
180004e14be6SSimon Wunderlich *
180104e14be6SSimon Wunderlich * for softinterface free or module unload
180204e14be6SSimon Wunderlich */
batadv_bla_free(struct batadv_priv * bat_priv)180356303d34SSven Eckelmann void batadv_bla_free(struct batadv_priv *bat_priv)
180423721387SSimon Wunderlich {
180556303d34SSven Eckelmann struct batadv_hard_iface *primary_if;
180623721387SSimon Wunderlich
1807807736f6SSven Eckelmann cancel_delayed_work_sync(&bat_priv->bla.work);
1808e5d89254SSven Eckelmann primary_if = batadv_primary_if_get_selected(bat_priv);
180923721387SSimon Wunderlich
1810807736f6SSven Eckelmann if (bat_priv->bla.claim_hash) {
18113b300de3SSven Eckelmann batadv_bla_purge_claims(bat_priv, primary_if, 1);
1812807736f6SSven Eckelmann batadv_hash_destroy(bat_priv->bla.claim_hash);
1813807736f6SSven Eckelmann bat_priv->bla.claim_hash = NULL;
181423721387SSimon Wunderlich }
1815807736f6SSven Eckelmann if (bat_priv->bla.backbone_hash) {
18163b300de3SSven Eckelmann batadv_bla_purge_backbone_gw(bat_priv, 1);
1817807736f6SSven Eckelmann batadv_hash_destroy(bat_priv->bla.backbone_hash);
1818807736f6SSven Eckelmann bat_priv->bla.backbone_hash = NULL;
181923721387SSimon Wunderlich }
182082047ad7SSven Eckelmann batadv_hardif_put(primary_if);
182123721387SSimon Wunderlich }
182223721387SSimon Wunderlich
18232c53040fSBen Hutchings /**
18247e9a8c2cSSven Eckelmann * batadv_bla_loopdetect_check() - check and handle a detected loop
1825cd9c7bfbSSimon Wunderlich * @bat_priv: the bat priv with all the soft interface information
1826cd9c7bfbSSimon Wunderlich * @skb: the packet to check
1827cd9c7bfbSSimon Wunderlich * @primary_if: interface where the request came on
1828cd9c7bfbSSimon Wunderlich * @vid: the VLAN ID of the frame
1829cd9c7bfbSSimon Wunderlich *
1830cd9c7bfbSSimon Wunderlich * Checks if this packet is a loop detect frame which has been sent by us,
1831bccb48c8SSven Eckelmann * throws an uevent and logs the event if that is the case.
1832cd9c7bfbSSimon Wunderlich *
1833cd9c7bfbSSimon Wunderlich * Return: true if it is a loop detect frame which is to be dropped, false
1834cd9c7bfbSSimon Wunderlich * otherwise.
1835cd9c7bfbSSimon Wunderlich */
1836cd9c7bfbSSimon Wunderlich static bool
batadv_bla_loopdetect_check(struct batadv_priv * bat_priv,struct sk_buff * skb,struct batadv_hard_iface * primary_if,unsigned short vid)1837cd9c7bfbSSimon Wunderlich batadv_bla_loopdetect_check(struct batadv_priv *bat_priv, struct sk_buff *skb,
1838cd9c7bfbSSimon Wunderlich struct batadv_hard_iface *primary_if,
1839cd9c7bfbSSimon Wunderlich unsigned short vid)
1840cd9c7bfbSSimon Wunderlich {
1841cd9c7bfbSSimon Wunderlich struct batadv_bla_backbone_gw *backbone_gw;
1842cd9c7bfbSSimon Wunderlich struct ethhdr *ethhdr;
18435af96b9cSMarek Lindner bool ret;
1844cd9c7bfbSSimon Wunderlich
1845cd9c7bfbSSimon Wunderlich ethhdr = eth_hdr(skb);
1846cd9c7bfbSSimon Wunderlich
1847cd9c7bfbSSimon Wunderlich /* Only check for the MAC address and skip more checks here for
1848cd9c7bfbSSimon Wunderlich * performance reasons - this function is on the hotpath, after all.
1849cd9c7bfbSSimon Wunderlich */
1850cd9c7bfbSSimon Wunderlich if (!batadv_compare_eth(ethhdr->h_source,
1851cd9c7bfbSSimon Wunderlich bat_priv->bla.loopdetect_addr))
1852cd9c7bfbSSimon Wunderlich return false;
1853cd9c7bfbSSimon Wunderlich
1854cd9c7bfbSSimon Wunderlich /* If the packet came too late, don't forward it on the mesh
1855cd9c7bfbSSimon Wunderlich * but don't consider that as loop. It might be a coincidence.
1856cd9c7bfbSSimon Wunderlich */
1857cd9c7bfbSSimon Wunderlich if (batadv_has_timed_out(bat_priv->bla.loopdetect_lasttime,
1858cd9c7bfbSSimon Wunderlich BATADV_BLA_LOOPDETECT_TIMEOUT))
1859cd9c7bfbSSimon Wunderlich return true;
1860cd9c7bfbSSimon Wunderlich
1861cd9c7bfbSSimon Wunderlich backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
1862cd9c7bfbSSimon Wunderlich primary_if->net_dev->dev_addr,
1863cd9c7bfbSSimon Wunderlich vid, true);
1864cd9c7bfbSSimon Wunderlich if (unlikely(!backbone_gw))
1865cd9c7bfbSSimon Wunderlich return true;
1866cd9c7bfbSSimon Wunderlich
18675af96b9cSMarek Lindner ret = queue_work(batadv_event_workqueue, &backbone_gw->report_work);
18685af96b9cSMarek Lindner
186921ba5ab2SSven Eckelmann /* backbone_gw is unreferenced in the report work function
18705af96b9cSMarek Lindner * if queue_work() call was successful
18715af96b9cSMarek Lindner */
18725af96b9cSMarek Lindner if (!ret)
18735af96b9cSMarek Lindner batadv_backbone_gw_put(backbone_gw);
1874cd9c7bfbSSimon Wunderlich
1875cd9c7bfbSSimon Wunderlich return true;
1876cd9c7bfbSSimon Wunderlich }
1877cd9c7bfbSSimon Wunderlich
1878cd9c7bfbSSimon Wunderlich /**
18797e9a8c2cSSven Eckelmann * batadv_bla_rx() - check packets coming from the mesh.
18802c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
188123721387SSimon Wunderlich * @skb: the frame to be checked
188223721387SSimon Wunderlich * @vid: the VLAN ID of the frame
188374c09b72SLinus Lüssing * @packet_type: the batman packet type this frame came in
188423721387SSimon Wunderlich *
188504e14be6SSimon Wunderlich * batadv_bla_rx avoidance checks if:
188623721387SSimon Wunderlich * * we have to race for a claim
188723721387SSimon Wunderlich * * if the frame is allowed on the LAN
188823721387SSimon Wunderlich *
1889bccb48c8SSven Eckelmann * In these cases, the skb is further handled by this function
189062fe710fSSven Eckelmann *
18914b426b10SSven Eckelmann * Return: true if handled, otherwise it returns false and the caller shall
18924b426b10SSven Eckelmann * further process the skb.
189323721387SSimon Wunderlich */
batadv_bla_rx(struct batadv_priv * bat_priv,struct sk_buff * skb,unsigned short vid,int packet_type)18944b426b10SSven Eckelmann bool batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
189574c09b72SLinus Lüssing unsigned short vid, int packet_type)
189623721387SSimon Wunderlich {
18973db0decfSSven Eckelmann struct batadv_bla_backbone_gw *backbone_gw;
189823721387SSimon Wunderlich struct ethhdr *ethhdr;
1899712bbfe4SMarek Lindner struct batadv_bla_claim search_claim, *claim = NULL;
190056303d34SSven Eckelmann struct batadv_hard_iface *primary_if;
19013db0decfSSven Eckelmann bool own_claim;
19024b426b10SSven Eckelmann bool ret;
190323721387SSimon Wunderlich
19047ed4be95SAntonio Quartulli ethhdr = eth_hdr(skb);
190523721387SSimon Wunderlich
1906e5d89254SSven Eckelmann primary_if = batadv_primary_if_get_selected(bat_priv);
190723721387SSimon Wunderlich if (!primary_if)
190823721387SSimon Wunderlich goto handled;
190923721387SSimon Wunderlich
191023721387SSimon Wunderlich if (!atomic_read(&bat_priv->bridge_loop_avoidance))
191123721387SSimon Wunderlich goto allow;
191223721387SSimon Wunderlich
1913cd9c7bfbSSimon Wunderlich if (batadv_bla_loopdetect_check(bat_priv, skb, primary_if, vid))
1914cd9c7bfbSSimon Wunderlich goto handled;
1915cd9c7bfbSSimon Wunderlich
1916807736f6SSven Eckelmann if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
191774c09b72SLinus Lüssing /* don't allow multicast packets while requests are in flight */
191874c09b72SLinus Lüssing if (is_multicast_ether_addr(ethhdr->h_dest))
191974c09b72SLinus Lüssing /* Both broadcast flooding or multicast-via-unicasts
192074c09b72SLinus Lüssing * delivery might send to multiple backbone gateways
192174c09b72SLinus Lüssing * sharing the same LAN and therefore need to coordinate
192274c09b72SLinus Lüssing * which backbone gateway forwards into the LAN,
192374c09b72SLinus Lüssing * by claiming the payload source address.
192474c09b72SLinus Lüssing *
192574c09b72SLinus Lüssing * Broadcast flooding and multicast-via-unicasts
192674c09b72SLinus Lüssing * delivery use the following two batman packet types.
192774c09b72SLinus Lüssing * Note: explicitly exclude BATADV_UNICAST_4ADDR,
192874c09b72SLinus Lüssing * as the DHCP gateway feature will send explicitly
192974c09b72SLinus Lüssing * to only one BLA gateway, so the claiming process
193074c09b72SLinus Lüssing * should be avoided there.
193174c09b72SLinus Lüssing */
193274c09b72SLinus Lüssing if (packet_type == BATADV_BCAST ||
193374c09b72SLinus Lüssing packet_type == BATADV_UNICAST)
193423721387SSimon Wunderlich goto handled;
193523721387SSimon Wunderlich
19362369e827SLinus Lüssing /* potential duplicates from foreign BLA backbone gateways via
19372369e827SLinus Lüssing * multicast-in-unicast packets
19382369e827SLinus Lüssing */
19392369e827SLinus Lüssing if (is_multicast_ether_addr(ethhdr->h_dest) &&
19402369e827SLinus Lüssing packet_type == BATADV_UNICAST &&
19412369e827SLinus Lüssing batadv_bla_check_ucast_duplist(bat_priv, skb))
194223721387SSimon Wunderlich goto handled;
194323721387SSimon Wunderlich
19448fdd0153SAntonio Quartulli ether_addr_copy(search_claim.addr, ethhdr->h_source);
194523721387SSimon Wunderlich search_claim.vid = vid;
19463b300de3SSven Eckelmann claim = batadv_claim_hash_find(bat_priv, &search_claim);
194723721387SSimon Wunderlich
194823721387SSimon Wunderlich if (!claim) {
194923721387SSimon Wunderlich /* possible optimization: race for a claim */
195023721387SSimon Wunderlich /* No claim exists yet, claim it for us!
195123721387SSimon Wunderlich */
19524dd72f73SAndreas Pape
19534dd72f73SAndreas Pape batadv_dbg(BATADV_DBG_BLA, bat_priv,
195422f0502eSSven Eckelmann "%s(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
195522f0502eSSven Eckelmann __func__, ethhdr->h_source,
19564dd72f73SAndreas Pape batadv_is_my_client(bat_priv,
19574dd72f73SAndreas Pape ethhdr->h_source, vid) ?
19584dd72f73SAndreas Pape "yes" : "no");
19593b300de3SSven Eckelmann batadv_handle_claim(bat_priv, primary_if,
196023721387SSimon Wunderlich primary_if->net_dev->dev_addr,
196123721387SSimon Wunderlich ethhdr->h_source, vid);
196223721387SSimon Wunderlich goto allow;
196323721387SSimon Wunderlich }
196423721387SSimon Wunderlich
196523721387SSimon Wunderlich /* if it is our own claim ... */
19663db0decfSSven Eckelmann backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
19673db0decfSSven Eckelmann own_claim = batadv_compare_eth(backbone_gw->orig,
19683db0decfSSven Eckelmann primary_if->net_dev->dev_addr);
19693db0decfSSven Eckelmann batadv_backbone_gw_put(backbone_gw);
19703db0decfSSven Eckelmann
19713db0decfSSven Eckelmann if (own_claim) {
197223721387SSimon Wunderlich /* ... allow it in any case */
197323721387SSimon Wunderlich claim->lasttime = jiffies;
197423721387SSimon Wunderlich goto allow;
197523721387SSimon Wunderlich }
197623721387SSimon Wunderlich
197774c09b72SLinus Lüssing /* if it is a multicast ... */
197874c09b72SLinus Lüssing if (is_multicast_ether_addr(ethhdr->h_dest) &&
197974c09b72SLinus Lüssing (packet_type == BATADV_BCAST || packet_type == BATADV_UNICAST)) {
19802d3f6cccSSimon Wunderlich /* ... drop it. the responsible gateway is in charge.
19812d3f6cccSSimon Wunderlich *
198274c09b72SLinus Lüssing * We need to check packet type because with the gateway
19832d3f6cccSSimon Wunderlich * feature, broadcasts (like DHCP requests) may be sent
198474c09b72SLinus Lüssing * using a unicast 4 address packet type. See comment above.
19852d3f6cccSSimon Wunderlich */
198623721387SSimon Wunderlich goto handled;
198723721387SSimon Wunderlich } else {
198823721387SSimon Wunderlich /* seems the client considers us as its best gateway.
198923721387SSimon Wunderlich * send a claim and update the claim table
199023721387SSimon Wunderlich * immediately.
199123721387SSimon Wunderlich */
19923b300de3SSven Eckelmann batadv_handle_claim(bat_priv, primary_if,
199323721387SSimon Wunderlich primary_if->net_dev->dev_addr,
199423721387SSimon Wunderlich ethhdr->h_source, vid);
199523721387SSimon Wunderlich goto allow;
199623721387SSimon Wunderlich }
199723721387SSimon Wunderlich allow:
19983b300de3SSven Eckelmann batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
19994b426b10SSven Eckelmann ret = false;
200023721387SSimon Wunderlich goto out;
200123721387SSimon Wunderlich
200223721387SSimon Wunderlich handled:
200323721387SSimon Wunderlich kfree_skb(skb);
20044b426b10SSven Eckelmann ret = true;
200523721387SSimon Wunderlich
200623721387SSimon Wunderlich out:
200782047ad7SSven Eckelmann batadv_hardif_put(primary_if);
2008321e3e08SSven Eckelmann batadv_claim_put(claim);
200923721387SSimon Wunderlich return ret;
201023721387SSimon Wunderlich }
201123721387SSimon Wunderlich
20122c53040fSBen Hutchings /**
20137e9a8c2cSSven Eckelmann * batadv_bla_tx() - check packets going into the mesh
20142c53040fSBen Hutchings * @bat_priv: the bat priv with all the soft interface information
201523721387SSimon Wunderlich * @skb: the frame to be checked
201623721387SSimon Wunderlich * @vid: the VLAN ID of the frame
201723721387SSimon Wunderlich *
201804e14be6SSimon Wunderlich * batadv_bla_tx checks if:
201923721387SSimon Wunderlich * * a claim was received which has to be processed
202023721387SSimon Wunderlich * * the frame is allowed on the mesh
202123721387SSimon Wunderlich *
202262fe710fSSven Eckelmann * in these cases, the skb is further handled by this function.
20239d2c9488SLinus Lüssing *
20249d2c9488SLinus Lüssing * This call might reallocate skb data.
202562fe710fSSven Eckelmann *
20264b426b10SSven Eckelmann * Return: true if handled, otherwise it returns false and the caller shall
20274b426b10SSven Eckelmann * further process the skb.
202823721387SSimon Wunderlich */
batadv_bla_tx(struct batadv_priv * bat_priv,struct sk_buff * skb,unsigned short vid)20294b426b10SSven Eckelmann bool batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
2030eb2deb6bSAntonio Quartulli unsigned short vid)
203123721387SSimon Wunderlich {
203223721387SSimon Wunderlich struct ethhdr *ethhdr;
2033712bbfe4SMarek Lindner struct batadv_bla_claim search_claim, *claim = NULL;
20343db0decfSSven Eckelmann struct batadv_bla_backbone_gw *backbone_gw;
203556303d34SSven Eckelmann struct batadv_hard_iface *primary_if;
20363db0decfSSven Eckelmann bool client_roamed;
20374b426b10SSven Eckelmann bool ret = false;
203823721387SSimon Wunderlich
2039e5d89254SSven Eckelmann primary_if = batadv_primary_if_get_selected(bat_priv);
204023721387SSimon Wunderlich if (!primary_if)
204123721387SSimon Wunderlich goto out;
204223721387SSimon Wunderlich
204323721387SSimon Wunderlich if (!atomic_read(&bat_priv->bridge_loop_avoidance))
204423721387SSimon Wunderlich goto allow;
204523721387SSimon Wunderlich
20463b300de3SSven Eckelmann if (batadv_bla_process_claim(bat_priv, primary_if, skb))
204723721387SSimon Wunderlich goto handled;
204823721387SSimon Wunderlich
20497ed4be95SAntonio Quartulli ethhdr = eth_hdr(skb);
205023721387SSimon Wunderlich
2051807736f6SSven Eckelmann if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
205223721387SSimon Wunderlich /* don't allow broadcasts while requests are in flight */
205323721387SSimon Wunderlich if (is_multicast_ether_addr(ethhdr->h_dest))
205423721387SSimon Wunderlich goto handled;
205523721387SSimon Wunderlich
20568fdd0153SAntonio Quartulli ether_addr_copy(search_claim.addr, ethhdr->h_source);
205723721387SSimon Wunderlich search_claim.vid = vid;
205823721387SSimon Wunderlich
20593b300de3SSven Eckelmann claim = batadv_claim_hash_find(bat_priv, &search_claim);
206023721387SSimon Wunderlich
206123721387SSimon Wunderlich /* if no claim exists, allow it. */
206223721387SSimon Wunderlich if (!claim)
206323721387SSimon Wunderlich goto allow;
206423721387SSimon Wunderlich
206523721387SSimon Wunderlich /* check if we are responsible. */
20663db0decfSSven Eckelmann backbone_gw = batadv_bla_claim_get_backbone_gw(claim);
20673db0decfSSven Eckelmann client_roamed = batadv_compare_eth(backbone_gw->orig,
20683db0decfSSven Eckelmann primary_if->net_dev->dev_addr);
20693db0decfSSven Eckelmann batadv_backbone_gw_put(backbone_gw);
20703db0decfSSven Eckelmann
20713db0decfSSven Eckelmann if (client_roamed) {
207223721387SSimon Wunderlich /* if yes, the client has roamed and we have
207323721387SSimon Wunderlich * to unclaim it.
207423721387SSimon Wunderlich */
2075a3a5129eSAndreas Pape if (batadv_has_timed_out(claim->lasttime, 100)) {
2076a3a5129eSAndreas Pape /* only unclaim if the last claim entry is
2077a3a5129eSAndreas Pape * older than 100 ms to make sure we really
2078a3a5129eSAndreas Pape * have a roaming client here.
2079a3a5129eSAndreas Pape */
208022f0502eSSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Roaming client %pM detected. Unclaim it.\n",
208122f0502eSSven Eckelmann __func__, ethhdr->h_source);
20823b300de3SSven Eckelmann batadv_handle_unclaim(bat_priv, primary_if,
208323721387SSimon Wunderlich primary_if->net_dev->dev_addr,
208423721387SSimon Wunderlich ethhdr->h_source, vid);
208523721387SSimon Wunderlich goto allow;
2086a3a5129eSAndreas Pape } else {
208722f0502eSSven Eckelmann batadv_dbg(BATADV_DBG_BLA, bat_priv, "%s(): Race for claim %pM detected. Drop packet.\n",
208822f0502eSSven Eckelmann __func__, ethhdr->h_source);
2089a3a5129eSAndreas Pape goto handled;
2090a3a5129eSAndreas Pape }
209123721387SSimon Wunderlich }
209223721387SSimon Wunderlich
209323721387SSimon Wunderlich /* check if it is a multicast/broadcast frame */
209423721387SSimon Wunderlich if (is_multicast_ether_addr(ethhdr->h_dest)) {
209523721387SSimon Wunderlich /* drop it. the responsible gateway has forwarded it into
209623721387SSimon Wunderlich * the backbone network.
209723721387SSimon Wunderlich */
209823721387SSimon Wunderlich goto handled;
209923721387SSimon Wunderlich } else {
210023721387SSimon Wunderlich /* we must allow it. at least if we are
210123721387SSimon Wunderlich * responsible for the DESTINATION.
210223721387SSimon Wunderlich */
210323721387SSimon Wunderlich goto allow;
210423721387SSimon Wunderlich }
210523721387SSimon Wunderlich allow:
21063b300de3SSven Eckelmann batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
21074b426b10SSven Eckelmann ret = false;
210823721387SSimon Wunderlich goto out;
210923721387SSimon Wunderlich handled:
21104b426b10SSven Eckelmann ret = true;
211123721387SSimon Wunderlich out:
211282047ad7SSven Eckelmann batadv_hardif_put(primary_if);
2113321e3e08SSven Eckelmann batadv_claim_put(claim);
211423721387SSimon Wunderlich return ret;
211523721387SSimon Wunderlich }
21169bf8e4d4SSimon Wunderlich
211704e14be6SSimon Wunderlich /**
21187e9a8c2cSSven Eckelmann * batadv_bla_claim_dump_entry() - dump one entry of the claim table
211904f3f5bfSAndrew Lunn * to a netlink socket
212004f3f5bfSAndrew Lunn * @msg: buffer for the message
212104f3f5bfSAndrew Lunn * @portid: netlink port
212224d71b92SSven Eckelmann * @cb: Control block containing additional options
212304f3f5bfSAndrew Lunn * @primary_if: primary interface
212404f3f5bfSAndrew Lunn * @claim: entry to dump
212504f3f5bfSAndrew Lunn *
212604f3f5bfSAndrew Lunn * Return: 0 or error code.
212704f3f5bfSAndrew Lunn */
212804f3f5bfSAndrew Lunn static int
batadv_bla_claim_dump_entry(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_hard_iface * primary_if,struct batadv_bla_claim * claim)212924d71b92SSven Eckelmann batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid,
213024d71b92SSven Eckelmann struct netlink_callback *cb,
213104f3f5bfSAndrew Lunn struct batadv_hard_iface *primary_if,
213204f3f5bfSAndrew Lunn struct batadv_bla_claim *claim)
213304f3f5bfSAndrew Lunn {
213447ce5f1eSJakub Kicinski const u8 *primary_addr = primary_if->net_dev->dev_addr;
213504f3f5bfSAndrew Lunn u16 backbone_crc;
213604f3f5bfSAndrew Lunn bool is_own;
213704f3f5bfSAndrew Lunn void *hdr;
213804f3f5bfSAndrew Lunn int ret = -EINVAL;
213904f3f5bfSAndrew Lunn
214024d71b92SSven Eckelmann hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
214124d71b92SSven Eckelmann &batadv_netlink_family, NLM_F_MULTI,
214224d71b92SSven Eckelmann BATADV_CMD_GET_BLA_CLAIM);
214304f3f5bfSAndrew Lunn if (!hdr) {
214404f3f5bfSAndrew Lunn ret = -ENOBUFS;
214504f3f5bfSAndrew Lunn goto out;
214604f3f5bfSAndrew Lunn }
214704f3f5bfSAndrew Lunn
214824d71b92SSven Eckelmann genl_dump_check_consistent(cb, hdr);
214924d71b92SSven Eckelmann
215004f3f5bfSAndrew Lunn is_own = batadv_compare_eth(claim->backbone_gw->orig,
215104f3f5bfSAndrew Lunn primary_addr);
215204f3f5bfSAndrew Lunn
215304f3f5bfSAndrew Lunn spin_lock_bh(&claim->backbone_gw->crc_lock);
215404f3f5bfSAndrew Lunn backbone_crc = claim->backbone_gw->crc;
215504f3f5bfSAndrew Lunn spin_unlock_bh(&claim->backbone_gw->crc_lock);
215604f3f5bfSAndrew Lunn
215704f3f5bfSAndrew Lunn if (is_own)
215804f3f5bfSAndrew Lunn if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
215904f3f5bfSAndrew Lunn genlmsg_cancel(msg, hdr);
216004f3f5bfSAndrew Lunn goto out;
216104f3f5bfSAndrew Lunn }
216204f3f5bfSAndrew Lunn
216304f3f5bfSAndrew Lunn if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
216404f3f5bfSAndrew Lunn nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
216504f3f5bfSAndrew Lunn nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
216604f3f5bfSAndrew Lunn claim->backbone_gw->orig) ||
216704f3f5bfSAndrew Lunn nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
216804f3f5bfSAndrew Lunn backbone_crc)) {
216904f3f5bfSAndrew Lunn genlmsg_cancel(msg, hdr);
217004f3f5bfSAndrew Lunn goto out;
217104f3f5bfSAndrew Lunn }
217204f3f5bfSAndrew Lunn
217304f3f5bfSAndrew Lunn genlmsg_end(msg, hdr);
217404f3f5bfSAndrew Lunn ret = 0;
217504f3f5bfSAndrew Lunn
217604f3f5bfSAndrew Lunn out:
217704f3f5bfSAndrew Lunn return ret;
217804f3f5bfSAndrew Lunn }
217904f3f5bfSAndrew Lunn
218004f3f5bfSAndrew Lunn /**
21817e9a8c2cSSven Eckelmann * batadv_bla_claim_dump_bucket() - dump one bucket of the claim table
218204f3f5bfSAndrew Lunn * to a netlink socket
218304f3f5bfSAndrew Lunn * @msg: buffer for the message
218404f3f5bfSAndrew Lunn * @portid: netlink port
218524d71b92SSven Eckelmann * @cb: Control block containing additional options
218604f3f5bfSAndrew Lunn * @primary_if: primary interface
218724d71b92SSven Eckelmann * @hash: hash to dump
218824d71b92SSven Eckelmann * @bucket: bucket index to dump
218904f3f5bfSAndrew Lunn * @idx_skip: How many entries to skip
219004f3f5bfSAndrew Lunn *
219104f3f5bfSAndrew Lunn * Return: always 0.
219204f3f5bfSAndrew Lunn */
219304f3f5bfSAndrew Lunn static int
batadv_bla_claim_dump_bucket(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_hard_iface * primary_if,struct batadv_hashtable * hash,unsigned int bucket,int * idx_skip)219424d71b92SSven Eckelmann batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid,
219524d71b92SSven Eckelmann struct netlink_callback *cb,
219604f3f5bfSAndrew Lunn struct batadv_hard_iface *primary_if,
219724d71b92SSven Eckelmann struct batadv_hashtable *hash, unsigned int bucket,
219824d71b92SSven Eckelmann int *idx_skip)
219904f3f5bfSAndrew Lunn {
220004f3f5bfSAndrew Lunn struct batadv_bla_claim *claim;
220104f3f5bfSAndrew Lunn int idx = 0;
2202b0264ecdSSven Eckelmann int ret = 0;
220304f3f5bfSAndrew Lunn
220424d71b92SSven Eckelmann spin_lock_bh(&hash->list_locks[bucket]);
220524d71b92SSven Eckelmann cb->seq = atomic_read(&hash->generation) << 1 | 1;
220624d71b92SSven Eckelmann
220724d71b92SSven Eckelmann hlist_for_each_entry(claim, &hash->table[bucket], hash_entry) {
220804f3f5bfSAndrew Lunn if (idx++ < *idx_skip)
220904f3f5bfSAndrew Lunn continue;
2210b0264ecdSSven Eckelmann
221124d71b92SSven Eckelmann ret = batadv_bla_claim_dump_entry(msg, portid, cb,
2212b0264ecdSSven Eckelmann primary_if, claim);
2213b0264ecdSSven Eckelmann if (ret) {
221404f3f5bfSAndrew Lunn *idx_skip = idx - 1;
221504f3f5bfSAndrew Lunn goto unlock;
221604f3f5bfSAndrew Lunn }
221704f3f5bfSAndrew Lunn }
221804f3f5bfSAndrew Lunn
2219b0264ecdSSven Eckelmann *idx_skip = 0;
222004f3f5bfSAndrew Lunn unlock:
222124d71b92SSven Eckelmann spin_unlock_bh(&hash->list_locks[bucket]);
2222b0264ecdSSven Eckelmann return ret;
222304f3f5bfSAndrew Lunn }
222404f3f5bfSAndrew Lunn
222504f3f5bfSAndrew Lunn /**
22267e9a8c2cSSven Eckelmann * batadv_bla_claim_dump() - dump claim table to a netlink socket
222704f3f5bfSAndrew Lunn * @msg: buffer for the message
222804f3f5bfSAndrew Lunn * @cb: callback structure containing arguments
222904f3f5bfSAndrew Lunn *
223004f3f5bfSAndrew Lunn * Return: message length.
223104f3f5bfSAndrew Lunn */
batadv_bla_claim_dump(struct sk_buff * msg,struct netlink_callback * cb)223204f3f5bfSAndrew Lunn int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
223304f3f5bfSAndrew Lunn {
223404f3f5bfSAndrew Lunn struct batadv_hard_iface *primary_if = NULL;
223504f3f5bfSAndrew Lunn int portid = NETLINK_CB(cb->skb).portid;
223604f3f5bfSAndrew Lunn struct net *net = sock_net(cb->skb->sk);
223704f3f5bfSAndrew Lunn struct net_device *soft_iface;
223804f3f5bfSAndrew Lunn struct batadv_hashtable *hash;
223904f3f5bfSAndrew Lunn struct batadv_priv *bat_priv;
224004f3f5bfSAndrew Lunn int bucket = cb->args[0];
224104f3f5bfSAndrew Lunn int idx = cb->args[1];
224204f3f5bfSAndrew Lunn int ifindex;
224304f3f5bfSAndrew Lunn int ret = 0;
224404f3f5bfSAndrew Lunn
224504f3f5bfSAndrew Lunn ifindex = batadv_netlink_get_ifindex(cb->nlh,
224604f3f5bfSAndrew Lunn BATADV_ATTR_MESH_IFINDEX);
224704f3f5bfSAndrew Lunn if (!ifindex)
224804f3f5bfSAndrew Lunn return -EINVAL;
224904f3f5bfSAndrew Lunn
225004f3f5bfSAndrew Lunn soft_iface = dev_get_by_index(net, ifindex);
225104f3f5bfSAndrew Lunn if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
225204f3f5bfSAndrew Lunn ret = -ENODEV;
225304f3f5bfSAndrew Lunn goto out;
225404f3f5bfSAndrew Lunn }
225504f3f5bfSAndrew Lunn
225604f3f5bfSAndrew Lunn bat_priv = netdev_priv(soft_iface);
225704f3f5bfSAndrew Lunn hash = bat_priv->bla.claim_hash;
225804f3f5bfSAndrew Lunn
225904f3f5bfSAndrew Lunn primary_if = batadv_primary_if_get_selected(bat_priv);
226004f3f5bfSAndrew Lunn if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
226104f3f5bfSAndrew Lunn ret = -ENOENT;
226204f3f5bfSAndrew Lunn goto out;
226304f3f5bfSAndrew Lunn }
226404f3f5bfSAndrew Lunn
226504f3f5bfSAndrew Lunn while (bucket < hash->size) {
226624d71b92SSven Eckelmann if (batadv_bla_claim_dump_bucket(msg, portid, cb, primary_if,
226724d71b92SSven Eckelmann hash, bucket, &idx))
226804f3f5bfSAndrew Lunn break;
226904f3f5bfSAndrew Lunn bucket++;
227004f3f5bfSAndrew Lunn }
227104f3f5bfSAndrew Lunn
227204f3f5bfSAndrew Lunn cb->args[0] = bucket;
227304f3f5bfSAndrew Lunn cb->args[1] = idx;
227404f3f5bfSAndrew Lunn
227504f3f5bfSAndrew Lunn ret = msg->len;
227604f3f5bfSAndrew Lunn
227704f3f5bfSAndrew Lunn out:
227804f3f5bfSAndrew Lunn batadv_hardif_put(primary_if);
227904f3f5bfSAndrew Lunn
228004f3f5bfSAndrew Lunn dev_put(soft_iface);
228104f3f5bfSAndrew Lunn
228204f3f5bfSAndrew Lunn return ret;
228304f3f5bfSAndrew Lunn }
228404f3f5bfSAndrew Lunn
2285ea4152e1SSimon Wunderlich /**
22867e9a8c2cSSven Eckelmann * batadv_bla_backbone_dump_entry() - dump one entry of the backbone table to a
22877e9a8c2cSSven Eckelmann * netlink socket
2288ea4152e1SSimon Wunderlich * @msg: buffer for the message
2289ea4152e1SSimon Wunderlich * @portid: netlink port
2290b00d0e6aSSven Eckelmann * @cb: Control block containing additional options
2291ea4152e1SSimon Wunderlich * @primary_if: primary interface
2292ea4152e1SSimon Wunderlich * @backbone_gw: entry to dump
2293ea4152e1SSimon Wunderlich *
2294ea4152e1SSimon Wunderlich * Return: 0 or error code.
2295ea4152e1SSimon Wunderlich */
2296ea4152e1SSimon Wunderlich static int
batadv_bla_backbone_dump_entry(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_hard_iface * primary_if,struct batadv_bla_backbone_gw * backbone_gw)2297b00d0e6aSSven Eckelmann batadv_bla_backbone_dump_entry(struct sk_buff *msg, u32 portid,
2298b00d0e6aSSven Eckelmann struct netlink_callback *cb,
2299ea4152e1SSimon Wunderlich struct batadv_hard_iface *primary_if,
2300ea4152e1SSimon Wunderlich struct batadv_bla_backbone_gw *backbone_gw)
2301ea4152e1SSimon Wunderlich {
230247ce5f1eSJakub Kicinski const u8 *primary_addr = primary_if->net_dev->dev_addr;
2303ea4152e1SSimon Wunderlich u16 backbone_crc;
2304ea4152e1SSimon Wunderlich bool is_own;
2305ea4152e1SSimon Wunderlich int msecs;
2306ea4152e1SSimon Wunderlich void *hdr;
2307ea4152e1SSimon Wunderlich int ret = -EINVAL;
2308ea4152e1SSimon Wunderlich
2309b00d0e6aSSven Eckelmann hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2310b00d0e6aSSven Eckelmann &batadv_netlink_family, NLM_F_MULTI,
2311b00d0e6aSSven Eckelmann BATADV_CMD_GET_BLA_BACKBONE);
2312ea4152e1SSimon Wunderlich if (!hdr) {
2313ea4152e1SSimon Wunderlich ret = -ENOBUFS;
2314ea4152e1SSimon Wunderlich goto out;
2315ea4152e1SSimon Wunderlich }
2316ea4152e1SSimon Wunderlich
2317b00d0e6aSSven Eckelmann genl_dump_check_consistent(cb, hdr);
2318b00d0e6aSSven Eckelmann
2319ea4152e1SSimon Wunderlich is_own = batadv_compare_eth(backbone_gw->orig, primary_addr);
2320ea4152e1SSimon Wunderlich
2321ea4152e1SSimon Wunderlich spin_lock_bh(&backbone_gw->crc_lock);
2322ea4152e1SSimon Wunderlich backbone_crc = backbone_gw->crc;
2323ea4152e1SSimon Wunderlich spin_unlock_bh(&backbone_gw->crc_lock);
2324ea4152e1SSimon Wunderlich
2325ea4152e1SSimon Wunderlich msecs = jiffies_to_msecs(jiffies - backbone_gw->lasttime);
2326ea4152e1SSimon Wunderlich
2327ea4152e1SSimon Wunderlich if (is_own)
2328ea4152e1SSimon Wunderlich if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
2329ea4152e1SSimon Wunderlich genlmsg_cancel(msg, hdr);
2330ea4152e1SSimon Wunderlich goto out;
2331ea4152e1SSimon Wunderlich }
2332ea4152e1SSimon Wunderlich
2333ea4152e1SSimon Wunderlich if (nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
2334ea4152e1SSimon Wunderlich backbone_gw->orig) ||
2335ea4152e1SSimon Wunderlich nla_put_u16(msg, BATADV_ATTR_BLA_VID, backbone_gw->vid) ||
2336ea4152e1SSimon Wunderlich nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
2337ea4152e1SSimon Wunderlich backbone_crc) ||
2338ea4152e1SSimon Wunderlich nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) {
2339ea4152e1SSimon Wunderlich genlmsg_cancel(msg, hdr);
2340ea4152e1SSimon Wunderlich goto out;
2341ea4152e1SSimon Wunderlich }
2342ea4152e1SSimon Wunderlich
2343ea4152e1SSimon Wunderlich genlmsg_end(msg, hdr);
2344ea4152e1SSimon Wunderlich ret = 0;
2345ea4152e1SSimon Wunderlich
2346ea4152e1SSimon Wunderlich out:
2347ea4152e1SSimon Wunderlich return ret;
2348ea4152e1SSimon Wunderlich }
2349ea4152e1SSimon Wunderlich
2350ea4152e1SSimon Wunderlich /**
23517e9a8c2cSSven Eckelmann * batadv_bla_backbone_dump_bucket() - dump one bucket of the backbone table to
23527e9a8c2cSSven Eckelmann * a netlink socket
2353ea4152e1SSimon Wunderlich * @msg: buffer for the message
2354ea4152e1SSimon Wunderlich * @portid: netlink port
2355b00d0e6aSSven Eckelmann * @cb: Control block containing additional options
2356ea4152e1SSimon Wunderlich * @primary_if: primary interface
2357b00d0e6aSSven Eckelmann * @hash: hash to dump
2358b00d0e6aSSven Eckelmann * @bucket: bucket index to dump
2359ea4152e1SSimon Wunderlich * @idx_skip: How many entries to skip
2360ea4152e1SSimon Wunderlich *
2361ea4152e1SSimon Wunderlich * Return: always 0.
2362ea4152e1SSimon Wunderlich */
2363ea4152e1SSimon Wunderlich static int
batadv_bla_backbone_dump_bucket(struct sk_buff * msg,u32 portid,struct netlink_callback * cb,struct batadv_hard_iface * primary_if,struct batadv_hashtable * hash,unsigned int bucket,int * idx_skip)2364b00d0e6aSSven Eckelmann batadv_bla_backbone_dump_bucket(struct sk_buff *msg, u32 portid,
2365b00d0e6aSSven Eckelmann struct netlink_callback *cb,
2366ea4152e1SSimon Wunderlich struct batadv_hard_iface *primary_if,
2367b00d0e6aSSven Eckelmann struct batadv_hashtable *hash,
2368b00d0e6aSSven Eckelmann unsigned int bucket, int *idx_skip)
2369ea4152e1SSimon Wunderlich {
2370ea4152e1SSimon Wunderlich struct batadv_bla_backbone_gw *backbone_gw;
2371ea4152e1SSimon Wunderlich int idx = 0;
2372fce672dbSSven Eckelmann int ret = 0;
2373ea4152e1SSimon Wunderlich
2374b00d0e6aSSven Eckelmann spin_lock_bh(&hash->list_locks[bucket]);
2375b00d0e6aSSven Eckelmann cb->seq = atomic_read(&hash->generation) << 1 | 1;
2376b00d0e6aSSven Eckelmann
2377b00d0e6aSSven Eckelmann hlist_for_each_entry(backbone_gw, &hash->table[bucket], hash_entry) {
2378ea4152e1SSimon Wunderlich if (idx++ < *idx_skip)
2379ea4152e1SSimon Wunderlich continue;
2380fce672dbSSven Eckelmann
2381b00d0e6aSSven Eckelmann ret = batadv_bla_backbone_dump_entry(msg, portid, cb,
2382fce672dbSSven Eckelmann primary_if, backbone_gw);
2383fce672dbSSven Eckelmann if (ret) {
2384ea4152e1SSimon Wunderlich *idx_skip = idx - 1;
2385ea4152e1SSimon Wunderlich goto unlock;
2386ea4152e1SSimon Wunderlich }
2387ea4152e1SSimon Wunderlich }
2388ea4152e1SSimon Wunderlich
2389fce672dbSSven Eckelmann *idx_skip = 0;
2390ea4152e1SSimon Wunderlich unlock:
2391b00d0e6aSSven Eckelmann spin_unlock_bh(&hash->list_locks[bucket]);
2392fce672dbSSven Eckelmann return ret;
2393ea4152e1SSimon Wunderlich }
2394ea4152e1SSimon Wunderlich
2395ea4152e1SSimon Wunderlich /**
23967e9a8c2cSSven Eckelmann * batadv_bla_backbone_dump() - dump backbone table to a netlink socket
2397ea4152e1SSimon Wunderlich * @msg: buffer for the message
2398ea4152e1SSimon Wunderlich * @cb: callback structure containing arguments
2399ea4152e1SSimon Wunderlich *
2400ea4152e1SSimon Wunderlich * Return: message length.
2401ea4152e1SSimon Wunderlich */
batadv_bla_backbone_dump(struct sk_buff * msg,struct netlink_callback * cb)2402ea4152e1SSimon Wunderlich int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb)
2403ea4152e1SSimon Wunderlich {
2404ea4152e1SSimon Wunderlich struct batadv_hard_iface *primary_if = NULL;
2405ea4152e1SSimon Wunderlich int portid = NETLINK_CB(cb->skb).portid;
2406ea4152e1SSimon Wunderlich struct net *net = sock_net(cb->skb->sk);
2407ea4152e1SSimon Wunderlich struct net_device *soft_iface;
2408ea4152e1SSimon Wunderlich struct batadv_hashtable *hash;
2409ea4152e1SSimon Wunderlich struct batadv_priv *bat_priv;
2410ea4152e1SSimon Wunderlich int bucket = cb->args[0];
2411ea4152e1SSimon Wunderlich int idx = cb->args[1];
2412ea4152e1SSimon Wunderlich int ifindex;
2413ea4152e1SSimon Wunderlich int ret = 0;
2414ea4152e1SSimon Wunderlich
2415ea4152e1SSimon Wunderlich ifindex = batadv_netlink_get_ifindex(cb->nlh,
2416ea4152e1SSimon Wunderlich BATADV_ATTR_MESH_IFINDEX);
2417ea4152e1SSimon Wunderlich if (!ifindex)
2418ea4152e1SSimon Wunderlich return -EINVAL;
2419ea4152e1SSimon Wunderlich
2420ea4152e1SSimon Wunderlich soft_iface = dev_get_by_index(net, ifindex);
2421ea4152e1SSimon Wunderlich if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
2422ea4152e1SSimon Wunderlich ret = -ENODEV;
2423ea4152e1SSimon Wunderlich goto out;
2424ea4152e1SSimon Wunderlich }
2425ea4152e1SSimon Wunderlich
2426ea4152e1SSimon Wunderlich bat_priv = netdev_priv(soft_iface);
2427ea4152e1SSimon Wunderlich hash = bat_priv->bla.backbone_hash;
2428ea4152e1SSimon Wunderlich
2429ea4152e1SSimon Wunderlich primary_if = batadv_primary_if_get_selected(bat_priv);
2430ea4152e1SSimon Wunderlich if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
2431ea4152e1SSimon Wunderlich ret = -ENOENT;
2432ea4152e1SSimon Wunderlich goto out;
2433ea4152e1SSimon Wunderlich }
2434ea4152e1SSimon Wunderlich
2435ea4152e1SSimon Wunderlich while (bucket < hash->size) {
2436b00d0e6aSSven Eckelmann if (batadv_bla_backbone_dump_bucket(msg, portid, cb, primary_if,
2437b00d0e6aSSven Eckelmann hash, bucket, &idx))
2438ea4152e1SSimon Wunderlich break;
2439ea4152e1SSimon Wunderlich bucket++;
2440ea4152e1SSimon Wunderlich }
2441ea4152e1SSimon Wunderlich
2442ea4152e1SSimon Wunderlich cb->args[0] = bucket;
2443ea4152e1SSimon Wunderlich cb->args[1] = idx;
2444ea4152e1SSimon Wunderlich
2445ea4152e1SSimon Wunderlich ret = msg->len;
2446ea4152e1SSimon Wunderlich
2447ea4152e1SSimon Wunderlich out:
2448ea4152e1SSimon Wunderlich batadv_hardif_put(primary_if);
2449ea4152e1SSimon Wunderlich
2450ea4152e1SSimon Wunderlich dev_put(soft_iface);
2451ea4152e1SSimon Wunderlich
2452ea4152e1SSimon Wunderlich return ret;
2453ea4152e1SSimon Wunderlich }
245400311de5SAndreas Pape
245500311de5SAndreas Pape #ifdef CONFIG_BATMAN_ADV_DAT
245600311de5SAndreas Pape /**
24577e9a8c2cSSven Eckelmann * batadv_bla_check_claim() - check if address is claimed
245800311de5SAndreas Pape *
245900311de5SAndreas Pape * @bat_priv: the bat priv with all the soft interface information
246000311de5SAndreas Pape * @addr: mac address of which the claim status is checked
246100311de5SAndreas Pape * @vid: the VLAN ID
246200311de5SAndreas Pape *
246300311de5SAndreas Pape * addr is checked if this address is claimed by the local device itself.
246400311de5SAndreas Pape *
246500311de5SAndreas Pape * Return: true if bla is disabled or the mac is claimed by the device,
246600311de5SAndreas Pape * false if the device addr is already claimed by another gateway
246700311de5SAndreas Pape */
batadv_bla_check_claim(struct batadv_priv * bat_priv,u8 * addr,unsigned short vid)246800311de5SAndreas Pape bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
246900311de5SAndreas Pape u8 *addr, unsigned short vid)
247000311de5SAndreas Pape {
247100311de5SAndreas Pape struct batadv_bla_claim search_claim;
247200311de5SAndreas Pape struct batadv_bla_claim *claim = NULL;
247300311de5SAndreas Pape struct batadv_hard_iface *primary_if = NULL;
247400311de5SAndreas Pape bool ret = true;
247500311de5SAndreas Pape
247600311de5SAndreas Pape if (!atomic_read(&bat_priv->bridge_loop_avoidance))
247700311de5SAndreas Pape return ret;
247800311de5SAndreas Pape
247900311de5SAndreas Pape primary_if = batadv_primary_if_get_selected(bat_priv);
248000311de5SAndreas Pape if (!primary_if)
248100311de5SAndreas Pape return ret;
248200311de5SAndreas Pape
248300311de5SAndreas Pape /* First look if the mac address is claimed */
248400311de5SAndreas Pape ether_addr_copy(search_claim.addr, addr);
248500311de5SAndreas Pape search_claim.vid = vid;
248600311de5SAndreas Pape
248700311de5SAndreas Pape claim = batadv_claim_hash_find(bat_priv, &search_claim);
248800311de5SAndreas Pape
248900311de5SAndreas Pape /* If there is a claim and we are not owner of the claim,
249000311de5SAndreas Pape * return false.
249100311de5SAndreas Pape */
249200311de5SAndreas Pape if (claim) {
249300311de5SAndreas Pape if (!batadv_compare_eth(claim->backbone_gw->orig,
249400311de5SAndreas Pape primary_if->net_dev->dev_addr))
249500311de5SAndreas Pape ret = false;
249600311de5SAndreas Pape batadv_claim_put(claim);
249700311de5SAndreas Pape }
249800311de5SAndreas Pape
249900311de5SAndreas Pape batadv_hardif_put(primary_if);
250000311de5SAndreas Pape return ret;
250100311de5SAndreas Pape }
250200311de5SAndreas Pape #endif
2503