1 /* Copyright (C) 2011-2012 B.A.T.M.A.N. contributors:
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 #include "hard-interface.h"
23 #include "originator.h"
24 #include "bridge_loop_avoidance.h"
25 #include "translation-table.h"
28 #include <linux/etherdevice.h>
29 #include <linux/crc16.h>
30 #include <linux/if_arp.h>
32 #include <linux/if_vlan.h>
34 static const uint8_t batadv_announce_mac
[4] = {0x43, 0x05, 0x43, 0x05};
36 static void batadv_bla_periodic_work(struct work_struct
*work
);
37 static void batadv_bla_send_announce(struct batadv_priv
*bat_priv
,
38 struct batadv_backbone_gw
*backbone_gw
);
40 /* return the index of the claim */
41 static inline uint32_t batadv_choose_claim(const void *data
, uint32_t size
)
43 struct batadv_claim
*claim
= (struct batadv_claim
*)data
;
46 hash
= batadv_hash_bytes(hash
, &claim
->addr
, sizeof(claim
->addr
));
47 hash
= batadv_hash_bytes(hash
, &claim
->vid
, sizeof(claim
->vid
));
56 /* return the index of the backbone gateway */
57 static inline uint32_t batadv_choose_backbone_gw(const void *data
,
60 struct batadv_claim
*claim
= (struct batadv_claim
*)data
;
63 hash
= batadv_hash_bytes(hash
, &claim
->addr
, sizeof(claim
->addr
));
64 hash
= batadv_hash_bytes(hash
, &claim
->vid
, sizeof(claim
->vid
));
74 /* compares address and vid of two backbone gws */
75 static int batadv_compare_backbone_gw(const struct hlist_node
*node
,
78 const void *data1
= container_of(node
, struct batadv_backbone_gw
,
81 return (memcmp(data1
, data2
, ETH_ALEN
+ sizeof(short)) == 0 ? 1 : 0);
84 /* compares address and vid of two claims */
85 static int batadv_compare_claim(const struct hlist_node
*node
,
88 const void *data1
= container_of(node
, struct batadv_claim
,
91 return (memcmp(data1
, data2
, ETH_ALEN
+ sizeof(short)) == 0 ? 1 : 0);
94 /* free a backbone gw */
95 static void batadv_backbone_gw_free_ref(struct batadv_backbone_gw
*backbone_gw
)
97 if (atomic_dec_and_test(&backbone_gw
->refcount
))
98 kfree_rcu(backbone_gw
, rcu
);
101 /* finally deinitialize the claim */
102 static void batadv_claim_free_rcu(struct rcu_head
*rcu
)
104 struct batadv_claim
*claim
;
106 claim
= container_of(rcu
, struct batadv_claim
, rcu
);
108 batadv_backbone_gw_free_ref(claim
->backbone_gw
);
112 /* free a claim, call claim_free_rcu if its the last reference */
113 static void batadv_claim_free_ref(struct batadv_claim
*claim
)
115 if (atomic_dec_and_test(&claim
->refcount
))
116 call_rcu(&claim
->rcu
, batadv_claim_free_rcu
);
119 /* @bat_priv: the bat priv with all the soft interface information
120 * @data: search data (may be local/static data)
122 * looks for a claim in the hash, and returns it if found
125 static struct batadv_claim
*batadv_claim_hash_find(struct batadv_priv
*bat_priv
,
126 struct batadv_claim
*data
)
128 struct batadv_hashtable
*hash
= bat_priv
->bla
.claim_hash
;
129 struct hlist_head
*head
;
130 struct hlist_node
*node
;
131 struct batadv_claim
*claim
;
132 struct batadv_claim
*claim_tmp
= NULL
;
138 index
= batadv_choose_claim(data
, hash
->size
);
139 head
= &hash
->table
[index
];
142 hlist_for_each_entry_rcu(claim
, node
, head
, hash_entry
) {
143 if (!batadv_compare_claim(&claim
->hash_entry
, data
))
146 if (!atomic_inc_not_zero(&claim
->refcount
))
158 * batadv_backbone_hash_find - looks for a claim in the hash
159 * @bat_priv: the bat priv with all the soft interface information
160 * @addr: the address of the originator
163 * Returns claim if found or NULL otherwise.
165 static struct batadv_backbone_gw
*
166 batadv_backbone_hash_find(struct batadv_priv
*bat_priv
,
167 uint8_t *addr
, short vid
)
169 struct batadv_hashtable
*hash
= bat_priv
->bla
.backbone_hash
;
170 struct hlist_head
*head
;
171 struct hlist_node
*node
;
172 struct batadv_backbone_gw search_entry
, *backbone_gw
;
173 struct batadv_backbone_gw
*backbone_gw_tmp
= NULL
;
179 memcpy(search_entry
.orig
, addr
, ETH_ALEN
);
180 search_entry
.vid
= vid
;
182 index
= batadv_choose_backbone_gw(&search_entry
, hash
->size
);
183 head
= &hash
->table
[index
];
186 hlist_for_each_entry_rcu(backbone_gw
, node
, head
, hash_entry
) {
187 if (!batadv_compare_backbone_gw(&backbone_gw
->hash_entry
,
191 if (!atomic_inc_not_zero(&backbone_gw
->refcount
))
194 backbone_gw_tmp
= backbone_gw
;
199 return backbone_gw_tmp
;
202 /* delete all claims for a backbone */
204 batadv_bla_del_backbone_claims(struct batadv_backbone_gw
*backbone_gw
)
206 struct batadv_hashtable
*hash
;
207 struct hlist_node
*node
, *node_tmp
;
208 struct hlist_head
*head
;
209 struct batadv_claim
*claim
;
211 spinlock_t
*list_lock
; /* protects write access to the hash lists */
213 hash
= backbone_gw
->bat_priv
->bla
.claim_hash
;
217 for (i
= 0; i
< hash
->size
; i
++) {
218 head
= &hash
->table
[i
];
219 list_lock
= &hash
->list_locks
[i
];
221 spin_lock_bh(list_lock
);
222 hlist_for_each_entry_safe(claim
, node
, node_tmp
,
225 if (claim
->backbone_gw
!= backbone_gw
)
228 batadv_claim_free_ref(claim
);
231 spin_unlock_bh(list_lock
);
234 /* all claims gone, intialize CRC */
235 backbone_gw
->crc
= BATADV_BLA_CRC_INIT
;
239 * batadv_bla_send_claim - sends a claim frame according to the provided info
240 * @bat_priv: the bat priv with all the soft interface information
241 * @orig: the mac address to be announced within the claim
243 * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
245 static void batadv_bla_send_claim(struct batadv_priv
*bat_priv
, uint8_t *mac
,
246 short vid
, int claimtype
)
249 struct ethhdr
*ethhdr
;
250 struct batadv_hard_iface
*primary_if
;
251 struct net_device
*soft_iface
;
253 struct batadv_bla_claim_dst local_claim_dest
;
256 primary_if
= batadv_primary_if_get_selected(bat_priv
);
260 memcpy(&local_claim_dest
, &bat_priv
->bla
.claim_dest
,
261 sizeof(local_claim_dest
));
262 local_claim_dest
.type
= claimtype
;
264 soft_iface
= primary_if
->soft_iface
;
266 skb
= arp_create(ARPOP_REPLY
, ETH_P_ARP
,
267 /* IP DST: 0.0.0.0 */
269 primary_if
->soft_iface
,
270 /* IP SRC: 0.0.0.0 */
272 /* Ethernet DST: Broadcast */
274 /* Ethernet SRC/HW SRC: originator mac */
275 primary_if
->net_dev
->dev_addr
,
276 /* HW DST: FF:43:05:XX:YY:YY
277 * with XX = claim type
278 * and YY:YY = group id
280 (uint8_t *)&local_claim_dest
);
285 ethhdr
= (struct ethhdr
*)skb
->data
;
286 hw_src
= (uint8_t *)ethhdr
+ ETH_HLEN
+ sizeof(struct arphdr
);
288 /* now we pretend that the client would have sent this ... */
290 case BATADV_CLAIM_TYPE_CLAIM
:
291 /* normal claim frame
292 * set Ethernet SRC to the clients mac
294 memcpy(ethhdr
->h_source
, mac
, ETH_ALEN
);
295 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
296 "bla_send_claim(): CLAIM %pM on vid %d\n", mac
, vid
);
298 case BATADV_CLAIM_TYPE_UNCLAIM
:
300 * set HW SRC to the clients mac
302 memcpy(hw_src
, mac
, ETH_ALEN
);
303 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
304 "bla_send_claim(): UNCLAIM %pM on vid %d\n", mac
,
307 case BATADV_CLAIM_TYPE_ANNOUNCE
:
308 /* announcement frame
309 * set HW SRC to the special mac containg the crc
311 memcpy(hw_src
, mac
, ETH_ALEN
);
312 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
313 "bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
314 ethhdr
->h_source
, vid
);
316 case BATADV_CLAIM_TYPE_REQUEST
:
318 * set HW SRC and header destination to the receiving backbone
321 memcpy(hw_src
, mac
, ETH_ALEN
);
322 memcpy(ethhdr
->h_dest
, mac
, ETH_ALEN
);
323 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
324 "bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",
325 ethhdr
->h_source
, ethhdr
->h_dest
, vid
);
331 skb
= vlan_insert_tag(skb
, vid
);
333 skb_reset_mac_header(skb
);
334 skb
->protocol
= eth_type_trans(skb
, soft_iface
);
335 batadv_inc_counter(bat_priv
, BATADV_CNT_RX
);
336 batadv_add_counter(bat_priv
, BATADV_CNT_RX_BYTES
,
337 skb
->len
+ ETH_HLEN
);
338 soft_iface
->last_rx
= jiffies
;
343 batadv_hardif_free_ref(primary_if
);
347 * batadv_bla_get_backbone_gw
348 * @bat_priv: the bat priv with all the soft interface information
349 * @orig: the mac address of the originator
352 * searches for the backbone gw or creates a new one if it could not
355 static struct batadv_backbone_gw
*
356 batadv_bla_get_backbone_gw(struct batadv_priv
*bat_priv
, uint8_t *orig
,
359 struct batadv_backbone_gw
*entry
;
360 struct batadv_orig_node
*orig_node
;
363 entry
= batadv_backbone_hash_find(bat_priv
, orig
, vid
);
368 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
369 "bla_get_backbone_gw(): not found (%pM, %d), creating new entry\n",
372 entry
= kzalloc(sizeof(*entry
), GFP_ATOMIC
);
377 entry
->lasttime
= jiffies
;
378 entry
->crc
= BATADV_BLA_CRC_INIT
;
379 entry
->bat_priv
= bat_priv
;
380 atomic_set(&entry
->request_sent
, 0);
381 memcpy(entry
->orig
, orig
, ETH_ALEN
);
383 /* one for the hash, one for returning */
384 atomic_set(&entry
->refcount
, 2);
386 hash_added
= batadv_hash_add(bat_priv
->bla
.backbone_hash
,
387 batadv_compare_backbone_gw
,
388 batadv_choose_backbone_gw
, entry
,
391 if (unlikely(hash_added
!= 0)) {
392 /* hash failed, free the structure */
397 /* this is a gateway now, remove any tt entries */
398 orig_node
= batadv_orig_hash_find(bat_priv
, orig
);
400 batadv_tt_global_del_orig(bat_priv
, orig_node
,
401 "became a backbone gateway");
402 batadv_orig_node_free_ref(orig_node
);
407 /* update or add the own backbone gw to make sure we announce
408 * where we receive other backbone gws
411 batadv_bla_update_own_backbone_gw(struct batadv_priv
*bat_priv
,
412 struct batadv_hard_iface
*primary_if
,
415 struct batadv_backbone_gw
*backbone_gw
;
417 backbone_gw
= batadv_bla_get_backbone_gw(bat_priv
,
418 primary_if
->net_dev
->dev_addr
,
420 if (unlikely(!backbone_gw
))
423 backbone_gw
->lasttime
= jiffies
;
424 batadv_backbone_gw_free_ref(backbone_gw
);
427 /* @bat_priv: the bat priv with all the soft interface information
428 * @vid: the vid where the request came on
430 * Repeat all of our own claims, and finally send an ANNOUNCE frame
431 * to allow the requester another check if the CRC is correct now.
433 static void batadv_bla_answer_request(struct batadv_priv
*bat_priv
,
434 struct batadv_hard_iface
*primary_if
,
437 struct hlist_node
*node
;
438 struct hlist_head
*head
;
439 struct batadv_hashtable
*hash
;
440 struct batadv_claim
*claim
;
441 struct batadv_backbone_gw
*backbone_gw
;
444 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
445 "bla_answer_request(): received a claim request, send all of our own claims again\n");
447 backbone_gw
= batadv_backbone_hash_find(bat_priv
,
448 primary_if
->net_dev
->dev_addr
,
453 hash
= bat_priv
->bla
.claim_hash
;
454 for (i
= 0; i
< hash
->size
; i
++) {
455 head
= &hash
->table
[i
];
458 hlist_for_each_entry_rcu(claim
, node
, head
, hash_entry
) {
459 /* only own claims are interesting */
460 if (claim
->backbone_gw
!= backbone_gw
)
463 batadv_bla_send_claim(bat_priv
, claim
->addr
, claim
->vid
,
464 BATADV_CLAIM_TYPE_CLAIM
);
469 /* finally, send an announcement frame */
470 batadv_bla_send_announce(bat_priv
, backbone_gw
);
471 batadv_backbone_gw_free_ref(backbone_gw
);
474 /* @backbone_gw: the backbone gateway from whom we are out of sync
476 * When the crc is wrong, ask the backbone gateway for a full table update.
477 * After the request, it will repeat all of his own claims and finally
478 * send an announcement claim with which we can check again.
480 static void batadv_bla_send_request(struct batadv_backbone_gw
*backbone_gw
)
482 /* first, remove all old entries */
483 batadv_bla_del_backbone_claims(backbone_gw
);
485 batadv_dbg(BATADV_DBG_BLA
, backbone_gw
->bat_priv
,
486 "Sending REQUEST to %pM\n", backbone_gw
->orig
);
489 batadv_bla_send_claim(backbone_gw
->bat_priv
, backbone_gw
->orig
,
490 backbone_gw
->vid
, BATADV_CLAIM_TYPE_REQUEST
);
492 /* no local broadcasts should be sent or received, for now. */
493 if (!atomic_read(&backbone_gw
->request_sent
)) {
494 atomic_inc(&backbone_gw
->bat_priv
->bla
.num_requests
);
495 atomic_set(&backbone_gw
->request_sent
, 1);
499 /* @bat_priv: the bat priv with all the soft interface information
500 * @backbone_gw: our backbone gateway which should be announced
502 * This function sends an announcement. It is called from multiple
505 static void batadv_bla_send_announce(struct batadv_priv
*bat_priv
,
506 struct batadv_backbone_gw
*backbone_gw
)
508 uint8_t mac
[ETH_ALEN
];
511 memcpy(mac
, batadv_announce_mac
, 4);
512 crc
= htons(backbone_gw
->crc
);
513 memcpy(&mac
[4], &crc
, 2);
515 batadv_bla_send_claim(bat_priv
, mac
, backbone_gw
->vid
,
516 BATADV_CLAIM_TYPE_ANNOUNCE
);
521 * batadv_bla_add_claim - Adds a claim in the claim hash
522 * @bat_priv: the bat priv with all the soft interface information
523 * @mac: the mac address of the claim
524 * @vid: the VLAN ID of the frame
525 * @backbone_gw: the backbone gateway which claims it
527 static void batadv_bla_add_claim(struct batadv_priv
*bat_priv
,
528 const uint8_t *mac
, const short vid
,
529 struct batadv_backbone_gw
*backbone_gw
)
531 struct batadv_claim
*claim
;
532 struct batadv_claim search_claim
;
535 memcpy(search_claim
.addr
, mac
, ETH_ALEN
);
536 search_claim
.vid
= vid
;
537 claim
= batadv_claim_hash_find(bat_priv
, &search_claim
);
539 /* create a new claim entry if it does not exist yet. */
541 claim
= kzalloc(sizeof(*claim
), GFP_ATOMIC
);
545 memcpy(claim
->addr
, mac
, ETH_ALEN
);
547 claim
->lasttime
= jiffies
;
548 claim
->backbone_gw
= backbone_gw
;
550 atomic_set(&claim
->refcount
, 2);
551 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
552 "bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
554 hash_added
= batadv_hash_add(bat_priv
->bla
.claim_hash
,
555 batadv_compare_claim
,
556 batadv_choose_claim
, claim
,
559 if (unlikely(hash_added
!= 0)) {
560 /* only local changes happened. */
565 claim
->lasttime
= jiffies
;
566 if (claim
->backbone_gw
== backbone_gw
)
567 /* no need to register a new backbone */
570 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
571 "bla_add_claim(): changing ownership for %pM, vid %d\n",
574 claim
->backbone_gw
->crc
^= crc16(0, claim
->addr
, ETH_ALEN
);
575 batadv_backbone_gw_free_ref(claim
->backbone_gw
);
578 /* set (new) backbone gw */
579 atomic_inc(&backbone_gw
->refcount
);
580 claim
->backbone_gw
= backbone_gw
;
582 backbone_gw
->crc
^= crc16(0, claim
->addr
, ETH_ALEN
);
583 backbone_gw
->lasttime
= jiffies
;
586 batadv_claim_free_ref(claim
);
589 /* Delete a claim from the claim hash which has the
590 * given mac address and vid.
592 static void batadv_bla_del_claim(struct batadv_priv
*bat_priv
,
593 const uint8_t *mac
, const short vid
)
595 struct batadv_claim search_claim
, *claim
;
597 memcpy(search_claim
.addr
, mac
, ETH_ALEN
);
598 search_claim
.vid
= vid
;
599 claim
= batadv_claim_hash_find(bat_priv
, &search_claim
);
603 batadv_dbg(BATADV_DBG_BLA
, bat_priv
, "bla_del_claim(): %pM, vid %d\n",
606 batadv_hash_remove(bat_priv
->bla
.claim_hash
, batadv_compare_claim
,
607 batadv_choose_claim
, claim
);
608 batadv_claim_free_ref(claim
); /* reference from the hash is gone */
610 claim
->backbone_gw
->crc
^= crc16(0, claim
->addr
, ETH_ALEN
);
612 /* don't need the reference from hash_find() anymore */
613 batadv_claim_free_ref(claim
);
616 /* check for ANNOUNCE frame, return 1 if handled */
617 static int batadv_handle_announce(struct batadv_priv
*bat_priv
,
618 uint8_t *an_addr
, uint8_t *backbone_addr
,
621 struct batadv_backbone_gw
*backbone_gw
;
624 if (memcmp(an_addr
, batadv_announce_mac
, 4) != 0)
627 backbone_gw
= batadv_bla_get_backbone_gw(bat_priv
, backbone_addr
, vid
);
629 if (unlikely(!backbone_gw
))
633 /* handle as ANNOUNCE frame */
634 backbone_gw
->lasttime
= jiffies
;
635 crc
= ntohs(*((__be16
*)(&an_addr
[4])));
637 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
638 "handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %04x\n",
639 vid
, backbone_gw
->orig
, crc
);
641 if (backbone_gw
->crc
!= crc
) {
642 batadv_dbg(BATADV_DBG_BLA
, backbone_gw
->bat_priv
,
643 "handle_announce(): CRC FAILED for %pM/%d (my = %04x, sent = %04x)\n",
644 backbone_gw
->orig
, backbone_gw
->vid
,
645 backbone_gw
->crc
, crc
);
647 batadv_bla_send_request(backbone_gw
);
649 /* if we have sent a request and the crc was OK,
650 * we can allow traffic again.
652 if (atomic_read(&backbone_gw
->request_sent
)) {
653 atomic_dec(&backbone_gw
->bat_priv
->bla
.num_requests
);
654 atomic_set(&backbone_gw
->request_sent
, 0);
658 batadv_backbone_gw_free_ref(backbone_gw
);
662 /* check for REQUEST frame, return 1 if handled */
663 static int batadv_handle_request(struct batadv_priv
*bat_priv
,
664 struct batadv_hard_iface
*primary_if
,
665 uint8_t *backbone_addr
,
666 struct ethhdr
*ethhdr
, short vid
)
668 /* check for REQUEST frame */
669 if (!batadv_compare_eth(backbone_addr
, ethhdr
->h_dest
))
672 /* sanity check, this should not happen on a normal switch,
673 * we ignore it in this case.
675 if (!batadv_compare_eth(ethhdr
->h_dest
, primary_if
->net_dev
->dev_addr
))
678 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
679 "handle_request(): REQUEST vid %d (sent by %pM)...\n",
680 vid
, ethhdr
->h_source
);
682 batadv_bla_answer_request(bat_priv
, primary_if
, vid
);
686 /* check for UNCLAIM frame, return 1 if handled */
687 static int batadv_handle_unclaim(struct batadv_priv
*bat_priv
,
688 struct batadv_hard_iface
*primary_if
,
689 uint8_t *backbone_addr
,
690 uint8_t *claim_addr
, short vid
)
692 struct batadv_backbone_gw
*backbone_gw
;
694 /* unclaim in any case if it is our own */
695 if (primary_if
&& batadv_compare_eth(backbone_addr
,
696 primary_if
->net_dev
->dev_addr
))
697 batadv_bla_send_claim(bat_priv
, claim_addr
, vid
,
698 BATADV_CLAIM_TYPE_UNCLAIM
);
700 backbone_gw
= batadv_backbone_hash_find(bat_priv
, backbone_addr
, vid
);
705 /* this must be an UNCLAIM frame */
706 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
707 "handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
708 claim_addr
, vid
, backbone_gw
->orig
);
710 batadv_bla_del_claim(bat_priv
, claim_addr
, vid
);
711 batadv_backbone_gw_free_ref(backbone_gw
);
715 /* check for CLAIM frame, return 1 if handled */
716 static int batadv_handle_claim(struct batadv_priv
*bat_priv
,
717 struct batadv_hard_iface
*primary_if
,
718 uint8_t *backbone_addr
, uint8_t *claim_addr
,
721 struct batadv_backbone_gw
*backbone_gw
;
723 /* register the gateway if not yet available, and add the claim. */
725 backbone_gw
= batadv_bla_get_backbone_gw(bat_priv
, backbone_addr
, vid
);
727 if (unlikely(!backbone_gw
))
730 /* this must be a CLAIM frame */
731 batadv_bla_add_claim(bat_priv
, claim_addr
, vid
, backbone_gw
);
732 if (batadv_compare_eth(backbone_addr
, primary_if
->net_dev
->dev_addr
))
733 batadv_bla_send_claim(bat_priv
, claim_addr
, vid
,
734 BATADV_CLAIM_TYPE_CLAIM
);
736 /* TODO: we could call something like tt_local_del() here. */
738 batadv_backbone_gw_free_ref(backbone_gw
);
743 * batadv_check_claim_group
744 * @bat_priv: the bat priv with all the soft interface information
745 * @hw_src: the Hardware source in the ARP Header
746 * @hw_dst: the Hardware destination in the ARP Header
747 * @ethhdr: pointer to the Ethernet header of the claim frame
749 * checks if it is a claim packet and if its on the same group.
750 * This function also applies the group ID of the sender
751 * if it is in the same mesh.
754 * 2 - if it is a claim packet and on the same group
755 * 1 - if is a claim packet from another group
756 * 0 - if it is not a claim packet
758 static int batadv_check_claim_group(struct batadv_priv
*bat_priv
,
759 struct batadv_hard_iface
*primary_if
,
760 uint8_t *hw_src
, uint8_t *hw_dst
,
761 struct ethhdr
*ethhdr
)
763 uint8_t *backbone_addr
;
764 struct batadv_orig_node
*orig_node
;
765 struct batadv_bla_claim_dst
*bla_dst
, *bla_dst_own
;
767 bla_dst
= (struct batadv_bla_claim_dst
*)hw_dst
;
768 bla_dst_own
= &bat_priv
->bla
.claim_dest
;
770 /* check if it is a claim packet in general */
771 if (memcmp(bla_dst
->magic
, bla_dst_own
->magic
,
772 sizeof(bla_dst
->magic
)) != 0)
775 /* if announcement packet, use the source,
776 * otherwise assume it is in the hw_src
778 switch (bla_dst
->type
) {
779 case BATADV_CLAIM_TYPE_CLAIM
:
780 backbone_addr
= hw_src
;
782 case BATADV_CLAIM_TYPE_REQUEST
:
783 case BATADV_CLAIM_TYPE_ANNOUNCE
:
784 case BATADV_CLAIM_TYPE_UNCLAIM
:
785 backbone_addr
= ethhdr
->h_source
;
791 /* don't accept claim frames from ourselves */
792 if (batadv_compare_eth(backbone_addr
, primary_if
->net_dev
->dev_addr
))
795 /* if its already the same group, it is fine. */
796 if (bla_dst
->group
== bla_dst_own
->group
)
799 /* lets see if this originator is in our mesh */
800 orig_node
= batadv_orig_hash_find(bat_priv
, backbone_addr
);
802 /* dont accept claims from gateways which are not in
803 * the same mesh or group.
808 /* if our mesh friends mac is bigger, use it for ourselves. */
809 if (ntohs(bla_dst
->group
) > ntohs(bla_dst_own
->group
)) {
810 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
811 "taking other backbones claim group: %04x\n",
812 ntohs(bla_dst
->group
));
813 bla_dst_own
->group
= bla_dst
->group
;
816 batadv_orig_node_free_ref(orig_node
);
822 /* @bat_priv: the bat priv with all the soft interface information
823 * @skb: the frame to be checked
825 * Check if this is a claim frame, and process it accordingly.
827 * returns 1 if it was a claim frame, otherwise return 0 to
828 * tell the callee that it can use the frame on its own.
830 static int batadv_bla_process_claim(struct batadv_priv
*bat_priv
,
831 struct batadv_hard_iface
*primary_if
,
834 struct ethhdr
*ethhdr
;
835 struct vlan_ethhdr
*vhdr
;
836 struct arphdr
*arphdr
;
837 uint8_t *hw_src
, *hw_dst
;
838 struct batadv_bla_claim_dst
*bla_dst
;
844 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
846 if (ntohs(ethhdr
->h_proto
) == ETH_P_8021Q
) {
847 vhdr
= (struct vlan_ethhdr
*)ethhdr
;
848 vid
= ntohs(vhdr
->h_vlan_TCI
) & VLAN_VID_MASK
;
849 proto
= ntohs(vhdr
->h_vlan_encapsulated_proto
);
850 headlen
= sizeof(*vhdr
);
852 proto
= ntohs(ethhdr
->h_proto
);
856 if (proto
!= ETH_P_ARP
)
857 return 0; /* not a claim frame */
859 /* this must be a ARP frame. check if it is a claim. */
861 if (unlikely(!pskb_may_pull(skb
, headlen
+ arp_hdr_len(skb
->dev
))))
864 /* pskb_may_pull() may have modified the pointers, get ethhdr again */
865 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
866 arphdr
= (struct arphdr
*)((uint8_t *)ethhdr
+ headlen
);
868 /* Check whether the ARP frame carries a valid
871 if (arphdr
->ar_hrd
!= htons(ARPHRD_ETHER
))
873 if (arphdr
->ar_pro
!= htons(ETH_P_IP
))
875 if (arphdr
->ar_hln
!= ETH_ALEN
)
877 if (arphdr
->ar_pln
!= 4)
880 hw_src
= (uint8_t *)arphdr
+ sizeof(struct arphdr
);
881 hw_dst
= hw_src
+ ETH_ALEN
+ 4;
882 bla_dst
= (struct batadv_bla_claim_dst
*)hw_dst
;
884 /* check if it is a claim frame. */
885 ret
= batadv_check_claim_group(bat_priv
, primary_if
, hw_src
, hw_dst
,
888 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
889 "bla_process_claim(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
890 ethhdr
->h_source
, vid
, hw_src
, hw_dst
);
895 /* become a backbone gw ourselves on this vlan if not happened yet */
896 batadv_bla_update_own_backbone_gw(bat_priv
, primary_if
, vid
);
898 /* check for the different types of claim frames ... */
899 switch (bla_dst
->type
) {
900 case BATADV_CLAIM_TYPE_CLAIM
:
901 if (batadv_handle_claim(bat_priv
, primary_if
, hw_src
,
902 ethhdr
->h_source
, vid
))
905 case BATADV_CLAIM_TYPE_UNCLAIM
:
906 if (batadv_handle_unclaim(bat_priv
, primary_if
,
907 ethhdr
->h_source
, hw_src
, vid
))
911 case BATADV_CLAIM_TYPE_ANNOUNCE
:
912 if (batadv_handle_announce(bat_priv
, hw_src
, ethhdr
->h_source
,
916 case BATADV_CLAIM_TYPE_REQUEST
:
917 if (batadv_handle_request(bat_priv
, primary_if
, hw_src
, ethhdr
,
923 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
924 "bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
925 ethhdr
->h_source
, vid
, hw_src
, hw_dst
);
929 /* Check when we last heard from other nodes, and remove them in case of
930 * a time out, or clean all backbone gws if now is set.
932 static void batadv_bla_purge_backbone_gw(struct batadv_priv
*bat_priv
, int now
)
934 struct batadv_backbone_gw
*backbone_gw
;
935 struct hlist_node
*node
, *node_tmp
;
936 struct hlist_head
*head
;
937 struct batadv_hashtable
*hash
;
938 spinlock_t
*list_lock
; /* protects write access to the hash lists */
941 hash
= bat_priv
->bla
.backbone_hash
;
945 for (i
= 0; i
< hash
->size
; i
++) {
946 head
= &hash
->table
[i
];
947 list_lock
= &hash
->list_locks
[i
];
949 spin_lock_bh(list_lock
);
950 hlist_for_each_entry_safe(backbone_gw
, node
, node_tmp
,
954 if (!batadv_has_timed_out(backbone_gw
->lasttime
,
955 BATADV_BLA_BACKBONE_TIMEOUT
))
958 batadv_dbg(BATADV_DBG_BLA
, backbone_gw
->bat_priv
,
959 "bla_purge_backbone_gw(): backbone gw %pM timed out\n",
963 /* don't wait for the pending request anymore */
964 if (atomic_read(&backbone_gw
->request_sent
))
965 atomic_dec(&bat_priv
->bla
.num_requests
);
967 batadv_bla_del_backbone_claims(backbone_gw
);
970 batadv_backbone_gw_free_ref(backbone_gw
);
972 spin_unlock_bh(list_lock
);
977 * batadv_bla_purge_claims
978 * @bat_priv: the bat priv with all the soft interface information
979 * @primary_if: the selected primary interface, may be NULL if now is set
980 * @now: whether the whole hash shall be wiped now
982 * Check when we heard last time from our own claims, and remove them in case of
983 * a time out, or clean all claims if now is set
985 static void batadv_bla_purge_claims(struct batadv_priv
*bat_priv
,
986 struct batadv_hard_iface
*primary_if
,
989 struct batadv_claim
*claim
;
990 struct hlist_node
*node
;
991 struct hlist_head
*head
;
992 struct batadv_hashtable
*hash
;
995 hash
= bat_priv
->bla
.claim_hash
;
999 for (i
= 0; i
< hash
->size
; i
++) {
1000 head
= &hash
->table
[i
];
1003 hlist_for_each_entry_rcu(claim
, node
, head
, hash_entry
) {
1006 if (!batadv_compare_eth(claim
->backbone_gw
->orig
,
1007 primary_if
->net_dev
->dev_addr
))
1009 if (!batadv_has_timed_out(claim
->lasttime
,
1010 BATADV_BLA_CLAIM_TIMEOUT
))
1013 batadv_dbg(BATADV_DBG_BLA
, bat_priv
,
1014 "bla_purge_claims(): %pM, vid %d, time out\n",
1015 claim
->addr
, claim
->vid
);
1018 batadv_handle_unclaim(bat_priv
, primary_if
,
1019 claim
->backbone_gw
->orig
,
1020 claim
->addr
, claim
->vid
);
1027 * batadv_bla_update_orig_address
1028 * @bat_priv: the bat priv with all the soft interface information
1029 * @primary_if: the new selected primary_if
1030 * @oldif: the old primary interface, may be NULL
1032 * Update the backbone gateways when the own orig address changes.
1034 void batadv_bla_update_orig_address(struct batadv_priv
*bat_priv
,
1035 struct batadv_hard_iface
*primary_if
,
1036 struct batadv_hard_iface
*oldif
)
1038 struct batadv_backbone_gw
*backbone_gw
;
1039 struct hlist_node
*node
;
1040 struct hlist_head
*head
;
1041 struct batadv_hashtable
*hash
;
1045 /* reset bridge loop avoidance group id */
1046 group
= htons(crc16(0, primary_if
->net_dev
->dev_addr
, ETH_ALEN
));
1047 bat_priv
->bla
.claim_dest
.group
= group
;
1050 batadv_bla_purge_claims(bat_priv
, NULL
, 1);
1051 batadv_bla_purge_backbone_gw(bat_priv
, 1);
1055 hash
= bat_priv
->bla
.backbone_hash
;
1059 for (i
= 0; i
< hash
->size
; i
++) {
1060 head
= &hash
->table
[i
];
1063 hlist_for_each_entry_rcu(backbone_gw
, node
, head
, hash_entry
) {
1064 /* own orig still holds the old value. */
1065 if (!batadv_compare_eth(backbone_gw
->orig
,
1066 oldif
->net_dev
->dev_addr
))
1069 memcpy(backbone_gw
->orig
,
1070 primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1071 /* send an announce frame so others will ask for our
1072 * claims and update their tables.
1074 batadv_bla_send_announce(bat_priv
, backbone_gw
);
1082 /* (re)start the timer */
1083 static void batadv_bla_start_timer(struct batadv_priv
*bat_priv
)
1085 INIT_DELAYED_WORK(&bat_priv
->bla
.work
, batadv_bla_periodic_work
);
1086 queue_delayed_work(batadv_event_workqueue
, &bat_priv
->bla
.work
,
1087 msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH
));
1090 /* periodic work to do:
1091 * * purge structures when they are too old
1092 * * send announcements
1094 static void batadv_bla_periodic_work(struct work_struct
*work
)
1096 struct delayed_work
*delayed_work
;
1097 struct batadv_priv
*bat_priv
;
1098 struct batadv_priv_bla
*priv_bla
;
1099 struct hlist_node
*node
;
1100 struct hlist_head
*head
;
1101 struct batadv_backbone_gw
*backbone_gw
;
1102 struct batadv_hashtable
*hash
;
1103 struct batadv_hard_iface
*primary_if
;
1106 delayed_work
= container_of(work
, struct delayed_work
, work
);
1107 priv_bla
= container_of(delayed_work
, struct batadv_priv_bla
, work
);
1108 bat_priv
= container_of(priv_bla
, struct batadv_priv
, bla
);
1109 primary_if
= batadv_primary_if_get_selected(bat_priv
);
1113 batadv_bla_purge_claims(bat_priv
, primary_if
, 0);
1114 batadv_bla_purge_backbone_gw(bat_priv
, 0);
1116 if (!atomic_read(&bat_priv
->bridge_loop_avoidance
))
1119 hash
= bat_priv
->bla
.backbone_hash
;
1123 for (i
= 0; i
< hash
->size
; i
++) {
1124 head
= &hash
->table
[i
];
1127 hlist_for_each_entry_rcu(backbone_gw
, node
, head
, hash_entry
) {
1128 if (!batadv_compare_eth(backbone_gw
->orig
,
1129 primary_if
->net_dev
->dev_addr
))
1132 backbone_gw
->lasttime
= jiffies
;
1134 batadv_bla_send_announce(bat_priv
, backbone_gw
);
1140 batadv_hardif_free_ref(primary_if
);
1142 batadv_bla_start_timer(bat_priv
);
1145 /* The hash for claim and backbone hash receive the same key because they
1146 * are getting initialized by hash_new with the same key. Reinitializing
1147 * them with to different keys to allow nested locking without generating
1150 static struct lock_class_key batadv_claim_hash_lock_class_key
;
1151 static struct lock_class_key batadv_backbone_hash_lock_class_key
;
1153 /* initialize all bla structures */
1154 int batadv_bla_init(struct batadv_priv
*bat_priv
)
1157 uint8_t claim_dest
[ETH_ALEN
] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
1158 struct batadv_hard_iface
*primary_if
;
1160 unsigned long entrytime
;
1162 spin_lock_init(&bat_priv
->bla
.bcast_duplist_lock
);
1164 batadv_dbg(BATADV_DBG_BLA
, bat_priv
, "bla hash registering\n");
1166 /* setting claim destination address */
1167 memcpy(&bat_priv
->bla
.claim_dest
.magic
, claim_dest
, 3);
1168 bat_priv
->bla
.claim_dest
.type
= 0;
1169 primary_if
= batadv_primary_if_get_selected(bat_priv
);
1171 crc
= crc16(0, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1172 bat_priv
->bla
.claim_dest
.group
= htons(crc
);
1173 batadv_hardif_free_ref(primary_if
);
1175 bat_priv
->bla
.claim_dest
.group
= 0; /* will be set later */
1178 /* initialize the duplicate list */
1179 entrytime
= jiffies
- msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT
);
1180 for (i
= 0; i
< BATADV_DUPLIST_SIZE
; i
++)
1181 bat_priv
->bla
.bcast_duplist
[i
].entrytime
= entrytime
;
1182 bat_priv
->bla
.bcast_duplist_curr
= 0;
1184 if (bat_priv
->bla
.claim_hash
)
1187 bat_priv
->bla
.claim_hash
= batadv_hash_new(128);
1188 bat_priv
->bla
.backbone_hash
= batadv_hash_new(32);
1190 if (!bat_priv
->bla
.claim_hash
|| !bat_priv
->bla
.backbone_hash
)
1193 batadv_hash_set_lock_class(bat_priv
->bla
.claim_hash
,
1194 &batadv_claim_hash_lock_class_key
);
1195 batadv_hash_set_lock_class(bat_priv
->bla
.backbone_hash
,
1196 &batadv_backbone_hash_lock_class_key
);
1198 batadv_dbg(BATADV_DBG_BLA
, bat_priv
, "bla hashes initialized\n");
1200 batadv_bla_start_timer(bat_priv
);
1205 * batadv_bla_check_bcast_duplist
1206 * @bat_priv: the bat priv with all the soft interface information
1207 * @bcast_packet: encapsulated broadcast frame plus batman header
1208 * @bcast_packet_len: length of encapsulated broadcast frame plus batman header
1210 * check if it is on our broadcast list. Another gateway might
1211 * have sent the same packet because it is connected to the same backbone,
1212 * so we have to remove this duplicate.
1214 * This is performed by checking the CRC, which will tell us
1215 * with a good chance that it is the same packet. If it is furthermore
1216 * sent by another host, drop it. We allow equal packets from
1217 * the same host however as this might be intended.
1219 int batadv_bla_check_bcast_duplist(struct batadv_priv
*bat_priv
,
1220 struct batadv_bcast_packet
*bcast_packet
,
1221 int bcast_packet_len
)
1223 int i
, length
, curr
, ret
= 0;
1226 struct batadv_bcast_duplist_entry
*entry
;
1228 length
= bcast_packet_len
- sizeof(*bcast_packet
);
1229 content
= (uint8_t *)bcast_packet
;
1230 content
+= sizeof(*bcast_packet
);
1232 /* calculate the crc ... */
1233 crc
= crc16(0, content
, length
);
1235 spin_lock_bh(&bat_priv
->bla
.bcast_duplist_lock
);
1237 for (i
= 0; i
< BATADV_DUPLIST_SIZE
; i
++) {
1238 curr
= (bat_priv
->bla
.bcast_duplist_curr
+ i
);
1239 curr
%= BATADV_DUPLIST_SIZE
;
1240 entry
= &bat_priv
->bla
.bcast_duplist
[curr
];
1242 /* we can stop searching if the entry is too old ;
1243 * later entries will be even older
1245 if (batadv_has_timed_out(entry
->entrytime
,
1246 BATADV_DUPLIST_TIMEOUT
))
1249 if (entry
->crc
!= crc
)
1252 if (batadv_compare_eth(entry
->orig
, bcast_packet
->orig
))
1255 /* this entry seems to match: same crc, not too old,
1256 * and from another gw. therefore return 1 to forbid it.
1261 /* not found, add a new entry (overwrite the oldest entry)
1262 * and allow it, its the first occurence.
1264 curr
= (bat_priv
->bla
.bcast_duplist_curr
+ BATADV_DUPLIST_SIZE
- 1);
1265 curr
%= BATADV_DUPLIST_SIZE
;
1266 entry
= &bat_priv
->bla
.bcast_duplist
[curr
];
1268 entry
->entrytime
= jiffies
;
1269 memcpy(entry
->orig
, bcast_packet
->orig
, ETH_ALEN
);
1270 bat_priv
->bla
.bcast_duplist_curr
= curr
;
1273 spin_unlock_bh(&bat_priv
->bla
.bcast_duplist_lock
);
1280 /* @bat_priv: the bat priv with all the soft interface information
1281 * @orig: originator mac address
1283 * check if the originator is a gateway for any VLAN ID.
1285 * returns 1 if it is found, 0 otherwise
1287 int batadv_bla_is_backbone_gw_orig(struct batadv_priv
*bat_priv
, uint8_t *orig
)
1289 struct batadv_hashtable
*hash
= bat_priv
->bla
.backbone_hash
;
1290 struct hlist_head
*head
;
1291 struct hlist_node
*node
;
1292 struct batadv_backbone_gw
*backbone_gw
;
1295 if (!atomic_read(&bat_priv
->bridge_loop_avoidance
))
1301 for (i
= 0; i
< hash
->size
; i
++) {
1302 head
= &hash
->table
[i
];
1305 hlist_for_each_entry_rcu(backbone_gw
, node
, head
, hash_entry
) {
1306 if (batadv_compare_eth(backbone_gw
->orig
, orig
)) {
1319 * batadv_bla_is_backbone_gw
1320 * @skb: the frame to be checked
1321 * @orig_node: the orig_node of the frame
1322 * @hdr_size: maximum length of the frame
1324 * bla_is_backbone_gw inspects the skb for the VLAN ID and returns 1
1325 * if the orig_node is also a gateway on the soft interface, otherwise it
1328 int batadv_bla_is_backbone_gw(struct sk_buff
*skb
,
1329 struct batadv_orig_node
*orig_node
, int hdr_size
)
1331 struct ethhdr
*ethhdr
;
1332 struct vlan_ethhdr
*vhdr
;
1333 struct batadv_backbone_gw
*backbone_gw
;
1336 if (!atomic_read(&orig_node
->bat_priv
->bridge_loop_avoidance
))
1339 /* first, find out the vid. */
1340 if (!pskb_may_pull(skb
, hdr_size
+ ETH_HLEN
))
1343 ethhdr
= (struct ethhdr
*)(((uint8_t *)skb
->data
) + hdr_size
);
1345 if (ntohs(ethhdr
->h_proto
) == ETH_P_8021Q
) {
1346 if (!pskb_may_pull(skb
, hdr_size
+ sizeof(struct vlan_ethhdr
)))
1349 vhdr
= (struct vlan_ethhdr
*)(skb
->data
+ hdr_size
);
1350 vid
= ntohs(vhdr
->h_vlan_TCI
) & VLAN_VID_MASK
;
1353 /* see if this originator is a backbone gw for this VLAN */
1354 backbone_gw
= batadv_backbone_hash_find(orig_node
->bat_priv
,
1355 orig_node
->orig
, vid
);
1359 batadv_backbone_gw_free_ref(backbone_gw
);
1363 /* free all bla structures (for softinterface free or module unload) */
1364 void batadv_bla_free(struct batadv_priv
*bat_priv
)
1366 struct batadv_hard_iface
*primary_if
;
1368 cancel_delayed_work_sync(&bat_priv
->bla
.work
);
1369 primary_if
= batadv_primary_if_get_selected(bat_priv
);
1371 if (bat_priv
->bla
.claim_hash
) {
1372 batadv_bla_purge_claims(bat_priv
, primary_if
, 1);
1373 batadv_hash_destroy(bat_priv
->bla
.claim_hash
);
1374 bat_priv
->bla
.claim_hash
= NULL
;
1376 if (bat_priv
->bla
.backbone_hash
) {
1377 batadv_bla_purge_backbone_gw(bat_priv
, 1);
1378 batadv_hash_destroy(bat_priv
->bla
.backbone_hash
);
1379 bat_priv
->bla
.backbone_hash
= NULL
;
1382 batadv_hardif_free_ref(primary_if
);
1387 * @bat_priv: the bat priv with all the soft interface information
1388 * @skb: the frame to be checked
1389 * @vid: the VLAN ID of the frame
1390 * @is_bcast: the packet came in a broadcast packet type.
1392 * bla_rx avoidance checks if:
1393 * * we have to race for a claim
1394 * * if the frame is allowed on the LAN
1396 * in these cases, the skb is further handled by this function and
1397 * returns 1, otherwise it returns 0 and the caller shall further
1400 int batadv_bla_rx(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
, short vid
,
1403 struct ethhdr
*ethhdr
;
1404 struct batadv_claim search_claim
, *claim
= NULL
;
1405 struct batadv_hard_iface
*primary_if
;
1408 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1410 primary_if
= batadv_primary_if_get_selected(bat_priv
);
1414 if (!atomic_read(&bat_priv
->bridge_loop_avoidance
))
1418 if (unlikely(atomic_read(&bat_priv
->bla
.num_requests
)))
1419 /* don't allow broadcasts while requests are in flight */
1420 if (is_multicast_ether_addr(ethhdr
->h_dest
) && is_bcast
)
1423 memcpy(search_claim
.addr
, ethhdr
->h_source
, ETH_ALEN
);
1424 search_claim
.vid
= vid
;
1425 claim
= batadv_claim_hash_find(bat_priv
, &search_claim
);
1428 /* possible optimization: race for a claim */
1429 /* No claim exists yet, claim it for us!
1431 batadv_handle_claim(bat_priv
, primary_if
,
1432 primary_if
->net_dev
->dev_addr
,
1433 ethhdr
->h_source
, vid
);
1437 /* if it is our own claim ... */
1438 if (batadv_compare_eth(claim
->backbone_gw
->orig
,
1439 primary_if
->net_dev
->dev_addr
)) {
1440 /* ... allow it in any case */
1441 claim
->lasttime
= jiffies
;
1445 /* if it is a broadcast ... */
1446 if (is_multicast_ether_addr(ethhdr
->h_dest
) && is_bcast
) {
1447 /* ... drop it. the responsible gateway is in charge.
1449 * We need to check is_bcast because with the gateway
1450 * feature, broadcasts (like DHCP requests) may be sent
1451 * using a unicast packet type.
1455 /* seems the client considers us as its best gateway.
1456 * send a claim and update the claim table
1459 batadv_handle_claim(bat_priv
, primary_if
,
1460 primary_if
->net_dev
->dev_addr
,
1461 ethhdr
->h_source
, vid
);
1465 batadv_bla_update_own_backbone_gw(bat_priv
, primary_if
, vid
);
1475 batadv_hardif_free_ref(primary_if
);
1477 batadv_claim_free_ref(claim
);
1483 * @bat_priv: the bat priv with all the soft interface information
1484 * @skb: the frame to be checked
1485 * @vid: the VLAN ID of the frame
1488 * * a claim was received which has to be processed
1489 * * the frame is allowed on the mesh
1491 * in these cases, the skb is further handled by this function and
1492 * returns 1, otherwise it returns 0 and the caller shall further
1495 int batadv_bla_tx(struct batadv_priv
*bat_priv
, struct sk_buff
*skb
, short vid
)
1497 struct ethhdr
*ethhdr
;
1498 struct batadv_claim search_claim
, *claim
= NULL
;
1499 struct batadv_hard_iface
*primary_if
;
1502 primary_if
= batadv_primary_if_get_selected(bat_priv
);
1506 if (!atomic_read(&bat_priv
->bridge_loop_avoidance
))
1509 /* in VLAN case, the mac header might not be set. */
1510 skb_reset_mac_header(skb
);
1512 if (batadv_bla_process_claim(bat_priv
, primary_if
, skb
))
1515 ethhdr
= (struct ethhdr
*)skb_mac_header(skb
);
1517 if (unlikely(atomic_read(&bat_priv
->bla
.num_requests
)))
1518 /* don't allow broadcasts while requests are in flight */
1519 if (is_multicast_ether_addr(ethhdr
->h_dest
))
1522 memcpy(search_claim
.addr
, ethhdr
->h_source
, ETH_ALEN
);
1523 search_claim
.vid
= vid
;
1525 claim
= batadv_claim_hash_find(bat_priv
, &search_claim
);
1527 /* if no claim exists, allow it. */
1531 /* check if we are responsible. */
1532 if (batadv_compare_eth(claim
->backbone_gw
->orig
,
1533 primary_if
->net_dev
->dev_addr
)) {
1534 /* if yes, the client has roamed and we have
1537 batadv_handle_unclaim(bat_priv
, primary_if
,
1538 primary_if
->net_dev
->dev_addr
,
1539 ethhdr
->h_source
, vid
);
1543 /* check if it is a multicast/broadcast frame */
1544 if (is_multicast_ether_addr(ethhdr
->h_dest
)) {
1545 /* drop it. the responsible gateway has forwarded it into
1546 * the backbone network.
1550 /* we must allow it. at least if we are
1551 * responsible for the DESTINATION.
1556 batadv_bla_update_own_backbone_gw(bat_priv
, primary_if
, vid
);
1563 batadv_hardif_free_ref(primary_if
);
1565 batadv_claim_free_ref(claim
);
1569 int batadv_bla_claim_table_seq_print_text(struct seq_file
*seq
, void *offset
)
1571 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
1572 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
1573 struct batadv_hashtable
*hash
= bat_priv
->bla
.claim_hash
;
1574 struct batadv_claim
*claim
;
1575 struct batadv_hard_iface
*primary_if
;
1576 struct hlist_node
*node
;
1577 struct hlist_head
*head
;
1580 uint8_t *primary_addr
;
1582 primary_if
= batadv_seq_print_text_primary_if_get(seq
);
1586 primary_addr
= primary_if
->net_dev
->dev_addr
;
1588 "Claims announced for the mesh %s (orig %pM, group id %04x)\n",
1589 net_dev
->name
, primary_addr
,
1590 ntohs(bat_priv
->bla
.claim_dest
.group
));
1591 seq_printf(seq
, " %-17s %-5s %-17s [o] (%-4s)\n",
1592 "Client", "VID", "Originator", "CRC");
1593 for (i
= 0; i
< hash
->size
; i
++) {
1594 head
= &hash
->table
[i
];
1597 hlist_for_each_entry_rcu(claim
, node
, head
, hash_entry
) {
1598 is_own
= batadv_compare_eth(claim
->backbone_gw
->orig
,
1600 seq_printf(seq
, " * %pM on % 5d by %pM [%c] (%04x)\n",
1601 claim
->addr
, claim
->vid
,
1602 claim
->backbone_gw
->orig
,
1603 (is_own
? 'x' : ' '),
1604 claim
->backbone_gw
->crc
);
1610 batadv_hardif_free_ref(primary_if
);
1614 int batadv_bla_backbone_table_seq_print_text(struct seq_file
*seq
, void *offset
)
1616 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
1617 struct batadv_priv
*bat_priv
= netdev_priv(net_dev
);
1618 struct batadv_hashtable
*hash
= bat_priv
->bla
.backbone_hash
;
1619 struct batadv_backbone_gw
*backbone_gw
;
1620 struct batadv_hard_iface
*primary_if
;
1621 struct hlist_node
*node
;
1622 struct hlist_head
*head
;
1626 uint8_t *primary_addr
;
1628 primary_if
= batadv_seq_print_text_primary_if_get(seq
);
1632 primary_addr
= primary_if
->net_dev
->dev_addr
;
1634 "Backbones announced for the mesh %s (orig %pM, group id %04x)\n",
1635 net_dev
->name
, primary_addr
,
1636 ntohs(bat_priv
->bla
.claim_dest
.group
));
1637 seq_printf(seq
, " %-17s %-5s %-9s (%-4s)\n",
1638 "Originator", "VID", "last seen", "CRC");
1639 for (i
= 0; i
< hash
->size
; i
++) {
1640 head
= &hash
->table
[i
];
1643 hlist_for_each_entry_rcu(backbone_gw
, node
, head
, hash_entry
) {
1644 msecs
= jiffies_to_msecs(jiffies
-
1645 backbone_gw
->lasttime
);
1646 secs
= msecs
/ 1000;
1647 msecs
= msecs
% 1000;
1649 is_own
= batadv_compare_eth(backbone_gw
->orig
,
1655 " * %pM on % 5d % 4i.%03is (%04x)\n",
1656 backbone_gw
->orig
, backbone_gw
->vid
,
1657 secs
, msecs
, backbone_gw
->crc
);
1663 batadv_hardif_free_ref(primary_if
);