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_ht_prot_mode - set correct HT protection mode
61 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
62 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
63 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
64 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
65 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
66 * HT20 peer is present. Otherwise no-protection mode is selected.
68 static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
70 struct ieee80211_local *local = sdata->local;
74 bool non_ht_sta = false, ht20_sta = false;
76 if (sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
80 list_for_each_entry_rcu(sta, &local->sta_list, list) {
81 if (sdata != sta->sdata ||
82 sta->plink_state != NL80211_PLINK_ESTAB)
85 switch (sta->ch_width) {
86 case NL80211_CHAN_WIDTH_20_NOHT:
88 "mesh_plink %pM: nonHT sta (%pM) is present\n",
89 sdata->vif.addr, sta->sta.addr);
92 case NL80211_CHAN_WIDTH_20:
94 "mesh_plink %pM: HT20 sta (%pM) is present\n",
95 sdata->vif.addr, sta->sta.addr);
105 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
107 sdata->vif.bss_conf.chandef.width > NL80211_CHAN_WIDTH_20)
108 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
110 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
112 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
113 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
114 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode;
115 changed = BSS_CHANGED_HT;
117 "mesh_plink %pM: protection mode changed to %d\n",
118 sdata->vif.addr, ht_opmode);
125 * __mesh_plink_deactivate - deactivate mesh peer link
127 * @sta: mesh peer link to deactivate
129 * All mesh paths with this peer as next hop will be flushed
130 * Returns beacon changed flag if the beacon content changed.
132 * Locking: the caller must hold sta->lock
134 static u32 __mesh_plink_deactivate(struct sta_info *sta)
136 struct ieee80211_sub_if_data *sdata = sta->sdata;
139 if (sta->plink_state == NL80211_PLINK_ESTAB)
140 changed = mesh_plink_dec_estab_count(sdata);
141 sta->plink_state = NL80211_PLINK_BLOCKED;
142 mesh_path_flush_by_nexthop(sta);
148 * mesh_plink_deactivate - deactivate mesh peer link
150 * @sta: mesh peer link to deactivate
152 * All mesh paths with this peer as next hop will be flushed
154 void mesh_plink_deactivate(struct sta_info *sta)
156 struct ieee80211_sub_if_data *sdata = sta->sdata;
159 spin_lock_bh(&sta->lock);
160 changed = __mesh_plink_deactivate(sta);
161 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
162 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
163 sta->sta.addr, sta->llid, sta->plid,
165 spin_unlock_bh(&sta->lock);
167 ieee80211_bss_info_change_notify(sdata, changed);
170 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
171 enum ieee80211_self_protected_actioncode action,
172 u8 *da, __le16 llid, __le16 plid, __le16 reason) {
173 struct ieee80211_local *local = sdata->local;
175 struct ieee80211_tx_info *info;
176 struct ieee80211_mgmt *mgmt;
177 bool include_plid = false;
178 u16 peering_proto = 0;
180 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) +
181 sizeof(mgmt->u.action.u.self_prot);
184 skb = dev_alloc_skb(local->tx_headroom +
186 2 + /* capability info */
188 2 + 8 + /* supported rates */
189 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
190 2 + sdata->u.mesh.mesh_id_len +
191 2 + sizeof(struct ieee80211_meshconf_ie) +
192 2 + sizeof(struct ieee80211_ht_cap) +
193 2 + sizeof(struct ieee80211_ht_operation) +
194 2 + 8 + /* peering IE */
195 sdata->u.mesh.ie_len);
198 info = IEEE80211_SKB_CB(skb);
199 skb_reserve(skb, local->tx_headroom);
200 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
201 memset(mgmt, 0, hdr_len);
202 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
203 IEEE80211_STYPE_ACTION);
204 memcpy(mgmt->da, da, ETH_ALEN);
205 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
206 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
207 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
208 mgmt->u.action.u.self_prot.action_code = action;
210 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
211 enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
213 /* capability info */
214 pos = skb_put(skb, 2);
216 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
218 pos = skb_put(skb, 2);
219 memcpy(pos + 2, &plid, 2);
221 if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
222 ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
223 mesh_add_rsn_ie(skb, sdata) ||
224 mesh_add_meshid_ie(skb, sdata) ||
225 mesh_add_meshconf_ie(skb, sdata))
227 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
228 info->flags |= IEEE80211_TX_CTL_NO_ACK;
229 if (mesh_add_meshid_ie(skb, sdata))
233 /* Add Mesh Peering Management element */
235 case WLAN_SP_MESH_PEERING_OPEN:
237 case WLAN_SP_MESH_PEERING_CONFIRM:
241 case WLAN_SP_MESH_PEERING_CLOSE:
246 ie_len += 2; /* reason code */
253 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
256 pos = skb_put(skb, 2 + ie_len);
257 *pos++ = WLAN_EID_PEER_MGMT;
259 memcpy(pos, &peering_proto, 2);
261 memcpy(pos, &llid, 2);
264 memcpy(pos, &plid, 2);
267 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
268 memcpy(pos, &reason, 2);
272 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
273 if (mesh_add_ht_cap_ie(skb, sdata) ||
274 mesh_add_ht_oper_ie(skb, sdata))
278 if (mesh_add_vendor_ies(skb, sdata))
281 ieee80211_tx_skb(sdata, skb);
288 static void mesh_sta_info_init(struct ieee80211_sub_if_data *sdata,
289 struct sta_info *sta,
290 struct ieee802_11_elems *elems, bool insert)
292 struct ieee80211_local *local = sdata->local;
293 enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
294 struct ieee80211_supported_band *sband;
295 u32 rates, basic_rates = 0;
297 sband = local->hw.wiphy->bands[band];
298 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates);
300 spin_lock_bh(&sta->lock);
301 sta->last_rx = jiffies;
303 /* rates and capabilities don't change during peering */
304 if (sta->plink_state == NL80211_PLINK_ESTAB)
307 sta->sta.supp_rates[band] = rates;
308 if (elems->ht_cap_elem &&
309 sdata->vif.bss_conf.chandef.width != NL80211_CHAN_WIDTH_20_NOHT)
310 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
314 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap));
316 if (elems->ht_operation) {
317 struct cfg80211_chan_def chandef;
319 if (!(elems->ht_operation->ht_param &
320 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
321 sta->sta.ht_cap.cap &=
322 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
323 ieee80211_ht_oper_to_chandef(sdata->vif.bss_conf.chandef.chan,
324 elems->ht_operation, &chandef);
325 sta->ch_width = chandef.width;
329 rate_control_rate_init(sta);
331 spin_unlock_bh(&sta->lock);
334 static struct sta_info *
335 __mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *hw_addr)
337 struct sta_info *sta;
339 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
342 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
346 sta->plink_state = NL80211_PLINK_LISTEN;
347 init_timer(&sta->plink_timer);
349 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
350 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
351 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
353 set_sta_flag(sta, WLAN_STA_WME);
358 static struct sta_info *
359 mesh_sta_info_alloc(struct ieee80211_sub_if_data *sdata, u8 *addr,
360 struct ieee802_11_elems *elems)
362 struct sta_info *sta = NULL;
364 /* Userspace handles peer allocation when security is enabled */
365 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED)
366 cfg80211_notify_new_peer_candidate(sdata->dev, addr,
371 sta = __mesh_sta_info_alloc(sdata, addr);
377 * mesh_sta_info_get - return mesh sta info entry for @addr.
379 * @sdata: local meshif
380 * @addr: peer's address
381 * @elems: IEs from beacon or mesh peering frame.
383 * Return existing or newly allocated sta_info under RCU read lock.
384 * (re)initialize with given IEs.
386 static struct sta_info *
387 mesh_sta_info_get(struct ieee80211_sub_if_data *sdata,
388 u8 *addr, struct ieee802_11_elems *elems) __acquires(RCU)
390 struct sta_info *sta = NULL;
393 sta = sta_info_get(sdata, addr);
395 mesh_sta_info_init(sdata, sta, elems, false);
398 /* can't run atomic */
399 sta = mesh_sta_info_alloc(sdata, addr, elems);
405 if (sta_info_insert_rcu(sta))
413 * mesh_neighbour_update - update or initialize new mesh neighbor.
415 * @sdata: local meshif
416 * @addr: peer's address
417 * @elems: IEs from beacon or mesh peering frame
419 * Initiates peering if appropriate.
421 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
423 struct ieee802_11_elems *elems)
425 struct sta_info *sta;
427 sta = mesh_sta_info_get(sdata, hw_addr, elems);
431 if (mesh_peer_accepts_plinks(elems) &&
432 sta->plink_state == NL80211_PLINK_LISTEN &&
433 sdata->u.mesh.accepting_plinks &&
434 sdata->u.mesh.mshcfg.auto_open_plinks &&
435 rssi_threshold_check(sta, sdata))
436 mesh_plink_open(sta);
442 static void mesh_plink_timer(unsigned long data)
444 struct sta_info *sta;
445 __le16 llid, plid, reason;
446 struct ieee80211_sub_if_data *sdata;
447 struct mesh_config *mshcfg;
450 * This STA is valid because sta_info_destroy() will
451 * del_timer_sync() this timer after having made sure
452 * it cannot be readded (by deleting the plink.)
454 sta = (struct sta_info *) data;
456 if (sta->sdata->local->quiescing) {
457 sta->plink_timer_was_running = true;
461 spin_lock_bh(&sta->lock);
462 if (sta->ignore_plink_timer) {
463 sta->ignore_plink_timer = false;
464 spin_unlock_bh(&sta->lock);
468 "Mesh plink timer for %pM fired on state %d\n",
469 sta->sta.addr, sta->plink_state);
474 mshcfg = &sdata->u.mesh.mshcfg;
476 switch (sta->plink_state) {
477 case NL80211_PLINK_OPN_RCVD:
478 case NL80211_PLINK_OPN_SNT:
480 if (sta->plink_retries < mshcfg->dot11MeshMaxRetries) {
483 "Mesh plink for %pM (retry, timeout): %d %d\n",
484 sta->sta.addr, sta->plink_retries,
486 get_random_bytes(&rand, sizeof(u32));
487 sta->plink_timeout = sta->plink_timeout +
488 rand % sta->plink_timeout;
489 ++sta->plink_retries;
490 mod_plink_timer(sta, sta->plink_timeout);
491 spin_unlock_bh(&sta->lock);
492 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
493 sta->sta.addr, llid, 0, 0);
496 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
497 /* fall through on else */
498 case NL80211_PLINK_CNF_RCVD:
501 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
502 sta->plink_state = NL80211_PLINK_HOLDING;
503 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
504 spin_unlock_bh(&sta->lock);
505 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
506 sta->sta.addr, llid, plid, reason);
508 case NL80211_PLINK_HOLDING:
510 del_timer(&sta->plink_timer);
511 mesh_plink_fsm_restart(sta);
512 spin_unlock_bh(&sta->lock);
515 spin_unlock_bh(&sta->lock);
521 void mesh_plink_quiesce(struct sta_info *sta)
523 if (del_timer_sync(&sta->plink_timer))
524 sta->plink_timer_was_running = true;
527 void mesh_plink_restart(struct sta_info *sta)
529 if (sta->plink_timer_was_running) {
530 add_timer(&sta->plink_timer);
531 sta->plink_timer_was_running = false;
536 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
538 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
539 sta->plink_timer.data = (unsigned long) sta;
540 sta->plink_timer.function = mesh_plink_timer;
541 sta->plink_timeout = timeout;
542 add_timer(&sta->plink_timer);
545 int mesh_plink_open(struct sta_info *sta)
548 struct ieee80211_sub_if_data *sdata = sta->sdata;
550 if (!test_sta_flag(sta, WLAN_STA_AUTH))
553 spin_lock_bh(&sta->lock);
554 get_random_bytes(&llid, 2);
556 if (sta->plink_state != NL80211_PLINK_LISTEN &&
557 sta->plink_state != NL80211_PLINK_BLOCKED) {
558 spin_unlock_bh(&sta->lock);
561 sta->plink_state = NL80211_PLINK_OPN_SNT;
562 mesh_plink_timer_set(sta, sdata->u.mesh.mshcfg.dot11MeshRetryTimeout);
563 spin_unlock_bh(&sta->lock);
565 "Mesh plink: starting establishment with %pM\n",
568 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
569 sta->sta.addr, llid, 0, 0);
572 void mesh_plink_block(struct sta_info *sta)
574 struct ieee80211_sub_if_data *sdata = sta->sdata;
577 spin_lock_bh(&sta->lock);
578 changed = __mesh_plink_deactivate(sta);
579 sta->plink_state = NL80211_PLINK_BLOCKED;
580 spin_unlock_bh(&sta->lock);
582 ieee80211_bss_info_change_notify(sdata, changed);
586 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
587 size_t len, struct ieee80211_rx_status *rx_status)
589 struct mesh_config *mshcfg = &sdata->u.mesh.mshcfg;
590 struct ieee802_11_elems elems;
591 struct sta_info *sta;
592 enum plink_event event;
593 enum ieee80211_self_protected_actioncode ftype;
595 bool matches_local = true;
599 __le16 plid, llid, reason;
600 static const char *mplstates[] = {
601 [NL80211_PLINK_LISTEN] = "LISTEN",
602 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
603 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
604 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
605 [NL80211_PLINK_ESTAB] = "ESTAB",
606 [NL80211_PLINK_HOLDING] = "HOLDING",
607 [NL80211_PLINK_BLOCKED] = "BLOCKED"
610 /* need action_code, aux */
611 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
614 if (is_multicast_ether_addr(mgmt->da)) {
616 "Mesh plink: ignore frame from multicast address\n");
620 baseaddr = mgmt->u.action.u.self_prot.variable;
621 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
622 if (mgmt->u.action.u.self_prot.action_code ==
623 WLAN_SP_MESH_PEERING_CONFIRM) {
627 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
628 if (!elems.peering) {
630 "Mesh plink: missing necessary peer link ie\n");
634 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
636 "Mesh plink: can't establish link with secure peer\n");
640 ftype = mgmt->u.action.u.self_prot.action_code;
641 ie_len = elems.peering_len;
642 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
643 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
644 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
647 "Mesh plink: incorrect plink ie length %d %d\n",
652 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
653 (!elems.mesh_id || !elems.mesh_config)) {
654 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
657 /* Note the lines below are correct, the llid in the frame is the plid
658 * from the point of view of this host.
660 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
661 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
662 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
663 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
665 /* WARNING: Only for sta pointer, is dropped & re-acquired */
668 sta = sta_info_get(sdata, mgmt->sa);
669 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
670 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
675 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
676 !rssi_threshold_check(sta, sdata)) {
677 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
683 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
684 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
689 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
694 /* Now we will figure out the appropriate event... */
695 event = PLINK_UNDEFINED;
696 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
697 !mesh_matches_local(sdata, &elems)) {
698 matches_local = false;
700 case WLAN_SP_MESH_PEERING_OPEN:
703 case WLAN_SP_MESH_PEERING_CONFIRM:
711 if (!sta && !matches_local) {
713 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
715 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
716 mgmt->sa, llid, plid, reason);
719 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
720 if (!mesh_plink_free_count(sdata)) {
721 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
726 } else if (matches_local) {
728 case WLAN_SP_MESH_PEERING_OPEN:
729 if (!mesh_plink_free_count(sdata) ||
730 (sta->plid && sta->plid != plid))
735 case WLAN_SP_MESH_PEERING_CONFIRM:
736 if (!mesh_plink_free_count(sdata) ||
737 (sta->llid != llid || sta->plid != plid))
742 case WLAN_SP_MESH_PEERING_CLOSE:
743 if (sta->plink_state == NL80211_PLINK_ESTAB)
744 /* Do not check for llid or plid. This does not
745 * follow the standard but since multiple plinks
746 * per sta are not supported, it is necessary in
747 * order to avoid a livelock when MP A sees an
748 * establish peer link to MP B but MP B does not
749 * see it. This can be caused by a timeout in
750 * B's peer link establishment or B beign
754 else if (sta->plid != plid)
756 else if (ie_len == 7 && sta->llid != llid)
762 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
768 if (event == OPN_ACPT) {
770 /* allocate sta entry if necessary and update info */
771 sta = mesh_sta_info_get(sdata, mgmt->sa, &elems);
773 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
780 "Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
781 mgmt->sa, mplstates[sta->plink_state],
782 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
785 spin_lock_bh(&sta->lock);
786 switch (sta->plink_state) {
787 /* spin_unlock as soon as state is updated at each case */
788 case NL80211_PLINK_LISTEN:
791 mesh_plink_fsm_restart(sta);
792 spin_unlock_bh(&sta->lock);
795 sta->plink_state = NL80211_PLINK_OPN_RCVD;
797 get_random_bytes(&llid, 2);
799 mesh_plink_timer_set(sta,
800 mshcfg->dot11MeshRetryTimeout);
801 spin_unlock_bh(&sta->lock);
802 mesh_plink_frame_tx(sdata,
803 WLAN_SP_MESH_PEERING_OPEN,
804 sta->sta.addr, llid, 0, 0);
805 mesh_plink_frame_tx(sdata,
806 WLAN_SP_MESH_PEERING_CONFIRM,
807 sta->sta.addr, llid, plid, 0);
810 spin_unlock_bh(&sta->lock);
815 case NL80211_PLINK_OPN_SNT:
819 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
822 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
823 sta->reason = reason;
824 sta->plink_state = NL80211_PLINK_HOLDING;
825 if (!mod_plink_timer(sta,
826 mshcfg->dot11MeshHoldingTimeout))
827 sta->ignore_plink_timer = true;
830 spin_unlock_bh(&sta->lock);
831 mesh_plink_frame_tx(sdata,
832 WLAN_SP_MESH_PEERING_CLOSE,
833 sta->sta.addr, llid, plid, reason);
836 /* retry timer is left untouched */
837 sta->plink_state = NL80211_PLINK_OPN_RCVD;
840 spin_unlock_bh(&sta->lock);
841 mesh_plink_frame_tx(sdata,
842 WLAN_SP_MESH_PEERING_CONFIRM,
843 sta->sta.addr, llid, plid, 0);
846 sta->plink_state = NL80211_PLINK_CNF_RCVD;
847 if (!mod_plink_timer(sta,
848 mshcfg->dot11MeshConfirmTimeout))
849 sta->ignore_plink_timer = true;
851 spin_unlock_bh(&sta->lock);
854 spin_unlock_bh(&sta->lock);
859 case NL80211_PLINK_OPN_RCVD:
863 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
866 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
867 sta->reason = reason;
868 sta->plink_state = NL80211_PLINK_HOLDING;
869 if (!mod_plink_timer(sta,
870 mshcfg->dot11MeshHoldingTimeout))
871 sta->ignore_plink_timer = true;
874 spin_unlock_bh(&sta->lock);
875 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
876 sta->sta.addr, llid, plid, reason);
880 spin_unlock_bh(&sta->lock);
881 mesh_plink_frame_tx(sdata,
882 WLAN_SP_MESH_PEERING_CONFIRM,
883 sta->sta.addr, llid, plid, 0);
886 del_timer(&sta->plink_timer);
887 sta->plink_state = NL80211_PLINK_ESTAB;
888 spin_unlock_bh(&sta->lock);
889 changed |= mesh_plink_inc_estab_count(sdata);
890 changed |= mesh_set_ht_prot_mode(sdata);
891 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
895 spin_unlock_bh(&sta->lock);
900 case NL80211_PLINK_CNF_RCVD:
904 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
907 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
908 sta->reason = reason;
909 sta->plink_state = NL80211_PLINK_HOLDING;
910 if (!mod_plink_timer(sta,
911 mshcfg->dot11MeshHoldingTimeout))
912 sta->ignore_plink_timer = true;
915 spin_unlock_bh(&sta->lock);
916 mesh_plink_frame_tx(sdata,
917 WLAN_SP_MESH_PEERING_CLOSE,
918 sta->sta.addr, llid, plid, reason);
921 del_timer(&sta->plink_timer);
922 sta->plink_state = NL80211_PLINK_ESTAB;
923 spin_unlock_bh(&sta->lock);
924 changed |= mesh_plink_inc_estab_count(sdata);
925 changed |= mesh_set_ht_prot_mode(sdata);
926 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
928 mesh_plink_frame_tx(sdata,
929 WLAN_SP_MESH_PEERING_CONFIRM,
930 sta->sta.addr, llid, plid, 0);
933 spin_unlock_bh(&sta->lock);
938 case NL80211_PLINK_ESTAB:
941 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
942 sta->reason = reason;
943 changed |= __mesh_plink_deactivate(sta);
944 sta->plink_state = NL80211_PLINK_HOLDING;
946 mod_plink_timer(sta, mshcfg->dot11MeshHoldingTimeout);
947 spin_unlock_bh(&sta->lock);
948 changed |= mesh_set_ht_prot_mode(sdata);
949 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
950 sta->sta.addr, llid, plid, reason);
954 spin_unlock_bh(&sta->lock);
955 mesh_plink_frame_tx(sdata,
956 WLAN_SP_MESH_PEERING_CONFIRM,
957 sta->sta.addr, llid, plid, 0);
960 spin_unlock_bh(&sta->lock);
964 case NL80211_PLINK_HOLDING:
967 if (del_timer(&sta->plink_timer))
968 sta->ignore_plink_timer = 1;
969 mesh_plink_fsm_restart(sta);
970 spin_unlock_bh(&sta->lock);
977 reason = sta->reason;
978 spin_unlock_bh(&sta->lock);
979 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
980 sta->sta.addr, llid, plid, reason);
983 spin_unlock_bh(&sta->lock);
987 /* should not get here, PLINK_BLOCKED is dealt with at the
988 * beginning of the function
990 spin_unlock_bh(&sta->lock);
997 ieee80211_bss_info_change_notify(sdata, changed);