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 "ieee80211_i.h"
16 #define PLINK_GET_LLID(p) (p + 2)
17 #define PLINK_GET_PLID(p) (p + 4)
19 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
20 jiffies + HZ * t / 1000))
22 /* We only need a valid sta if user configured a minimum rssi_threshold. */
23 #define rssi_threshold_check(sta, sdata) \
24 (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\
25 (sta && (s8) -ewma_read(&sta->avg_signal) > \
26 sdata->u.mesh.mshcfg.rssi_threshold))
40 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
41 enum ieee80211_self_protected_actioncode action,
42 u8 *da, __le16 llid, __le16 plid, __le16 reason);
45 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
47 * @sta: mesh peer link to restart
49 * Locking: this function must be called holding sta->lock
51 static inline void mesh_plink_fsm_restart(struct sta_info *sta)
53 sta->plink_state = NL80211_PLINK_LISTEN;
54 sta->llid = sta->plid = sta->reason = 0;
55 sta->plink_retries = 0;
59 * mesh_set_short_slot_time - enable / disable ERP short slot time.
61 * The standard indirectly mandates mesh STAs to turn off short slot time by
62 * disallowing advertising this (802.11-2012 8.4.1.4), but that doesn't mean we
63 * can't be sneaky about it. Enable short slot time if all mesh STAs in the
64 * MBSS support ERP rates.
66 * Returns BSS_CHANGED_ERP_SLOT or 0 for no change.
68 static u32 mesh_set_short_slot_time(struct ieee80211_sub_if_data *sdata)
70 struct ieee80211_local *local = sdata->local;
71 enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
72 struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
74 u32 erp_rates = 0, changed = 0;
76 bool short_slot = false;
78 if (band == IEEE80211_BAND_5GHZ) {
79 /* (IEEE 802.11-2012 19.4.5) */
82 } else if (band != IEEE80211_BAND_2GHZ ||
83 (band == IEEE80211_BAND_2GHZ &&
84 local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
87 for (i = 0; i < sband->n_bitrates; i++)
88 if (sband->bitrates[i].flags & IEEE80211_RATE_ERP_G)
95 list_for_each_entry_rcu(sta, &local->sta_list, list) {
96 if (sdata != sta->sdata ||
97 sta->plink_state != NL80211_PLINK_ESTAB)
101 if (erp_rates & sta->sta.supp_rates[band])
109 if (sdata->vif.bss_conf.use_short_slot != short_slot) {
110 sdata->vif.bss_conf.use_short_slot = short_slot;
111 changed = BSS_CHANGED_ERP_SLOT;
112 mpl_dbg(sdata, "mesh_plink %pM: ERP short slot time %d\n",
113 sdata->vif.addr, short_slot);
119 * mesh_set_ht_prot_mode - set correct HT protection mode
121 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
122 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
123 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
124 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
125 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
126 * HT20 peer is present. Otherwise no-protection mode is selected.
128 static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
130 struct ieee80211_local *local = sdata->local;
131 struct sta_info *sta;
134 bool non_ht_sta = false, ht20_sta = false;
136 if (sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
140 list_for_each_entry_rcu(sta, &local->sta_list, list) {
141 if (sdata != sta->sdata ||
142 sta->plink_state != NL80211_PLINK_ESTAB)
145 switch (sta->ch_width) {
146 case NL80211_CHAN_WIDTH_20_NOHT:
148 "mesh_plink %pM: nonHT sta (%pM) is present\n",
149 sdata->vif.addr, sta->sta.addr);
152 case NL80211_CHAN_WIDTH_20:
154 "mesh_plink %pM: HT20 sta (%pM) is present\n",
155 sdata->vif.addr, sta->sta.addr);
165 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
167 sdata->vif.bss_conf.chandef.width > NL80211_CHAN_WIDTH_20)
168 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
170 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
172 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
173 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
174 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode;
175 changed = BSS_CHANGED_HT;
177 "mesh_plink %pM: protection mode changed to %d\n",
178 sdata->vif.addr, ht_opmode);
185 * __mesh_plink_deactivate - deactivate mesh peer link
187 * @sta: mesh peer link to deactivate
189 * All mesh paths with this peer as next hop will be flushed
190 * Returns beacon changed flag if the beacon content changed.
192 * Locking: the caller must hold sta->lock
194 static u32 __mesh_plink_deactivate(struct sta_info *sta)
196 struct ieee80211_sub_if_data *sdata = sta->sdata;
199 if (sta->plink_state == NL80211_PLINK_ESTAB)
200 changed = mesh_plink_dec_estab_count(sdata);
201 sta->plink_state = NL80211_PLINK_BLOCKED;
202 mesh_path_flush_by_nexthop(sta);
204 ieee80211_mps_sta_status_update(sta);
205 ieee80211_mps_local_status_update(sdata);
211 * mesh_plink_deactivate - deactivate mesh peer link
213 * @sta: mesh peer link to deactivate
215 * All mesh paths with this peer as next hop will be flushed
217 u32 mesh_plink_deactivate(struct sta_info *sta)
219 struct ieee80211_sub_if_data *sdata = sta->sdata;
222 spin_lock_bh(&sta->lock);
223 changed = __mesh_plink_deactivate(sta);
224 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
225 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
226 sta->sta.addr, sta->llid, sta->plid,
228 spin_unlock_bh(&sta->lock);
233 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
234 enum ieee80211_self_protected_actioncode action,
235 u8 *da, __le16 llid, __le16 plid, __le16 reason) {
236 struct ieee80211_local *local = sdata->local;
238 struct ieee80211_tx_info *info;
239 struct ieee80211_mgmt *mgmt;
240 bool include_plid = false;
241 u16 peering_proto = 0;
243 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) +
244 sizeof(mgmt->u.action.u.self_prot);
247 skb = dev_alloc_skb(local->tx_headroom +
249 2 + /* capability info */
251 2 + 8 + /* supported rates */
252 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
253 2 + sdata->u.mesh.mesh_id_len +
254 2 + sizeof(struct ieee80211_meshconf_ie) +
255 2 + sizeof(struct ieee80211_ht_cap) +
256 2 + sizeof(struct ieee80211_ht_operation) +
257 2 + 8 + /* peering IE */
258 sdata->u.mesh.ie_len);
261 info = IEEE80211_SKB_CB(skb);
262 skb_reserve(skb, local->tx_headroom);
263 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
264 memset(mgmt, 0, hdr_len);
265 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
266 IEEE80211_STYPE_ACTION);
267 memcpy(mgmt->da, da, ETH_ALEN);
268 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
269 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
270 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
271 mgmt->u.action.u.self_prot.action_code = action;
273 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
274 enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
276 /* capability info */
277 pos = skb_put(skb, 2);
279 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
281 pos = skb_put(skb, 2);
282 memcpy(pos + 2, &plid, 2);
284 if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
285 ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
286 mesh_add_rsn_ie(skb, sdata) ||
287 mesh_add_meshid_ie(skb, sdata) ||
288 mesh_add_meshconf_ie(skb, sdata))
290 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
291 info->flags |= IEEE80211_TX_CTL_NO_ACK;
292 if (mesh_add_meshid_ie(skb, sdata))
296 /* Add Mesh Peering Management element */
298 case WLAN_SP_MESH_PEERING_OPEN:
300 case WLAN_SP_MESH_PEERING_CONFIRM:
304 case WLAN_SP_MESH_PEERING_CLOSE:
309 ie_len += 2; /* reason code */
316 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
319 pos = skb_put(skb, 2 + ie_len);
320 *pos++ = WLAN_EID_PEER_MGMT;
322 memcpy(pos, &peering_proto, 2);
324 memcpy(pos, &llid, 2);
327 memcpy(pos, &plid, 2);
330 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
331 memcpy(pos, &reason, 2);
335 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
336 if (mesh_add_ht_cap_ie(skb, sdata) ||
337 mesh_add_ht_oper_ie(skb, sdata))
341 if (mesh_add_vendor_ies(skb, sdata))
344 ieee80211_tx_skb(sdata, skb);
351 static void mesh_sta_info_init(struct ieee80211_sub_if_data *sdata,
352 struct sta_info *sta,
353 struct ieee802_11_elems *elems, bool insert)
355 struct ieee80211_local *local = sdata->local;
356 enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
357 struct ieee80211_supported_band *sband;
358 u32 rates, basic_rates = 0, changed = 0;
360 sband = local->hw.wiphy->bands[band];
361 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates);
363 spin_lock_bh(&sta->lock);
364 sta->last_rx = jiffies;
366 /* rates and capabilities don't change during peering */
367 if (sta->plink_state == NL80211_PLINK_ESTAB)
370 if (sta->sta.supp_rates[band] != rates)
371 changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
372 sta->sta.supp_rates[band] = rates;
373 if (elems->ht_cap_elem &&
374 sdata->vif.bss_conf.chandef.width != NL80211_CHAN_WIDTH_20_NOHT)
375 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
379 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap));
381 if (elems->ht_operation) {
382 struct cfg80211_chan_def chandef;
384 if (!(elems->ht_operation->ht_param &
385 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
386 sta->sta.ht_cap.cap &=
387 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
388 ieee80211_ht_oper_to_chandef(sdata->vif.bss_conf.chandef.chan,
389 elems->ht_operation, &chandef);
390 if (sta->ch_width != chandef.width)
391 changed |= IEEE80211_RC_BW_CHANGED;
392 sta->ch_width = chandef.width;
396 rate_control_rate_init(sta);
398 rate_control_rate_update(local, sband, sta, changed);
400 spin_unlock_bh(&sta->lock);
403 static struct sta_info *
404 __mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *hw_addr)
406 struct sta_info *sta;
408 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
411 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
415 sta->plink_state = NL80211_PLINK_LISTEN;
416 init_timer(&sta->plink_timer);
418 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
419 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
420 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
422 set_sta_flag(sta, WLAN_STA_WME);
427 static struct sta_info *
428 mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *addr,
429 struct ieee802_11_elems *elems)
431 struct sta_info *sta = NULL;
433 /* Userspace handles peer allocation when security is enabled */
434 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED)
435 cfg80211_notify_new_peer_candidate(sdata->dev, addr,
440 sta = __mesh_sta_info_alloc(sdata, addr);
446 * mesh_sta_info_get - return mesh sta info entry for @addr.
448 * @sdata: local meshif
449 * @addr: peer's address
450 * @elems: IEs from beacon or mesh peering frame.
452 * Return existing or newly allocated sta_info under RCU read lock.
453 * (re)initialize with given IEs.
455 static struct sta_info *
456 mesh_sta_info_get(struct ieee80211_sub_if_data *sdata,
457 u8 *addr, struct ieee802_11_elems *elems) __acquires(RCU)
459 struct sta_info *sta = NULL;
462 sta = sta_info_get(sdata, addr);
464 mesh_sta_info_init(sdata, sta, elems, false);
467 /* can't run atomic */
468 sta = mesh_sta_info_alloc(sdata, addr, elems);
474 mesh_sta_info_init(sdata, sta, elems, true);
476 if (sta_info_insert_rcu(sta))
484 * mesh_neighbour_update - update or initialize new mesh neighbor.
486 * @sdata: local meshif
487 * @addr: peer's address
488 * @elems: IEs from beacon or mesh peering frame
490 * Initiates peering if appropriate.
492 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
494 struct ieee802_11_elems *elems)
496 struct sta_info *sta;
498 sta = mesh_sta_info_get(sdata, hw_addr, elems);
502 if (mesh_peer_accepts_plinks(elems) &&
503 sta->plink_state == NL80211_PLINK_LISTEN &&
504 sdata->u.mesh.accepting_plinks &&
505 sdata->u.mesh.mshcfg.auto_open_plinks &&
506 rssi_threshold_check(sta, sdata))
507 mesh_plink_open(sta);
509 ieee80211_mps_frame_release(sta, elems);
514 static void mesh_plink_timer(unsigned long data)
516 struct sta_info *sta;
517 __le16 llid, plid, reason;
518 struct ieee80211_sub_if_data *sdata;
519 struct mesh_config *mshcfg;
522 * This STA is valid because sta_info_destroy() will
523 * del_timer_sync() this timer after having made sure
524 * it cannot be readded (by deleting the plink.)
526 sta = (struct sta_info *) data;
528 if (sta->sdata->local->quiescing) {
529 sta->plink_timer_was_running = true;
533 spin_lock_bh(&sta->lock);
534 if (sta->ignore_plink_timer) {
535 sta->ignore_plink_timer = false;
536 spin_unlock_bh(&sta->lock);
540 "Mesh plink timer for %pM fired on state %d\n",
541 sta->sta.addr, sta->plink_state);
546 mshcfg = &sdata->u.mesh.mshcfg;
548 switch (sta->plink_state) {
549 case NL80211_PLINK_OPN_RCVD:
550 case NL80211_PLINK_OPN_SNT:
552 if (sta->plink_retries < mshcfg->dot11MeshMaxRetries) {
555 "Mesh plink for %pM (retry, timeout): %d %d\n",
556 sta->sta.addr, sta->plink_retries,
558 get_random_bytes(&rand, sizeof(u32));
559 sta->plink_timeout = sta->plink_timeout +
560 rand % sta->plink_timeout;
561 ++sta->plink_retries;
562 mod_plink_timer(sta, sta->plink_timeout);
563 spin_unlock_bh(&sta->lock);
564 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
565 sta->sta.addr, llid, 0, 0);
568 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
569 /* fall through on else */
570 case NL80211_PLINK_CNF_RCVD:
573 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
574 sta->plink_state = NL80211_PLINK_HOLDING;
575 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
576 spin_unlock_bh(&sta->lock);
577 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
578 sta->sta.addr, llid, plid, reason);
580 case NL80211_PLINK_HOLDING:
582 del_timer(&sta->plink_timer);
583 mesh_plink_fsm_restart(sta);
584 spin_unlock_bh(&sta->lock);
587 spin_unlock_bh(&sta->lock);
593 void mesh_plink_quiesce(struct sta_info *sta)
595 if (!ieee80211_vif_is_mesh(&sta->sdata->vif))
598 /* no kernel mesh sta timers have been initialized */
599 if (sta->sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
602 if (del_timer_sync(&sta->plink_timer))
603 sta->plink_timer_was_running = true;
606 void mesh_plink_restart(struct sta_info *sta)
608 if (sta->plink_timer_was_running) {
609 add_timer(&sta->plink_timer);
610 sta->plink_timer_was_running = false;
615 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
617 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
618 sta->plink_timer.data = (unsigned long) sta;
619 sta->plink_timer.function = mesh_plink_timer;
620 sta->plink_timeout = timeout;
621 add_timer(&sta->plink_timer);
624 int mesh_plink_open(struct sta_info *sta)
627 struct ieee80211_sub_if_data *sdata = sta->sdata;
629 if (!test_sta_flag(sta, WLAN_STA_AUTH))
632 spin_lock_bh(&sta->lock);
633 get_random_bytes(&llid, 2);
635 if (sta->plink_state != NL80211_PLINK_LISTEN &&
636 sta->plink_state != NL80211_PLINK_BLOCKED) {
637 spin_unlock_bh(&sta->lock);
640 sta->plink_state = NL80211_PLINK_OPN_SNT;
641 mesh_plink_timer_set(sta, sdata->u.mesh.mshcfg.dot11MeshRetryTimeout);
642 spin_unlock_bh(&sta->lock);
644 "Mesh plink: starting establishment with %pM\n",
647 /* set the non-peer mode to active during peering */
648 ieee80211_mps_local_status_update(sdata);
650 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
651 sta->sta.addr, llid, 0, 0);
654 void mesh_plink_block(struct sta_info *sta)
656 struct ieee80211_sub_if_data *sdata = sta->sdata;
659 spin_lock_bh(&sta->lock);
660 changed = __mesh_plink_deactivate(sta);
661 sta->plink_state = NL80211_PLINK_BLOCKED;
662 spin_unlock_bh(&sta->lock);
664 ieee80211_bss_info_change_notify(sdata, changed);
668 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
669 size_t len, struct ieee80211_rx_status *rx_status)
671 struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
672 struct ieee802_11_elems elems;
673 struct sta_info *sta;
674 enum plink_event event;
675 enum ieee80211_self_protected_actioncode ftype;
677 bool matches_local = true;
681 __le16 plid, llid, reason;
682 static const char *mplstates[] = {
683 [NL80211_PLINK_LISTEN] = "LISTEN",
684 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
685 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
686 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
687 [NL80211_PLINK_ESTAB] = "ESTAB",
688 [NL80211_PLINK_HOLDING] = "HOLDING",
689 [NL80211_PLINK_BLOCKED] = "BLOCKED"
692 /* need action_code, aux */
693 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
696 if (is_multicast_ether_addr(mgmt->da)) {
698 "Mesh plink: ignore frame from multicast address\n");
702 baseaddr = mgmt->u.action.u.self_prot.variable;
703 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
704 if (mgmt->u.action.u.self_prot.action_code ==
705 WLAN_SP_MESH_PEERING_CONFIRM) {
709 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
710 if (!elems.peering) {
712 "Mesh plink: missing necessary peer link ie\n");
716 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
718 "Mesh plink: can't establish link with secure peer\n");
722 ftype = mgmt->u.action.u.self_prot.action_code;
723 ie_len = elems.peering_len;
724 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
725 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
726 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
729 "Mesh plink: incorrect plink ie length %d %d\n",
734 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
735 (!elems.mesh_id || !elems.mesh_config)) {
736 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
739 /* Note the lines below are correct, the llid in the frame is the plid
740 * from the point of view of this host.
742 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
743 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
744 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
745 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
747 /* WARNING: Only for sta pointer, is dropped & re-acquired */
750 sta = sta_info_get(sdata, mgmt->sa);
751 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
752 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
757 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
758 !rssi_threshold_check(sta, sdata)) {
759 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
765 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
766 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
771 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
776 /* Now we will figure out the appropriate event... */
777 event = PLINK_UNDEFINED;
778 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
779 !mesh_matches_local(sdata, &elems)) {
780 matches_local = false;
782 case WLAN_SP_MESH_PEERING_OPEN:
785 case WLAN_SP_MESH_PEERING_CONFIRM:
793 if (!sta && !matches_local) {
795 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
797 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
798 mgmt->sa, llid, plid, reason);
801 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
802 if (!mesh_plink_free_count(sdata)) {
803 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
808 } else if (matches_local) {
810 case WLAN_SP_MESH_PEERING_OPEN:
811 if (!mesh_plink_free_count(sdata) ||
812 (sta->plid && sta->plid != plid))
817 case WLAN_SP_MESH_PEERING_CONFIRM:
818 if (!mesh_plink_free_count(sdata) ||
819 (sta->llid != llid || sta->plid != plid))
824 case WLAN_SP_MESH_PEERING_CLOSE:
825 if (sta->plink_state == NL80211_PLINK_ESTAB)
826 /* Do not check for llid or plid. This does not
827 * follow the standard but since multiple plinks
828 * per sta are not supported, it is necessary in
829 * order to avoid a livelock when MP A sees an
830 * establish peer link to MP B but MP B does not
831 * see it. This can be caused by a timeout in
832 * B's peer link establishment or B beign
836 else if (sta->plid != plid)
838 else if (ie_len == 7 && sta->llid != llid)
844 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
850 if (event == OPN_ACPT) {
852 /* allocate sta entry if necessary and update info */
853 sta = mesh_sta_info_get(sdata, mgmt->sa, &elems);
855 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
862 "Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
863 mgmt->sa, mplstates[sta->plink_state],
864 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
867 spin_lock_bh(&sta->lock);
868 switch (sta->plink_state) {
869 /* spin_unlock as soon as state is updated at each case */
870 case NL80211_PLINK_LISTEN:
873 mesh_plink_fsm_restart(sta);
874 spin_unlock_bh(&sta->lock);
877 sta->plink_state = NL80211_PLINK_OPN_RCVD;
879 get_random_bytes(&llid, 2);
881 mesh_plink_timer_set(sta,
882 mshcfg->dot11MeshRetryTimeout);
884 /* set the non-peer mode to active during peering */
885 ieee80211_mps_local_status_update(sdata);
887 spin_unlock_bh(&sta->lock);
888 mesh_plink_frame_tx(sdata,
889 WLAN_SP_MESH_PEERING_OPEN,
890 sta->sta.addr, llid, 0, 0);
891 mesh_plink_frame_tx(sdata,
892 WLAN_SP_MESH_PEERING_CONFIRM,
893 sta->sta.addr, llid, plid, 0);
896 spin_unlock_bh(&sta->lock);
901 case NL80211_PLINK_OPN_SNT:
905 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
908 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
909 sta->reason = reason;
910 sta->plink_state = NL80211_PLINK_HOLDING;
911 if (!mod_plink_timer(sta,
912 mshcfg->dot11MeshHoldingTimeout))
913 sta->ignore_plink_timer = true;
916 spin_unlock_bh(&sta->lock);
917 mesh_plink_frame_tx(sdata,
918 WLAN_SP_MESH_PEERING_CLOSE,
919 sta->sta.addr, llid, plid, reason);
922 /* retry timer is left untouched */
923 sta->plink_state = NL80211_PLINK_OPN_RCVD;
926 spin_unlock_bh(&sta->lock);
927 mesh_plink_frame_tx(sdata,
928 WLAN_SP_MESH_PEERING_CONFIRM,
929 sta->sta.addr, llid, plid, 0);
932 sta->plink_state = NL80211_PLINK_CNF_RCVD;
933 if (!mod_plink_timer(sta,
934 mshcfg->dot11MeshConfirmTimeout))
935 sta->ignore_plink_timer = true;
937 spin_unlock_bh(&sta->lock);
940 spin_unlock_bh(&sta->lock);
945 case NL80211_PLINK_OPN_RCVD:
949 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
952 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
953 sta->reason = reason;
954 sta->plink_state = NL80211_PLINK_HOLDING;
955 if (!mod_plink_timer(sta,
956 mshcfg->dot11MeshHoldingTimeout))
957 sta->ignore_plink_timer = true;
960 spin_unlock_bh(&sta->lock);
961 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
962 sta->sta.addr, llid, plid, reason);
966 spin_unlock_bh(&sta->lock);
967 mesh_plink_frame_tx(sdata,
968 WLAN_SP_MESH_PEERING_CONFIRM,
969 sta->sta.addr, llid, plid, 0);
972 del_timer(&sta->plink_timer);
973 sta->plink_state = NL80211_PLINK_ESTAB;
974 spin_unlock_bh(&sta->lock);
975 changed |= mesh_plink_inc_estab_count(sdata);
976 changed |= mesh_set_ht_prot_mode(sdata);
977 changed |= mesh_set_short_slot_time(sdata);
978 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
980 ieee80211_mps_sta_status_update(sta);
981 ieee80211_mps_set_sta_local_pm(sta,
985 spin_unlock_bh(&sta->lock);
990 case NL80211_PLINK_CNF_RCVD:
994 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
997 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
998 sta->reason = reason;
999 sta->plink_state = NL80211_PLINK_HOLDING;
1000 if (!mod_plink_timer(sta,
1001 mshcfg->dot11MeshHoldingTimeout))
1002 sta->ignore_plink_timer = true;
1005 spin_unlock_bh(&sta->lock);
1006 mesh_plink_frame_tx(sdata,
1007 WLAN_SP_MESH_PEERING_CLOSE,
1008 sta->sta.addr, llid, plid, reason);
1011 del_timer(&sta->plink_timer);
1012 sta->plink_state = NL80211_PLINK_ESTAB;
1013 spin_unlock_bh(&sta->lock);
1014 changed |= mesh_plink_inc_estab_count(sdata);
1015 changed |= mesh_set_ht_prot_mode(sdata);
1016 changed |= mesh_set_short_slot_time(sdata);
1017 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
1019 mesh_plink_frame_tx(sdata,
1020 WLAN_SP_MESH_PEERING_CONFIRM,
1021 sta->sta.addr, llid, plid, 0);
1022 ieee80211_mps_sta_status_update(sta);
1023 ieee80211_mps_set_sta_local_pm(sta,
1024 mshcfg->power_mode);
1027 spin_unlock_bh(&sta->lock);
1032 case NL80211_PLINK_ESTAB:
1035 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
1036 sta->reason = reason;
1037 changed |= __mesh_plink_deactivate(sta);
1038 sta->plink_state = NL80211_PLINK_HOLDING;
1040 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
1041 spin_unlock_bh(&sta->lock);
1042 changed |= mesh_set_ht_prot_mode(sdata);
1043 changed |= mesh_set_short_slot_time(sdata);
1044 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
1045 sta->sta.addr, llid, plid, reason);
1049 spin_unlock_bh(&sta->lock);
1050 mesh_plink_frame_tx(sdata,
1051 WLAN_SP_MESH_PEERING_CONFIRM,
1052 sta->sta.addr, llid, plid, 0);
1055 spin_unlock_bh(&sta->lock);
1059 case NL80211_PLINK_HOLDING:
1062 if (del_timer(&sta->plink_timer))
1063 sta->ignore_plink_timer = 1;
1064 mesh_plink_fsm_restart(sta);
1065 spin_unlock_bh(&sta->lock);
1072 reason = sta->reason;
1073 spin_unlock_bh(&sta->lock);
1074 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
1075 sta->sta.addr, llid, plid, reason);
1078 spin_unlock_bh(&sta->lock);
1082 /* should not get here, PLINK_BLOCKED is dealt with at the
1083 * beginning of the function
1085 spin_unlock_bh(&sta->lock);
1092 ieee80211_bss_info_change_notify(sdata, changed);