2 * Copyright (c) 2008, 2009 open80211s Ltd.
3 * Author: Luis Carlos Cobo <luisca@cozybit.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/kernel.h>
11 #include <linux/random.h>
12 #include <linux/rculist.h>
14 #include "ieee80211_i.h"
18 #define PLINK_CNF_AID(mgmt) ((mgmt)->u.action.u.self_prot.variable + 2)
19 #define PLINK_GET_LLID(p) (p + 2)
20 #define PLINK_GET_PLID(p) (p + 4)
22 #define mod_plink_timer(s, t) (mod_timer(&s->mesh->plink_timer, \
23 jiffies + msecs_to_jiffies(t)))
37 static const char * const mplstates
[] = {
38 [NL80211_PLINK_LISTEN
] = "LISTEN",
39 [NL80211_PLINK_OPN_SNT
] = "OPN-SNT",
40 [NL80211_PLINK_OPN_RCVD
] = "OPN-RCVD",
41 [NL80211_PLINK_CNF_RCVD
] = "CNF_RCVD",
42 [NL80211_PLINK_ESTAB
] = "ESTAB",
43 [NL80211_PLINK_HOLDING
] = "HOLDING",
44 [NL80211_PLINK_BLOCKED
] = "BLOCKED"
47 static const char * const mplevents
[] = {
48 [PLINK_UNDEFINED
] = "NONE",
49 [OPN_ACPT
] = "OPN_ACPT",
50 [OPN_RJCT
] = "OPN_RJCT",
51 [OPN_IGNR
] = "OPN_IGNR",
52 [CNF_ACPT
] = "CNF_ACPT",
53 [CNF_RJCT
] = "CNF_RJCT",
54 [CNF_IGNR
] = "CNF_IGNR",
55 [CLS_ACPT
] = "CLS_ACPT",
56 [CLS_IGNR
] = "CLS_IGNR"
59 /* We only need a valid sta if user configured a minimum rssi_threshold. */
60 static bool rssi_threshold_check(struct ieee80211_sub_if_data
*sdata
,
63 s32 rssi_threshold
= sdata
->u
.mesh
.mshcfg
.rssi_threshold
;
64 return rssi_threshold
== 0 ||
66 (s8
)-ewma_signal_read(&sta
->rx_stats_avg
.signal
) >
71 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
73 * @sta: mesh peer link to restart
75 * Locking: this function must be called holding sta->mesh->plink_lock
77 static inline void mesh_plink_fsm_restart(struct sta_info
*sta
)
79 lockdep_assert_held(&sta
->mesh
->plink_lock
);
80 sta
->mesh
->plink_state
= NL80211_PLINK_LISTEN
;
81 sta
->mesh
->llid
= sta
->mesh
->plid
= sta
->mesh
->reason
= 0;
82 sta
->mesh
->plink_retries
= 0;
86 * mesh_set_short_slot_time - enable / disable ERP short slot time.
88 * The standard indirectly mandates mesh STAs to turn off short slot time by
89 * disallowing advertising this (802.11-2012 8.4.1.4), but that doesn't mean we
90 * can't be sneaky about it. Enable short slot time if all mesh STAs in the
91 * MBSS support ERP rates.
93 * Returns BSS_CHANGED_ERP_SLOT or 0 for no change.
95 static u32
mesh_set_short_slot_time(struct ieee80211_sub_if_data
*sdata
)
97 struct ieee80211_local
*local
= sdata
->local
;
98 struct ieee80211_supported_band
*sband
;
100 u32 erp_rates
= 0, changed
= 0;
102 bool short_slot
= false;
104 sband
= ieee80211_get_sband(sdata
);
108 if (sband
->band
== NL80211_BAND_5GHZ
) {
109 /* (IEEE 802.11-2012 19.4.5) */
112 } else if (sband
->band
!= NL80211_BAND_2GHZ
) {
116 for (i
= 0; i
< sband
->n_bitrates
; i
++)
117 if (sband
->bitrates
[i
].flags
& IEEE80211_RATE_ERP_G
)
124 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
125 if (sdata
!= sta
->sdata
||
126 sta
->mesh
->plink_state
!= NL80211_PLINK_ESTAB
)
130 if (erp_rates
& sta
->sta
.supp_rates
[sband
->band
])
138 if (sdata
->vif
.bss_conf
.use_short_slot
!= short_slot
) {
139 sdata
->vif
.bss_conf
.use_short_slot
= short_slot
;
140 changed
= BSS_CHANGED_ERP_SLOT
;
141 mpl_dbg(sdata
, "mesh_plink %pM: ERP short slot time %d\n",
142 sdata
->vif
.addr
, short_slot
);
148 * mesh_set_ht_prot_mode - set correct HT protection mode
150 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
151 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
152 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
153 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
154 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
155 * HT20 peer is present. Otherwise no-protection mode is selected.
157 static u32
mesh_set_ht_prot_mode(struct ieee80211_sub_if_data
*sdata
)
159 struct ieee80211_local
*local
= sdata
->local
;
160 struct sta_info
*sta
;
162 bool non_ht_sta
= false, ht20_sta
= false;
164 switch (sdata
->vif
.bss_conf
.chandef
.width
) {
165 case NL80211_CHAN_WIDTH_20_NOHT
:
166 case NL80211_CHAN_WIDTH_5
:
167 case NL80211_CHAN_WIDTH_10
:
174 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
175 if (sdata
!= sta
->sdata
||
176 sta
->mesh
->plink_state
!= NL80211_PLINK_ESTAB
)
179 if (sta
->sta
.bandwidth
> IEEE80211_STA_RX_BW_20
)
182 if (!sta
->sta
.ht_cap
.ht_supported
) {
183 mpl_dbg(sdata
, "nonHT sta (%pM) is present\n",
189 mpl_dbg(sdata
, "HT20 sta (%pM) is present\n", sta
->sta
.addr
);
195 ht_opmode
= IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
;
197 sdata
->vif
.bss_conf
.chandef
.width
> NL80211_CHAN_WIDTH_20
)
198 ht_opmode
= IEEE80211_HT_OP_MODE_PROTECTION_20MHZ
;
200 ht_opmode
= IEEE80211_HT_OP_MODE_PROTECTION_NONE
;
202 if (sdata
->vif
.bss_conf
.ht_operation_mode
== ht_opmode
)
205 sdata
->vif
.bss_conf
.ht_operation_mode
= ht_opmode
;
206 sdata
->u
.mesh
.mshcfg
.ht_opmode
= ht_opmode
;
207 mpl_dbg(sdata
, "selected new HT protection mode %d\n", ht_opmode
);
208 return BSS_CHANGED_HT
;
211 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data
*sdata
,
212 struct sta_info
*sta
,
213 enum ieee80211_self_protected_actioncode action
,
214 u8
*da
, u16 llid
, u16 plid
, u16 reason
)
216 struct ieee80211_local
*local
= sdata
->local
;
218 struct ieee80211_tx_info
*info
;
219 struct ieee80211_mgmt
*mgmt
;
220 bool include_plid
= false;
221 u16 peering_proto
= 0;
223 int hdr_len
= offsetof(struct ieee80211_mgmt
, u
.action
.u
.self_prot
) +
224 sizeof(mgmt
->u
.action
.u
.self_prot
);
227 skb
= dev_alloc_skb(local
->tx_headroom
+
229 2 + /* capability info */
231 2 + 8 + /* supported rates */
232 2 + (IEEE80211_MAX_SUPP_RATES
- 8) +
233 2 + sdata
->u
.mesh
.mesh_id_len
+
234 2 + sizeof(struct ieee80211_meshconf_ie
) +
235 2 + sizeof(struct ieee80211_ht_cap
) +
236 2 + sizeof(struct ieee80211_ht_operation
) +
237 2 + sizeof(struct ieee80211_vht_cap
) +
238 2 + sizeof(struct ieee80211_vht_operation
) +
239 2 + 8 + /* peering IE */
240 sdata
->u
.mesh
.ie_len
);
243 info
= IEEE80211_SKB_CB(skb
);
244 skb_reserve(skb
, local
->tx_headroom
);
245 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, hdr_len
);
246 memset(mgmt
, 0, hdr_len
);
247 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
248 IEEE80211_STYPE_ACTION
);
249 memcpy(mgmt
->da
, da
, ETH_ALEN
);
250 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
251 memcpy(mgmt
->bssid
, sdata
->vif
.addr
, ETH_ALEN
);
252 mgmt
->u
.action
.category
= WLAN_CATEGORY_SELF_PROTECTED
;
253 mgmt
->u
.action
.u
.self_prot
.action_code
= action
;
255 if (action
!= WLAN_SP_MESH_PEERING_CLOSE
) {
256 struct ieee80211_supported_band
*sband
;
257 enum nl80211_band band
;
259 sband
= ieee80211_get_sband(sdata
);
266 /* capability info */
267 pos
= skb_put(skb
, 2);
269 if (action
== WLAN_SP_MESH_PEERING_CONFIRM
) {
271 pos
= skb_put(skb
, 2);
272 put_unaligned_le16(sta
->sta
.aid
, pos
);
274 if (ieee80211_add_srates_ie(sdata
, skb
, true, band
) ||
275 ieee80211_add_ext_srates_ie(sdata
, skb
, true, band
) ||
276 mesh_add_rsn_ie(sdata
, skb
) ||
277 mesh_add_meshid_ie(sdata
, skb
) ||
278 mesh_add_meshconf_ie(sdata
, skb
))
280 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
281 info
->flags
|= IEEE80211_TX_CTL_NO_ACK
;
282 if (mesh_add_meshid_ie(sdata
, skb
))
286 /* Add Mesh Peering Management element */
288 case WLAN_SP_MESH_PEERING_OPEN
:
290 case WLAN_SP_MESH_PEERING_CONFIRM
:
294 case WLAN_SP_MESH_PEERING_CLOSE
:
299 ie_len
+= 2; /* reason code */
306 if (WARN_ON(skb_tailroom(skb
) < 2 + ie_len
))
309 pos
= skb_put(skb
, 2 + ie_len
);
310 *pos
++ = WLAN_EID_PEER_MGMT
;
312 memcpy(pos
, &peering_proto
, 2);
314 put_unaligned_le16(llid
, pos
);
317 put_unaligned_le16(plid
, pos
);
320 if (action
== WLAN_SP_MESH_PEERING_CLOSE
) {
321 put_unaligned_le16(reason
, pos
);
325 if (action
!= WLAN_SP_MESH_PEERING_CLOSE
) {
326 if (mesh_add_ht_cap_ie(sdata
, skb
) ||
327 mesh_add_ht_oper_ie(sdata
, skb
) ||
328 mesh_add_vht_cap_ie(sdata
, skb
) ||
329 mesh_add_vht_oper_ie(sdata
, skb
))
333 if (mesh_add_vendor_ies(sdata
, skb
))
336 ieee80211_tx_skb(sdata
, skb
);
344 * __mesh_plink_deactivate - deactivate mesh peer link
346 * @sta: mesh peer link to deactivate
348 * Mesh paths with this peer as next hop should be flushed
349 * by the caller outside of plink_lock.
351 * Returns beacon changed flag if the beacon content changed.
353 * Locking: the caller must hold sta->mesh->plink_lock
355 static u32
__mesh_plink_deactivate(struct sta_info
*sta
)
357 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
360 lockdep_assert_held(&sta
->mesh
->plink_lock
);
362 if (sta
->mesh
->plink_state
== NL80211_PLINK_ESTAB
)
363 changed
= mesh_plink_dec_estab_count(sdata
);
364 sta
->mesh
->plink_state
= NL80211_PLINK_BLOCKED
;
366 ieee80211_mps_sta_status_update(sta
);
367 changed
|= ieee80211_mps_set_sta_local_pm(sta
,
368 NL80211_MESH_POWER_UNKNOWN
);
374 * mesh_plink_deactivate - deactivate mesh peer link
376 * @sta: mesh peer link to deactivate
378 * All mesh paths with this peer as next hop will be flushed
380 u32
mesh_plink_deactivate(struct sta_info
*sta
)
382 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
385 spin_lock_bh(&sta
->mesh
->plink_lock
);
386 changed
= __mesh_plink_deactivate(sta
);
388 if (!sdata
->u
.mesh
.user_mpm
) {
389 sta
->mesh
->reason
= WLAN_REASON_MESH_PEER_CANCELED
;
390 mesh_plink_frame_tx(sdata
, sta
, WLAN_SP_MESH_PEERING_CLOSE
,
391 sta
->sta
.addr
, sta
->mesh
->llid
,
392 sta
->mesh
->plid
, sta
->mesh
->reason
);
394 spin_unlock_bh(&sta
->mesh
->plink_lock
);
395 if (!sdata
->u
.mesh
.user_mpm
)
396 del_timer_sync(&sta
->mesh
->plink_timer
);
397 mesh_path_flush_by_nexthop(sta
);
399 /* make sure no readers can access nexthop sta from here on */
405 static void mesh_sta_info_init(struct ieee80211_sub_if_data
*sdata
,
406 struct sta_info
*sta
,
407 struct ieee802_11_elems
*elems
, bool insert
)
409 struct ieee80211_local
*local
= sdata
->local
;
410 struct ieee80211_supported_band
*sband
;
411 u32 rates
, basic_rates
= 0, changed
= 0;
412 enum ieee80211_sta_rx_bandwidth bw
= sta
->sta
.bandwidth
;
414 sband
= ieee80211_get_sband(sdata
);
418 rates
= ieee80211_sta_get_rates(sdata
, elems
, sband
->band
,
421 spin_lock_bh(&sta
->mesh
->plink_lock
);
422 sta
->rx_stats
.last_rx
= jiffies
;
424 /* rates and capabilities don't change during peering */
425 if (sta
->mesh
->plink_state
== NL80211_PLINK_ESTAB
&&
426 sta
->mesh
->processed_beacon
)
428 sta
->mesh
->processed_beacon
= true;
430 if (sta
->sta
.supp_rates
[sband
->band
] != rates
)
431 changed
|= IEEE80211_RC_SUPP_RATES_CHANGED
;
432 sta
->sta
.supp_rates
[sband
->band
] = rates
;
434 if (ieee80211_ht_cap_ie_to_sta_ht_cap(sdata
, sband
,
435 elems
->ht_cap_elem
, sta
))
436 changed
|= IEEE80211_RC_BW_CHANGED
;
438 ieee80211_vht_cap_ie_to_sta_vht_cap(sdata
, sband
,
439 elems
->vht_cap_elem
, sta
);
441 if (bw
!= sta
->sta
.bandwidth
)
442 changed
|= IEEE80211_RC_BW_CHANGED
;
444 /* HT peer is operating 20MHz-only */
445 if (elems
->ht_operation
&&
446 !(elems
->ht_operation
->ht_param
&
447 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY
)) {
448 if (sta
->sta
.bandwidth
!= IEEE80211_STA_RX_BW_20
)
449 changed
|= IEEE80211_RC_BW_CHANGED
;
450 sta
->sta
.bandwidth
= IEEE80211_STA_RX_BW_20
;
454 rate_control_rate_init(sta
);
456 rate_control_rate_update(local
, sband
, sta
, changed
);
458 spin_unlock_bh(&sta
->mesh
->plink_lock
);
461 static int mesh_allocate_aid(struct ieee80211_sub_if_data
*sdata
)
463 struct sta_info
*sta
;
464 unsigned long *aid_map
;
467 aid_map
= kcalloc(BITS_TO_LONGS(IEEE80211_MAX_AID
+ 1),
468 sizeof(*aid_map
), GFP_KERNEL
);
472 /* reserve aid 0 for mcast indication */
473 __set_bit(0, aid_map
);
476 list_for_each_entry_rcu(sta
, &sdata
->local
->sta_list
, list
)
477 __set_bit(sta
->sta
.aid
, aid_map
);
480 aid
= find_first_zero_bit(aid_map
, IEEE80211_MAX_AID
+ 1);
483 if (aid
> IEEE80211_MAX_AID
)
489 static struct sta_info
*
490 __mesh_sta_info_alloc(struct ieee80211_sub_if_data
*sdata
, u8
*hw_addr
)
492 struct sta_info
*sta
;
495 if (sdata
->local
->num_sta
>= MESH_MAX_PLINKS
)
498 aid
= mesh_allocate_aid(sdata
);
502 sta
= sta_info_alloc(sdata
, hw_addr
, GFP_KERNEL
);
506 sta
->mesh
->plink_state
= NL80211_PLINK_LISTEN
;
510 sta_info_pre_move_state(sta
, IEEE80211_STA_AUTH
);
511 sta_info_pre_move_state(sta
, IEEE80211_STA_ASSOC
);
512 sta_info_pre_move_state(sta
, IEEE80211_STA_AUTHORIZED
);
517 static struct sta_info
*
518 mesh_sta_info_alloc(struct ieee80211_sub_if_data
*sdata
, u8
*addr
,
519 struct ieee802_11_elems
*elems
)
521 struct sta_info
*sta
= NULL
;
523 /* Userspace handles station allocation */
524 if (sdata
->u
.mesh
.user_mpm
||
525 sdata
->u
.mesh
.security
& IEEE80211_MESH_SEC_AUTHED
) {
526 if (mesh_peer_accepts_plinks(elems
) &&
527 mesh_plink_availables(sdata
))
528 cfg80211_notify_new_peer_candidate(sdata
->dev
, addr
,
533 sta
= __mesh_sta_info_alloc(sdata
, addr
);
539 * mesh_sta_info_get - return mesh sta info entry for @addr.
541 * @sdata: local meshif
542 * @addr: peer's address
543 * @elems: IEs from beacon or mesh peering frame.
545 * Return existing or newly allocated sta_info under RCU read lock.
546 * (re)initialize with given IEs.
548 static struct sta_info
*
549 mesh_sta_info_get(struct ieee80211_sub_if_data
*sdata
,
550 u8
*addr
, struct ieee802_11_elems
*elems
) __acquires(RCU
)
552 struct sta_info
*sta
= NULL
;
555 sta
= sta_info_get(sdata
, addr
);
557 mesh_sta_info_init(sdata
, sta
, elems
, false);
560 /* can't run atomic */
561 sta
= mesh_sta_info_alloc(sdata
, addr
, elems
);
567 mesh_sta_info_init(sdata
, sta
, elems
, true);
569 if (sta_info_insert_rcu(sta
))
577 * mesh_neighbour_update - update or initialize new mesh neighbor.
579 * @sdata: local meshif
580 * @addr: peer's address
581 * @elems: IEs from beacon or mesh peering frame
583 * Initiates peering if appropriate.
585 void mesh_neighbour_update(struct ieee80211_sub_if_data
*sdata
,
587 struct ieee802_11_elems
*elems
)
589 struct sta_info
*sta
;
592 sta
= mesh_sta_info_get(sdata
, hw_addr
, elems
);
596 if (mesh_peer_accepts_plinks(elems
) &&
597 sta
->mesh
->plink_state
== NL80211_PLINK_LISTEN
&&
598 sdata
->u
.mesh
.accepting_plinks
&&
599 sdata
->u
.mesh
.mshcfg
.auto_open_plinks
&&
600 rssi_threshold_check(sdata
, sta
))
601 changed
= mesh_plink_open(sta
);
603 ieee80211_mps_frame_release(sta
, elems
);
606 ieee80211_mbss_info_change_notify(sdata
, changed
);
609 static void mesh_plink_timer(unsigned long data
)
611 struct sta_info
*sta
;
613 struct ieee80211_sub_if_data
*sdata
;
614 struct mesh_config
*mshcfg
;
615 enum ieee80211_self_protected_actioncode action
= 0;
618 * This STA is valid because sta_info_destroy() will
619 * del_timer_sync() this timer after having made sure
620 * it cannot be readded (by deleting the plink.)
622 sta
= (struct sta_info
*) data
;
624 if (sta
->sdata
->local
->quiescing
)
627 spin_lock_bh(&sta
->mesh
->plink_lock
);
629 /* If a timer fires just before a state transition on another CPU,
630 * we may have already extended the timeout and changed state by the
631 * time we've acquired the lock and arrived here. In that case,
632 * skip this timer and wait for the new one.
634 if (time_before(jiffies
, sta
->mesh
->plink_timer
.expires
)) {
636 "Ignoring timer for %pM in state %s (timer adjusted)",
637 sta
->sta
.addr
, mplstates
[sta
->mesh
->plink_state
]);
638 spin_unlock_bh(&sta
->mesh
->plink_lock
);
642 /* del_timer() and handler may race when entering these states */
643 if (sta
->mesh
->plink_state
== NL80211_PLINK_LISTEN
||
644 sta
->mesh
->plink_state
== NL80211_PLINK_ESTAB
) {
646 "Ignoring timer for %pM in state %s (timer deleted)",
647 sta
->sta
.addr
, mplstates
[sta
->mesh
->plink_state
]);
648 spin_unlock_bh(&sta
->mesh
->plink_lock
);
653 "Mesh plink timer for %pM fired on state %s\n",
654 sta
->sta
.addr
, mplstates
[sta
->mesh
->plink_state
]);
656 mshcfg
= &sdata
->u
.mesh
.mshcfg
;
658 switch (sta
->mesh
->plink_state
) {
659 case NL80211_PLINK_OPN_RCVD
:
660 case NL80211_PLINK_OPN_SNT
:
662 if (sta
->mesh
->plink_retries
< mshcfg
->dot11MeshMaxRetries
) {
665 "Mesh plink for %pM (retry, timeout): %d %d\n",
666 sta
->sta
.addr
, sta
->mesh
->plink_retries
,
667 sta
->mesh
->plink_timeout
);
668 get_random_bytes(&rand
, sizeof(u32
));
669 sta
->mesh
->plink_timeout
= sta
->mesh
->plink_timeout
+
670 rand
% sta
->mesh
->plink_timeout
;
671 ++sta
->mesh
->plink_retries
;
672 mod_plink_timer(sta
, sta
->mesh
->plink_timeout
);
673 action
= WLAN_SP_MESH_PEERING_OPEN
;
676 reason
= WLAN_REASON_MESH_MAX_RETRIES
;
677 /* fall through on else */
678 case NL80211_PLINK_CNF_RCVD
:
681 reason
= WLAN_REASON_MESH_CONFIRM_TIMEOUT
;
682 sta
->mesh
->plink_state
= NL80211_PLINK_HOLDING
;
683 mod_plink_timer(sta
, mshcfg
->dot11MeshHoldingTimeout
);
684 action
= WLAN_SP_MESH_PEERING_CLOSE
;
686 case NL80211_PLINK_HOLDING
:
688 del_timer(&sta
->mesh
->plink_timer
);
689 mesh_plink_fsm_restart(sta
);
694 spin_unlock_bh(&sta
->mesh
->plink_lock
);
696 mesh_plink_frame_tx(sdata
, sta
, action
, sta
->sta
.addr
,
697 sta
->mesh
->llid
, sta
->mesh
->plid
, reason
);
700 static inline void mesh_plink_timer_set(struct sta_info
*sta
, u32 timeout
)
702 sta
->mesh
->plink_timer
.expires
= jiffies
+ msecs_to_jiffies(timeout
);
703 sta
->mesh
->plink_timer
.data
= (unsigned long) sta
;
704 sta
->mesh
->plink_timer
.function
= mesh_plink_timer
;
705 sta
->mesh
->plink_timeout
= timeout
;
706 add_timer(&sta
->mesh
->plink_timer
);
709 static bool llid_in_use(struct ieee80211_sub_if_data
*sdata
,
712 struct ieee80211_local
*local
= sdata
->local
;
714 struct sta_info
*sta
;
717 list_for_each_entry_rcu(sta
, &local
->sta_list
, list
) {
718 if (sdata
!= sta
->sdata
)
721 if (!memcmp(&sta
->mesh
->llid
, &llid
, sizeof(llid
))) {
731 static u16
mesh_get_new_llid(struct ieee80211_sub_if_data
*sdata
)
736 get_random_bytes(&llid
, sizeof(llid
));
737 } while (llid_in_use(sdata
, llid
));
742 u32
mesh_plink_open(struct sta_info
*sta
)
744 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
747 if (!test_sta_flag(sta
, WLAN_STA_AUTH
))
750 spin_lock_bh(&sta
->mesh
->plink_lock
);
751 sta
->mesh
->llid
= mesh_get_new_llid(sdata
);
752 if (sta
->mesh
->plink_state
!= NL80211_PLINK_LISTEN
&&
753 sta
->mesh
->plink_state
!= NL80211_PLINK_BLOCKED
) {
754 spin_unlock_bh(&sta
->mesh
->plink_lock
);
757 sta
->mesh
->plink_state
= NL80211_PLINK_OPN_SNT
;
758 mesh_plink_timer_set(sta
, sdata
->u
.mesh
.mshcfg
.dot11MeshRetryTimeout
);
759 spin_unlock_bh(&sta
->mesh
->plink_lock
);
761 "Mesh plink: starting establishment with %pM\n",
764 /* set the non-peer mode to active during peering */
765 changed
= ieee80211_mps_local_status_update(sdata
);
767 mesh_plink_frame_tx(sdata
, sta
, WLAN_SP_MESH_PEERING_OPEN
,
768 sta
->sta
.addr
, sta
->mesh
->llid
, 0, 0);
772 u32
mesh_plink_block(struct sta_info
*sta
)
776 spin_lock_bh(&sta
->mesh
->plink_lock
);
777 changed
= __mesh_plink_deactivate(sta
);
778 sta
->mesh
->plink_state
= NL80211_PLINK_BLOCKED
;
779 spin_unlock_bh(&sta
->mesh
->plink_lock
);
780 mesh_path_flush_by_nexthop(sta
);
785 static void mesh_plink_close(struct ieee80211_sub_if_data
*sdata
,
786 struct sta_info
*sta
,
787 enum plink_event event
)
789 struct mesh_config
*mshcfg
= &sdata
->u
.mesh
.mshcfg
;
790 u16 reason
= (event
== CLS_ACPT
) ?
791 WLAN_REASON_MESH_CLOSE
: WLAN_REASON_MESH_CONFIG
;
793 sta
->mesh
->reason
= reason
;
794 sta
->mesh
->plink_state
= NL80211_PLINK_HOLDING
;
795 mod_plink_timer(sta
, mshcfg
->dot11MeshHoldingTimeout
);
798 static u32
mesh_plink_establish(struct ieee80211_sub_if_data
*sdata
,
799 struct sta_info
*sta
)
801 struct mesh_config
*mshcfg
= &sdata
->u
.mesh
.mshcfg
;
804 del_timer(&sta
->mesh
->plink_timer
);
805 sta
->mesh
->plink_state
= NL80211_PLINK_ESTAB
;
806 changed
|= mesh_plink_inc_estab_count(sdata
);
807 changed
|= mesh_set_ht_prot_mode(sdata
);
808 changed
|= mesh_set_short_slot_time(sdata
);
809 mpl_dbg(sdata
, "Mesh plink with %pM ESTABLISHED\n", sta
->sta
.addr
);
810 ieee80211_mps_sta_status_update(sta
);
811 changed
|= ieee80211_mps_set_sta_local_pm(sta
, mshcfg
->power_mode
);
816 * mesh_plink_fsm - step @sta MPM based on @event
819 * @sta: mesh neighbor
820 * @event: peering event
822 * Return: changed MBSS flags
824 static u32
mesh_plink_fsm(struct ieee80211_sub_if_data
*sdata
,
825 struct sta_info
*sta
, enum plink_event event
)
827 struct mesh_config
*mshcfg
= &sdata
->u
.mesh
.mshcfg
;
828 enum ieee80211_self_protected_actioncode action
= 0;
832 mpl_dbg(sdata
, "peer %pM in state %s got event %s\n", sta
->sta
.addr
,
833 mplstates
[sta
->mesh
->plink_state
], mplevents
[event
]);
835 spin_lock_bh(&sta
->mesh
->plink_lock
);
836 switch (sta
->mesh
->plink_state
) {
837 case NL80211_PLINK_LISTEN
:
840 mesh_plink_fsm_restart(sta
);
843 sta
->mesh
->plink_state
= NL80211_PLINK_OPN_RCVD
;
844 sta
->mesh
->llid
= mesh_get_new_llid(sdata
);
845 mesh_plink_timer_set(sta
,
846 mshcfg
->dot11MeshRetryTimeout
);
848 /* set the non-peer mode to active during peering */
849 changed
|= ieee80211_mps_local_status_update(sdata
);
850 action
= WLAN_SP_MESH_PEERING_OPEN
;
856 case NL80211_PLINK_OPN_SNT
:
861 mesh_plink_close(sdata
, sta
, event
);
862 action
= WLAN_SP_MESH_PEERING_CLOSE
;
865 /* retry timer is left untouched */
866 sta
->mesh
->plink_state
= NL80211_PLINK_OPN_RCVD
;
867 action
= WLAN_SP_MESH_PEERING_CONFIRM
;
870 sta
->mesh
->plink_state
= NL80211_PLINK_CNF_RCVD
;
871 mod_plink_timer(sta
, mshcfg
->dot11MeshConfirmTimeout
);
877 case NL80211_PLINK_OPN_RCVD
:
882 mesh_plink_close(sdata
, sta
, event
);
883 action
= WLAN_SP_MESH_PEERING_CLOSE
;
886 action
= WLAN_SP_MESH_PEERING_CONFIRM
;
889 changed
|= mesh_plink_establish(sdata
, sta
);
895 case NL80211_PLINK_CNF_RCVD
:
900 mesh_plink_close(sdata
, sta
, event
);
901 action
= WLAN_SP_MESH_PEERING_CLOSE
;
904 changed
|= mesh_plink_establish(sdata
, sta
);
905 action
= WLAN_SP_MESH_PEERING_CONFIRM
;
911 case NL80211_PLINK_ESTAB
:
914 changed
|= __mesh_plink_deactivate(sta
);
915 changed
|= mesh_set_ht_prot_mode(sdata
);
916 changed
|= mesh_set_short_slot_time(sdata
);
917 mesh_plink_close(sdata
, sta
, event
);
918 action
= WLAN_SP_MESH_PEERING_CLOSE
;
922 action
= WLAN_SP_MESH_PEERING_CONFIRM
;
928 case NL80211_PLINK_HOLDING
:
931 del_timer(&sta
->mesh
->plink_timer
);
932 mesh_plink_fsm_restart(sta
);
938 action
= WLAN_SP_MESH_PEERING_CLOSE
;
945 /* should not get here, PLINK_BLOCKED is dealt with at the
946 * beginning of the function
950 spin_unlock_bh(&sta
->mesh
->plink_lock
);
952 mesh_path_flush_by_nexthop(sta
);
954 mesh_plink_frame_tx(sdata
, sta
, action
, sta
->sta
.addr
,
955 sta
->mesh
->llid
, sta
->mesh
->plid
,
958 /* also send confirm in open case */
959 if (action
== WLAN_SP_MESH_PEERING_OPEN
) {
960 mesh_plink_frame_tx(sdata
, sta
,
961 WLAN_SP_MESH_PEERING_CONFIRM
,
962 sta
->sta
.addr
, sta
->mesh
->llid
,
971 * mesh_plink_get_event - get correct MPM event
974 * @sta: peer, leave NULL if processing a frame from a new suitable peer
975 * @elems: peering management IEs
977 * @llid: peer's peer link ID
978 * @plid: peer's local link ID
980 * Return: new peering event for @sta, but PLINK_UNDEFINED should be treated as
983 static enum plink_event
984 mesh_plink_get_event(struct ieee80211_sub_if_data
*sdata
,
985 struct sta_info
*sta
,
986 struct ieee802_11_elems
*elems
,
987 enum ieee80211_self_protected_actioncode ftype
,
990 enum plink_event event
= PLINK_UNDEFINED
;
991 u8 ie_len
= elems
->peering_len
;
994 matches_local
= (ftype
== WLAN_SP_MESH_PEERING_CLOSE
||
995 mesh_matches_local(sdata
, elems
));
997 /* deny open request from non-matching peer */
998 if (!matches_local
&& !sta
) {
1004 if (ftype
!= WLAN_SP_MESH_PEERING_OPEN
) {
1005 mpl_dbg(sdata
, "Mesh plink: cls or cnf from unknown peer\n");
1008 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
1009 if (!mesh_plink_free_count(sdata
)) {
1010 mpl_dbg(sdata
, "Mesh plink error: no more free plinks\n");
1014 /* new matching peer */
1018 if (!test_sta_flag(sta
, WLAN_STA_AUTH
)) {
1019 mpl_dbg(sdata
, "Mesh plink: Action frame from non-authed peer\n");
1022 if (sta
->mesh
->plink_state
== NL80211_PLINK_BLOCKED
)
1027 case WLAN_SP_MESH_PEERING_OPEN
:
1030 if (!mesh_plink_free_count(sdata
) ||
1031 (sta
->mesh
->plid
&& sta
->mesh
->plid
!= plid
))
1036 case WLAN_SP_MESH_PEERING_CONFIRM
:
1039 if (!mesh_plink_free_count(sdata
) ||
1040 sta
->mesh
->llid
!= llid
||
1041 (sta
->mesh
->plid
&& sta
->mesh
->plid
!= plid
))
1046 case WLAN_SP_MESH_PEERING_CLOSE
:
1047 if (sta
->mesh
->plink_state
== NL80211_PLINK_ESTAB
)
1048 /* Do not check for llid or plid. This does not
1049 * follow the standard but since multiple plinks
1050 * per sta are not supported, it is necessary in
1051 * order to avoid a livelock when MP A sees an
1052 * establish peer link to MP B but MP B does not
1053 * see it. This can be caused by a timeout in
1054 * B's peer link establishment or B beign
1058 else if (sta
->mesh
->plid
!= plid
)
1060 else if (ie_len
== 8 && sta
->mesh
->llid
!= llid
)
1066 mpl_dbg(sdata
, "Mesh plink: unknown frame subtype\n");
1075 mesh_process_plink_frame(struct ieee80211_sub_if_data
*sdata
,
1076 struct ieee80211_mgmt
*mgmt
,
1077 struct ieee802_11_elems
*elems
)
1080 struct sta_info
*sta
;
1081 enum plink_event event
;
1082 enum ieee80211_self_protected_actioncode ftype
;
1084 u8 ie_len
= elems
->peering_len
;
1087 if (!elems
->peering
) {
1089 "Mesh plink: missing necessary peer link ie\n");
1093 if (elems
->rsn_len
&&
1094 sdata
->u
.mesh
.security
== IEEE80211_MESH_SEC_NONE
) {
1096 "Mesh plink: can't establish link with secure peer\n");
1100 ftype
= mgmt
->u
.action
.u
.self_prot
.action_code
;
1101 if ((ftype
== WLAN_SP_MESH_PEERING_OPEN
&& ie_len
!= 4) ||
1102 (ftype
== WLAN_SP_MESH_PEERING_CONFIRM
&& ie_len
!= 6) ||
1103 (ftype
== WLAN_SP_MESH_PEERING_CLOSE
&& ie_len
!= 6
1106 "Mesh plink: incorrect plink ie length %d %d\n",
1111 if (ftype
!= WLAN_SP_MESH_PEERING_CLOSE
&&
1112 (!elems
->mesh_id
|| !elems
->mesh_config
)) {
1113 mpl_dbg(sdata
, "Mesh plink: missing necessary ie\n");
1116 /* Note the lines below are correct, the llid in the frame is the plid
1117 * from the point of view of this host.
1119 plid
= get_unaligned_le16(PLINK_GET_LLID(elems
->peering
));
1120 if (ftype
== WLAN_SP_MESH_PEERING_CONFIRM
||
1121 (ftype
== WLAN_SP_MESH_PEERING_CLOSE
&& ie_len
== 8))
1122 llid
= get_unaligned_le16(PLINK_GET_PLID(elems
->peering
));
1124 /* WARNING: Only for sta pointer, is dropped & re-acquired */
1127 sta
= sta_info_get(sdata
, mgmt
->sa
);
1129 if (ftype
== WLAN_SP_MESH_PEERING_OPEN
&&
1130 !rssi_threshold_check(sdata
, sta
)) {
1131 mpl_dbg(sdata
, "Mesh plink: %pM does not meet rssi threshold\n",
1136 /* Now we will figure out the appropriate event... */
1137 event
= mesh_plink_get_event(sdata
, sta
, elems
, ftype
, llid
, plid
);
1139 if (event
== OPN_ACPT
) {
1141 /* allocate sta entry if necessary and update info */
1142 sta
= mesh_sta_info_get(sdata
, mgmt
->sa
, elems
);
1144 mpl_dbg(sdata
, "Mesh plink: failed to init peer!\n");
1147 sta
->mesh
->plid
= plid
;
1148 } else if (!sta
&& event
== OPN_RJCT
) {
1149 mesh_plink_frame_tx(sdata
, NULL
, WLAN_SP_MESH_PEERING_CLOSE
,
1151 WLAN_REASON_MESH_CONFIG
);
1153 } else if (!sta
|| event
== PLINK_UNDEFINED
) {
1154 /* something went wrong */
1158 if (event
== CNF_ACPT
) {
1159 /* 802.11-2012 13.3.7.2 - update plid on CNF if not set */
1160 if (!sta
->mesh
->plid
)
1161 sta
->mesh
->plid
= plid
;
1163 sta
->mesh
->aid
= get_unaligned_le16(PLINK_CNF_AID(mgmt
));
1166 changed
|= mesh_plink_fsm(sdata
, sta
, event
);
1172 ieee80211_mbss_info_change_notify(sdata
, changed
);
1175 void mesh_rx_plink_frame(struct ieee80211_sub_if_data
*sdata
,
1176 struct ieee80211_mgmt
*mgmt
, size_t len
,
1177 struct ieee80211_rx_status
*rx_status
)
1179 struct ieee802_11_elems elems
;
1183 /* need action_code, aux */
1184 if (len
< IEEE80211_MIN_ACTION_SIZE
+ 3)
1187 if (sdata
->u
.mesh
.user_mpm
)
1188 /* userspace must register for these */
1191 if (is_multicast_ether_addr(mgmt
->da
)) {
1193 "Mesh plink: ignore frame from multicast address\n");
1197 baseaddr
= mgmt
->u
.action
.u
.self_prot
.variable
;
1198 baselen
= (u8
*) mgmt
->u
.action
.u
.self_prot
.variable
- (u8
*) mgmt
;
1199 if (mgmt
->u
.action
.u
.self_prot
.action_code
==
1200 WLAN_SP_MESH_PEERING_CONFIRM
) {
1207 ieee802_11_parse_elems(baseaddr
, len
- baselen
, true, &elems
);
1208 mesh_process_plink_frame(sdata
, mgmt
, &elems
);