Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 9385d04f2872057a2029901190391fe192b18693

Authored by Chun-Yeow Yeoh
Committed by Johannes Berg
1 parent 5d8e4237d2
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

mac80211: allow re-open the blocked peer link in mesh 

Peer link which is blocked using the "iw mesh0 station
set <MAC addr> plink_action block" is previously not able
to re-open using "iw mesh0 station set <MAC addr>
plink_action open". This patch is intended to solve this.

If the station plink state remains at OPN_SNT once open,
try block and open again should solve this problem.

Signed-off-by: Chun-Yeow Yeoh <yeohchunyeow@gmail.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>

Showing 1 changed file with 2 additions and 1 deletions Inline Diff

net/mac80211/mesh_plink.c
Diff comments   View file @ 9385d04
1 /* 1 /*
2 * Copyright (c) 2008, 2009 open80211s Ltd. 2 * Copyright (c) 2008, 2009 open80211s Ltd.
3 * Author: Luis Carlos Cobo <luisca@cozybit.com> 3 * Author: Luis Carlos Cobo <luisca@cozybit.com>
4 * 4 *
5 * This program is free software; you can redistribute it and/or modify 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 6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation. 7 * published by the Free Software Foundation.
8 */ 8 */
9 #include <linux/gfp.h> 9 #include <linux/gfp.h>
10 #include <linux/kernel.h> 10 #include <linux/kernel.h>
11 #include <linux/random.h> 11 #include <linux/random.h>
12 #include "ieee80211_i.h" 12 #include "ieee80211_i.h"
13 #include "rate.h" 13 #include "rate.h"
14 #include "mesh.h" 14 #include "mesh.h"
15 15
16 #define PLINK_GET_LLID(p) (p + 2) 16 #define PLINK_GET_LLID(p) (p + 2)
17 #define PLINK_GET_PLID(p) (p + 4) 17 #define PLINK_GET_PLID(p) (p + 4)
18 18
19 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \ 19 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
20 jiffies + HZ * t / 1000)) 20 jiffies + HZ * t / 1000))
21 21
22 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries) 22 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
23 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout) 23 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
24 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout) 24 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
25 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout) 25 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
26 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks) 26 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
27 27
28 /* We only need a valid sta if user configured a minimum rssi_threshold. */ 28 /* We only need a valid sta if user configured a minimum rssi_threshold. */
29 #define rssi_threshold_check(sta, sdata) \ 29 #define rssi_threshold_check(sta, sdata) \
30 (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\ 30 (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\
31 (sta && (s8) -ewma_read(&sta->avg_signal) > \ 31 (sta && (s8) -ewma_read(&sta->avg_signal) > \
32 sdata->u.mesh.mshcfg.rssi_threshold)) 32 sdata->u.mesh.mshcfg.rssi_threshold))
33 33
34 enum plink_event { 34 enum plink_event {
35 PLINK_UNDEFINED, 35 PLINK_UNDEFINED,
36 OPN_ACPT, 36 OPN_ACPT,
37 OPN_RJCT, 37 OPN_RJCT,
38 OPN_IGNR, 38 OPN_IGNR,
39 CNF_ACPT, 39 CNF_ACPT,
40 CNF_RJCT, 40 CNF_RJCT,
41 CNF_IGNR, 41 CNF_IGNR,
42 CLS_ACPT, 42 CLS_ACPT,
43 CLS_IGNR 43 CLS_IGNR
44 }; 44 };
45 45
46 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata, 46 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
47 enum ieee80211_self_protected_actioncode action, 47 enum ieee80211_self_protected_actioncode action,
48 u8 *da, __le16 llid, __le16 plid, __le16 reason); 48 u8 *da, __le16 llid, __le16 plid, __le16 reason);
49 49
50 static inline 50 static inline
51 u32 mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata) 51 u32 mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
52 { 52 {
53 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks); 53 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks);
54 return mesh_accept_plinks_update(sdata); 54 return mesh_accept_plinks_update(sdata);
55 } 55 }
56 56
57 static inline 57 static inline
58 u32 mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata) 58 u32 mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
59 { 59 {
60 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks); 60 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks);
61 return mesh_accept_plinks_update(sdata); 61 return mesh_accept_plinks_update(sdata);
62 } 62 }
63 63
64 /** 64 /**
65 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine 65 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
66 * 66 *
67 * @sta: mesh peer link to restart 67 * @sta: mesh peer link to restart
68 * 68 *
69 * Locking: this function must be called holding sta->lock 69 * Locking: this function must be called holding sta->lock
70 */ 70 */
71 static inline void mesh_plink_fsm_restart(struct sta_info *sta) 71 static inline void mesh_plink_fsm_restart(struct sta_info *sta)
72 { 72 {
73 sta->plink_state = NL80211_PLINK_LISTEN; 73 sta->plink_state = NL80211_PLINK_LISTEN;
74 sta->llid = sta->plid = sta->reason = 0; 74 sta->llid = sta->plid = sta->reason = 0;
75 sta->plink_retries = 0; 75 sta->plink_retries = 0;
76 } 76 }
77 77
78 /* 78 /*
79 * Allocate mesh sta entry and insert into station table 79 * Allocate mesh sta entry and insert into station table
80 */ 80 */
81 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata, 81 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
82 u8 *hw_addr) 82 u8 *hw_addr)
83 { 83 {
84 struct sta_info *sta; 84 struct sta_info *sta;
85 85
86 if (sdata->local->num_sta >= MESH_MAX_PLINKS) 86 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
87 return NULL; 87 return NULL;
88 88
89 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL); 89 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
90 if (!sta) 90 if (!sta)
91 return NULL; 91 return NULL;
92 92
93 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH); 93 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
94 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC); 94 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
95 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED); 95 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
96 96
97 set_sta_flag(sta, WLAN_STA_WME); 97 set_sta_flag(sta, WLAN_STA_WME);
98 98
99 return sta; 99 return sta;
100 } 100 }
101 101
102 /** 102 /**
103 * mesh_set_ht_prot_mode - set correct HT protection mode 103 * mesh_set_ht_prot_mode - set correct HT protection mode
104 * 104 *
105 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT 105 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
106 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT 106 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
107 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is 107 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
108 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode 108 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
109 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one 109 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
110 * HT20 peer is present. Otherwise no-protection mode is selected. 110 * HT20 peer is present. Otherwise no-protection mode is selected.
111 */ 111 */
112 static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata) 112 static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
113 { 113 {
114 struct ieee80211_local *local = sdata->local; 114 struct ieee80211_local *local = sdata->local;
115 struct sta_info *sta; 115 struct sta_info *sta;
116 u32 changed = 0; 116 u32 changed = 0;
117 u16 ht_opmode; 117 u16 ht_opmode;
118 bool non_ht_sta = false, ht20_sta = false; 118 bool non_ht_sta = false, ht20_sta = false;
119 119
120 if (sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT) 120 if (sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT)
121 return 0; 121 return 0;
122 122
123 rcu_read_lock(); 123 rcu_read_lock();
124 list_for_each_entry_rcu(sta, &local->sta_list, list) { 124 list_for_each_entry_rcu(sta, &local->sta_list, list) {
125 if (sdata != sta->sdata || 125 if (sdata != sta->sdata ||
126 sta->plink_state != NL80211_PLINK_ESTAB) 126 sta->plink_state != NL80211_PLINK_ESTAB)
127 continue; 127 continue;
128 128
129 switch (sta->ch_type) { 129 switch (sta->ch_type) {
130 case NL80211_CHAN_NO_HT: 130 case NL80211_CHAN_NO_HT:
131 mpl_dbg(sdata, 131 mpl_dbg(sdata,
132 "mesh_plink %pM: nonHT sta (%pM) is present\n", 132 "mesh_plink %pM: nonHT sta (%pM) is present\n",
133 sdata->vif.addr, sta->sta.addr); 133 sdata->vif.addr, sta->sta.addr);
134 non_ht_sta = true; 134 non_ht_sta = true;
135 goto out; 135 goto out;
136 case NL80211_CHAN_HT20: 136 case NL80211_CHAN_HT20:
137 mpl_dbg(sdata, 137 mpl_dbg(sdata,
138 "mesh_plink %pM: HT20 sta (%pM) is present\n", 138 "mesh_plink %pM: HT20 sta (%pM) is present\n",
139 sdata->vif.addr, sta->sta.addr); 139 sdata->vif.addr, sta->sta.addr);
140 ht20_sta = true; 140 ht20_sta = true;
141 default: 141 default:
142 break; 142 break;
143 } 143 }
144 } 144 }
145 out: 145 out:
146 rcu_read_unlock(); 146 rcu_read_unlock();
147 147
148 if (non_ht_sta) 148 if (non_ht_sta)
149 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED; 149 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
150 else if (ht20_sta && 150 else if (ht20_sta &&
151 sdata->vif.bss_conf.channel_type > NL80211_CHAN_HT20) 151 sdata->vif.bss_conf.channel_type > NL80211_CHAN_HT20)
152 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ; 152 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
153 else 153 else
154 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE; 154 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
155 155
156 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) { 156 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
157 sdata->vif.bss_conf.ht_operation_mode = ht_opmode; 157 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
158 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode; 158 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode;
159 changed = BSS_CHANGED_HT; 159 changed = BSS_CHANGED_HT;
160 mpl_dbg(sdata, 160 mpl_dbg(sdata,
161 "mesh_plink %pM: protection mode changed to %d\n", 161 "mesh_plink %pM: protection mode changed to %d\n",
162 sdata->vif.addr, ht_opmode); 162 sdata->vif.addr, ht_opmode);
163 } 163 }
164 164
165 return changed; 165 return changed;
166 } 166 }
167 167
168 /** 168 /**
169 * __mesh_plink_deactivate - deactivate mesh peer link 169 * __mesh_plink_deactivate - deactivate mesh peer link
170 * 170 *
171 * @sta: mesh peer link to deactivate 171 * @sta: mesh peer link to deactivate
172 * 172 *
173 * All mesh paths with this peer as next hop will be flushed 173 * All mesh paths with this peer as next hop will be flushed
174 * Returns beacon changed flag if the beacon content changed. 174 * Returns beacon changed flag if the beacon content changed.
175 * 175 *
176 * Locking: the caller must hold sta->lock 176 * Locking: the caller must hold sta->lock
177 */ 177 */
178 static u32 __mesh_plink_deactivate(struct sta_info *sta) 178 static u32 __mesh_plink_deactivate(struct sta_info *sta)
179 { 179 {
180 struct ieee80211_sub_if_data *sdata = sta->sdata; 180 struct ieee80211_sub_if_data *sdata = sta->sdata;
181 u32 changed = 0; 181 u32 changed = 0;
182 182
183 if (sta->plink_state == NL80211_PLINK_ESTAB) 183 if (sta->plink_state == NL80211_PLINK_ESTAB)
184 changed = mesh_plink_dec_estab_count(sdata); 184 changed = mesh_plink_dec_estab_count(sdata);
185 sta->plink_state = NL80211_PLINK_BLOCKED; 185 sta->plink_state = NL80211_PLINK_BLOCKED;
186 mesh_path_flush_by_nexthop(sta); 186 mesh_path_flush_by_nexthop(sta);
187 187
188 return changed; 188 return changed;
189 } 189 }
190 190
191 /** 191 /**
192 * mesh_plink_deactivate - deactivate mesh peer link 192 * mesh_plink_deactivate - deactivate mesh peer link
193 * 193 *
194 * @sta: mesh peer link to deactivate 194 * @sta: mesh peer link to deactivate
195 * 195 *
196 * All mesh paths with this peer as next hop will be flushed 196 * All mesh paths with this peer as next hop will be flushed
197 */ 197 */
198 void mesh_plink_deactivate(struct sta_info *sta) 198 void mesh_plink_deactivate(struct sta_info *sta)
199 { 199 {
200 struct ieee80211_sub_if_data *sdata = sta->sdata; 200 struct ieee80211_sub_if_data *sdata = sta->sdata;
201 u32 changed; 201 u32 changed;
202 202
203 spin_lock_bh(&sta->lock); 203 spin_lock_bh(&sta->lock);
204 changed = __mesh_plink_deactivate(sta); 204 changed = __mesh_plink_deactivate(sta);
205 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED); 205 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
206 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE, 206 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
207 sta->sta.addr, sta->llid, sta->plid, 207 sta->sta.addr, sta->llid, sta->plid,
208 sta->reason); 208 sta->reason);
209 spin_unlock_bh(&sta->lock); 209 spin_unlock_bh(&sta->lock);
210 210
211 ieee80211_bss_info_change_notify(sdata, changed); 211 ieee80211_bss_info_change_notify(sdata, changed);
212 } 212 }
213 213
214 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata, 214 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
215 enum ieee80211_self_protected_actioncode action, 215 enum ieee80211_self_protected_actioncode action,
216 u8 *da, __le16 llid, __le16 plid, __le16 reason) { 216 u8 *da, __le16 llid, __le16 plid, __le16 reason) {
217 struct ieee80211_local *local = sdata->local; 217 struct ieee80211_local *local = sdata->local;
218 struct sk_buff *skb; 218 struct sk_buff *skb;
219 struct ieee80211_tx_info *info; 219 struct ieee80211_tx_info *info;
220 struct ieee80211_mgmt *mgmt; 220 struct ieee80211_mgmt *mgmt;
221 bool include_plid = false; 221 bool include_plid = false;
222 u16 peering_proto = 0; 222 u16 peering_proto = 0;
223 u8 *pos, ie_len = 4; 223 u8 *pos, ie_len = 4;
224 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) + 224 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) +
225 sizeof(mgmt->u.action.u.self_prot); 225 sizeof(mgmt->u.action.u.self_prot);
226 int err = -ENOMEM; 226 int err = -ENOMEM;
227 227
228 skb = dev_alloc_skb(local->tx_headroom + 228 skb = dev_alloc_skb(local->tx_headroom +
229 hdr_len + 229 hdr_len +
230 2 + /* capability info */ 230 2 + /* capability info */
231 2 + /* AID */ 231 2 + /* AID */
232 2 + 8 + /* supported rates */ 232 2 + 8 + /* supported rates */
233 2 + (IEEE80211_MAX_SUPP_RATES - 8) + 233 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
234 2 + sdata->u.mesh.mesh_id_len + 234 2 + sdata->u.mesh.mesh_id_len +
235 2 + sizeof(struct ieee80211_meshconf_ie) + 235 2 + sizeof(struct ieee80211_meshconf_ie) +
236 2 + sizeof(struct ieee80211_ht_cap) + 236 2 + sizeof(struct ieee80211_ht_cap) +
237 2 + sizeof(struct ieee80211_ht_operation) + 237 2 + sizeof(struct ieee80211_ht_operation) +
238 2 + 8 + /* peering IE */ 238 2 + 8 + /* peering IE */
239 sdata->u.mesh.ie_len); 239 sdata->u.mesh.ie_len);
240 if (!skb) 240 if (!skb)
241 return -1; 241 return -1;
242 info = IEEE80211_SKB_CB(skb); 242 info = IEEE80211_SKB_CB(skb);
243 skb_reserve(skb, local->tx_headroom); 243 skb_reserve(skb, local->tx_headroom);
244 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 244 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
245 memset(mgmt, 0, hdr_len); 245 memset(mgmt, 0, hdr_len);
246 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 246 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
247 IEEE80211_STYPE_ACTION); 247 IEEE80211_STYPE_ACTION);
248 memcpy(mgmt->da, da, ETH_ALEN); 248 memcpy(mgmt->da, da, ETH_ALEN);
249 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 249 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
250 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); 250 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
251 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED; 251 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
252 mgmt->u.action.u.self_prot.action_code = action; 252 mgmt->u.action.u.self_prot.action_code = action;
253 253
254 if (action != WLAN_SP_MESH_PEERING_CLOSE) { 254 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
255 /* capability info */ 255 /* capability info */
256 pos = skb_put(skb, 2); 256 pos = skb_put(skb, 2);
257 memset(pos, 0, 2); 257 memset(pos, 0, 2);
258 if (action == WLAN_SP_MESH_PEERING_CONFIRM) { 258 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
259 /* AID */ 259 /* AID */
260 pos = skb_put(skb, 2); 260 pos = skb_put(skb, 2);
261 memcpy(pos + 2, &plid, 2); 261 memcpy(pos + 2, &plid, 2);
262 } 262 }
263 if (ieee80211_add_srates_ie(sdata, skb, true, 263 if (ieee80211_add_srates_ie(sdata, skb, true,
264 local->oper_channel->band) || 264 local->oper_channel->band) ||
265 ieee80211_add_ext_srates_ie(sdata, skb, true, 265 ieee80211_add_ext_srates_ie(sdata, skb, true,
266 local->oper_channel->band) || 266 local->oper_channel->band) ||
267 mesh_add_rsn_ie(skb, sdata) || 267 mesh_add_rsn_ie(skb, sdata) ||
268 mesh_add_meshid_ie(skb, sdata) || 268 mesh_add_meshid_ie(skb, sdata) ||
269 mesh_add_meshconf_ie(skb, sdata)) 269 mesh_add_meshconf_ie(skb, sdata))
270 goto free; 270 goto free;
271 } else { /* WLAN_SP_MESH_PEERING_CLOSE */ 271 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
272 info->flags |= IEEE80211_TX_CTL_NO_ACK; 272 info->flags |= IEEE80211_TX_CTL_NO_ACK;
273 if (mesh_add_meshid_ie(skb, sdata)) 273 if (mesh_add_meshid_ie(skb, sdata))
274 goto free; 274 goto free;
275 } 275 }
276 276
277 /* Add Mesh Peering Management element */ 277 /* Add Mesh Peering Management element */
278 switch (action) { 278 switch (action) {
279 case WLAN_SP_MESH_PEERING_OPEN: 279 case WLAN_SP_MESH_PEERING_OPEN:
280 break; 280 break;
281 case WLAN_SP_MESH_PEERING_CONFIRM: 281 case WLAN_SP_MESH_PEERING_CONFIRM:
282 ie_len += 2; 282 ie_len += 2;
283 include_plid = true; 283 include_plid = true;
284 break; 284 break;
285 case WLAN_SP_MESH_PEERING_CLOSE: 285 case WLAN_SP_MESH_PEERING_CLOSE:
286 if (plid) { 286 if (plid) {
287 ie_len += 2; 287 ie_len += 2;
288 include_plid = true; 288 include_plid = true;
289 } 289 }
290 ie_len += 2; /* reason code */ 290 ie_len += 2; /* reason code */
291 break; 291 break;
292 default: 292 default:
293 err = -EINVAL; 293 err = -EINVAL;
294 goto free; 294 goto free;
295 } 295 }
296 296
297 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len)) 297 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
298 goto free; 298 goto free;
299 299
300 pos = skb_put(skb, 2 + ie_len); 300 pos = skb_put(skb, 2 + ie_len);
301 *pos++ = WLAN_EID_PEER_MGMT; 301 *pos++ = WLAN_EID_PEER_MGMT;
302 *pos++ = ie_len; 302 *pos++ = ie_len;
303 memcpy(pos, &peering_proto, 2); 303 memcpy(pos, &peering_proto, 2);
304 pos += 2; 304 pos += 2;
305 memcpy(pos, &llid, 2); 305 memcpy(pos, &llid, 2);
306 pos += 2; 306 pos += 2;
307 if (include_plid) { 307 if (include_plid) {
308 memcpy(pos, &plid, 2); 308 memcpy(pos, &plid, 2);
309 pos += 2; 309 pos += 2;
310 } 310 }
311 if (action == WLAN_SP_MESH_PEERING_CLOSE) { 311 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
312 memcpy(pos, &reason, 2); 312 memcpy(pos, &reason, 2);
313 pos += 2; 313 pos += 2;
314 } 314 }
315 315
316 if (action != WLAN_SP_MESH_PEERING_CLOSE) { 316 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
317 if (mesh_add_ht_cap_ie(skb, sdata) || 317 if (mesh_add_ht_cap_ie(skb, sdata) ||
318 mesh_add_ht_oper_ie(skb, sdata)) 318 mesh_add_ht_oper_ie(skb, sdata))
319 goto free; 319 goto free;
320 } 320 }
321 321
322 if (mesh_add_vendor_ies(skb, sdata)) 322 if (mesh_add_vendor_ies(skb, sdata))
323 goto free; 323 goto free;
324 324
325 ieee80211_tx_skb(sdata, skb); 325 ieee80211_tx_skb(sdata, skb);
326 return 0; 326 return 0;
327 free: 327 free:
328 kfree_skb(skb); 328 kfree_skb(skb);
329 return err; 329 return err;
330 } 330 }
331 331
332 /** 332 /**
333 * mesh_peer_init - initialize new mesh peer and return resulting sta_info 333 * mesh_peer_init - initialize new mesh peer and return resulting sta_info
334 * 334 *
335 * @sdata: local meshif 335 * @sdata: local meshif
336 * @addr: peer's address 336 * @addr: peer's address
337 * @elems: IEs from beacon or mesh peering frame 337 * @elems: IEs from beacon or mesh peering frame
338 * 338 *
339 * call under RCU 339 * call under RCU
340 */ 340 */
341 static struct sta_info *mesh_peer_init(struct ieee80211_sub_if_data *sdata, 341 static struct sta_info *mesh_peer_init(struct ieee80211_sub_if_data *sdata,
342 u8 *addr, 342 u8 *addr,
343 struct ieee802_11_elems *elems) 343 struct ieee802_11_elems *elems)
344 { 344 {
345 struct ieee80211_local *local = sdata->local; 345 struct ieee80211_local *local = sdata->local;
346 enum ieee80211_band band = local->oper_channel->band; 346 enum ieee80211_band band = local->oper_channel->band;
347 struct ieee80211_supported_band *sband; 347 struct ieee80211_supported_band *sband;
348 u32 rates, basic_rates = 0; 348 u32 rates, basic_rates = 0;
349 struct sta_info *sta; 349 struct sta_info *sta;
350 bool insert = false; 350 bool insert = false;
351 351
352 sband = local->hw.wiphy->bands[band]; 352 sband = local->hw.wiphy->bands[band];
353 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates); 353 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates);
354 354
355 sta = sta_info_get(sdata, addr); 355 sta = sta_info_get(sdata, addr);
356 if (!sta) { 356 if (!sta) {
357 /* Userspace handles peer allocation when security is enabled */ 357 /* Userspace handles peer allocation when security is enabled */
358 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED) { 358 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED) {
359 cfg80211_notify_new_peer_candidate(sdata->dev, addr, 359 cfg80211_notify_new_peer_candidate(sdata->dev, addr,
360 elems->ie_start, 360 elems->ie_start,
361 elems->total_len, 361 elems->total_len,
362 GFP_ATOMIC); 362 GFP_ATOMIC);
363 return NULL; 363 return NULL;
364 } 364 }
365 365
366 sta = mesh_plink_alloc(sdata, addr); 366 sta = mesh_plink_alloc(sdata, addr);
367 if (!sta) 367 if (!sta)
368 return NULL; 368 return NULL;
369 insert = true; 369 insert = true;
370 } 370 }
371 371
372 spin_lock_bh(&sta->lock); 372 spin_lock_bh(&sta->lock);
373 sta->last_rx = jiffies; 373 sta->last_rx = jiffies;
374 if (sta->plink_state == NL80211_PLINK_ESTAB) { 374 if (sta->plink_state == NL80211_PLINK_ESTAB) {
375 spin_unlock_bh(&sta->lock); 375 spin_unlock_bh(&sta->lock);
376 return sta; 376 return sta;
377 } 377 }
378 378
379 sta->sta.supp_rates[band] = rates; 379 sta->sta.supp_rates[band] = rates;
380 if (elems->ht_cap_elem && 380 if (elems->ht_cap_elem &&
381 sdata->vif.bss_conf.channel_type != NL80211_CHAN_NO_HT) 381 sdata->vif.bss_conf.channel_type != NL80211_CHAN_NO_HT)
382 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband, 382 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
383 elems->ht_cap_elem, 383 elems->ht_cap_elem,
384 &sta->sta.ht_cap); 384 &sta->sta.ht_cap);
385 else 385 else
386 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap)); 386 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap));
387 387
388 if (elems->ht_operation) { 388 if (elems->ht_operation) {
389 if (!(elems->ht_operation->ht_param & 389 if (!(elems->ht_operation->ht_param &
390 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) 390 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
391 sta->sta.ht_cap.cap &= 391 sta->sta.ht_cap.cap &=
392 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; 392 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
393 sta->ch_type = 393 sta->ch_type =
394 ieee80211_ht_oper_to_channel_type(elems->ht_operation); 394 ieee80211_ht_oper_to_channel_type(elems->ht_operation);
395 } 395 }
396 396
397 rate_control_rate_init(sta); 397 rate_control_rate_init(sta);
398 spin_unlock_bh(&sta->lock); 398 spin_unlock_bh(&sta->lock);
399 399
400 if (insert && sta_info_insert(sta)) 400 if (insert && sta_info_insert(sta))
401 return NULL; 401 return NULL;
402 402
403 return sta; 403 return sta;
404 } 404 }
405 405
406 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata, 406 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
407 u8 *hw_addr, 407 u8 *hw_addr,
408 struct ieee802_11_elems *elems) 408 struct ieee802_11_elems *elems)
409 { 409 {
410 struct sta_info *sta; 410 struct sta_info *sta;
411 411
412 rcu_read_lock(); 412 rcu_read_lock();
413 sta = mesh_peer_init(sdata, hw_addr, elems); 413 sta = mesh_peer_init(sdata, hw_addr, elems);
414 if (!sta) 414 if (!sta)
415 goto out; 415 goto out;
416 416
417 if (mesh_peer_accepts_plinks(elems) && 417 if (mesh_peer_accepts_plinks(elems) &&
418 sta->plink_state == NL80211_PLINK_LISTEN && 418 sta->plink_state == NL80211_PLINK_LISTEN &&
419 sdata->u.mesh.accepting_plinks && 419 sdata->u.mesh.accepting_plinks &&
420 sdata->u.mesh.mshcfg.auto_open_plinks && 420 sdata->u.mesh.mshcfg.auto_open_plinks &&
421 rssi_threshold_check(sta, sdata)) 421 rssi_threshold_check(sta, sdata))
422 mesh_plink_open(sta); 422 mesh_plink_open(sta);
423 423
424 out: 424 out:
425 rcu_read_unlock(); 425 rcu_read_unlock();
426 } 426 }
427 427
428 static void mesh_plink_timer(unsigned long data) 428 static void mesh_plink_timer(unsigned long data)
429 { 429 {
430 struct sta_info *sta; 430 struct sta_info *sta;
431 __le16 llid, plid, reason; 431 __le16 llid, plid, reason;
432 struct ieee80211_sub_if_data *sdata; 432 struct ieee80211_sub_if_data *sdata;
433 433
434 /* 434 /*
435 * This STA is valid because sta_info_destroy() will 435 * This STA is valid because sta_info_destroy() will
436 * del_timer_sync() this timer after having made sure 436 * del_timer_sync() this timer after having made sure
437 * it cannot be readded (by deleting the plink.) 437 * it cannot be readded (by deleting the plink.)
438 */ 438 */
439 sta = (struct sta_info *) data; 439 sta = (struct sta_info *) data;
440 440
441 if (sta->sdata->local->quiescing) { 441 if (sta->sdata->local->quiescing) {
442 sta->plink_timer_was_running = true; 442 sta->plink_timer_was_running = true;
443 return; 443 return;
444 } 444 }
445 445
446 spin_lock_bh(&sta->lock); 446 spin_lock_bh(&sta->lock);
447 if (sta->ignore_plink_timer) { 447 if (sta->ignore_plink_timer) {
448 sta->ignore_plink_timer = false; 448 sta->ignore_plink_timer = false;
449 spin_unlock_bh(&sta->lock); 449 spin_unlock_bh(&sta->lock);
450 return; 450 return;
451 } 451 }
452 mpl_dbg(sta->sdata, 452 mpl_dbg(sta->sdata,
453 "Mesh plink timer for %pM fired on state %d\n", 453 "Mesh plink timer for %pM fired on state %d\n",
454 sta->sta.addr, sta->plink_state); 454 sta->sta.addr, sta->plink_state);
455 reason = 0; 455 reason = 0;
456 llid = sta->llid; 456 llid = sta->llid;
457 plid = sta->plid; 457 plid = sta->plid;
458 sdata = sta->sdata; 458 sdata = sta->sdata;
459 459
460 switch (sta->plink_state) { 460 switch (sta->plink_state) {
461 case NL80211_PLINK_OPN_RCVD: 461 case NL80211_PLINK_OPN_RCVD:
462 case NL80211_PLINK_OPN_SNT: 462 case NL80211_PLINK_OPN_SNT:
463 /* retry timer */ 463 /* retry timer */
464 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) { 464 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
465 u32 rand; 465 u32 rand;
466 mpl_dbg(sta->sdata, 466 mpl_dbg(sta->sdata,
467 "Mesh plink for %pM (retry, timeout): %d %d\n", 467 "Mesh plink for %pM (retry, timeout): %d %d\n",
468 sta->sta.addr, sta->plink_retries, 468 sta->sta.addr, sta->plink_retries,
469 sta->plink_timeout); 469 sta->plink_timeout);
470 get_random_bytes(&rand, sizeof(u32)); 470 get_random_bytes(&rand, sizeof(u32));
471 sta->plink_timeout = sta->plink_timeout + 471 sta->plink_timeout = sta->plink_timeout +
472 rand % sta->plink_timeout; 472 rand % sta->plink_timeout;
473 ++sta->plink_retries; 473 ++sta->plink_retries;
474 mod_plink_timer(sta, sta->plink_timeout); 474 mod_plink_timer(sta, sta->plink_timeout);
475 spin_unlock_bh(&sta->lock); 475 spin_unlock_bh(&sta->lock);
476 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN, 476 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
477 sta->sta.addr, llid, 0, 0); 477 sta->sta.addr, llid, 0, 0);
478 break; 478 break;
479 } 479 }
480 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES); 480 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
481 /* fall through on else */ 481 /* fall through on else */
482 case NL80211_PLINK_CNF_RCVD: 482 case NL80211_PLINK_CNF_RCVD:
483 /* confirm timer */ 483 /* confirm timer */
484 if (!reason) 484 if (!reason)
485 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT); 485 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
486 sta->plink_state = NL80211_PLINK_HOLDING; 486 sta->plink_state = NL80211_PLINK_HOLDING;
487 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)); 487 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
488 spin_unlock_bh(&sta->lock); 488 spin_unlock_bh(&sta->lock);
489 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE, 489 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
490 sta->sta.addr, llid, plid, reason); 490 sta->sta.addr, llid, plid, reason);
491 break; 491 break;
492 case NL80211_PLINK_HOLDING: 492 case NL80211_PLINK_HOLDING:
493 /* holding timer */ 493 /* holding timer */
494 del_timer(&sta->plink_timer); 494 del_timer(&sta->plink_timer);
495 mesh_plink_fsm_restart(sta); 495 mesh_plink_fsm_restart(sta);
496 spin_unlock_bh(&sta->lock); 496 spin_unlock_bh(&sta->lock);
497 break; 497 break;
498 default: 498 default:
499 spin_unlock_bh(&sta->lock); 499 spin_unlock_bh(&sta->lock);
500 break; 500 break;
501 } 501 }
502 } 502 }
503 503
504 #ifdef CONFIG_PM 504 #ifdef CONFIG_PM
505 void mesh_plink_quiesce(struct sta_info *sta) 505 void mesh_plink_quiesce(struct sta_info *sta)
506 { 506 {
507 if (del_timer_sync(&sta->plink_timer)) 507 if (del_timer_sync(&sta->plink_timer))
508 sta->plink_timer_was_running = true; 508 sta->plink_timer_was_running = true;
509 } 509 }
510 510
511 void mesh_plink_restart(struct sta_info *sta) 511 void mesh_plink_restart(struct sta_info *sta)
512 { 512 {
513 if (sta->plink_timer_was_running) { 513 if (sta->plink_timer_was_running) {
514 add_timer(&sta->plink_timer); 514 add_timer(&sta->plink_timer);
515 sta->plink_timer_was_running = false; 515 sta->plink_timer_was_running = false;
516 } 516 }
517 } 517 }
518 #endif 518 #endif
519 519
520 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout) 520 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
521 { 521 {
522 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000); 522 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
523 sta->plink_timer.data = (unsigned long) sta; 523 sta->plink_timer.data = (unsigned long) sta;
524 sta->plink_timer.function = mesh_plink_timer; 524 sta->plink_timer.function = mesh_plink_timer;
525 sta->plink_timeout = timeout; 525 sta->plink_timeout = timeout;
526 add_timer(&sta->plink_timer); 526 add_timer(&sta->plink_timer);
527 } 527 }
528 528
529 int mesh_plink_open(struct sta_info *sta) 529 int mesh_plink_open(struct sta_info *sta)
530 { 530 {
531 __le16 llid; 531 __le16 llid;
532 struct ieee80211_sub_if_data *sdata = sta->sdata; 532 struct ieee80211_sub_if_data *sdata = sta->sdata;
533 533
534 if (!test_sta_flag(sta, WLAN_STA_AUTH)) 534 if (!test_sta_flag(sta, WLAN_STA_AUTH))
535 return -EPERM; 535 return -EPERM;
536 536
537 spin_lock_bh(&sta->lock); 537 spin_lock_bh(&sta->lock);
538 get_random_bytes(&llid, 2); 538 get_random_bytes(&llid, 2);
539 sta->llid = llid; 539 sta->llid = llid;
540 if (sta->plink_state != NL80211_PLINK_LISTEN) { 540 if (sta->plink_state != NL80211_PLINK_LISTEN &&
541 sta->plink_state != NL80211_PLINK_BLOCKED) {
541 spin_unlock_bh(&sta->lock); 542 spin_unlock_bh(&sta->lock);
542 return -EBUSY; 543 return -EBUSY;
543 } 544 }
544 sta->plink_state = NL80211_PLINK_OPN_SNT; 545 sta->plink_state = NL80211_PLINK_OPN_SNT;
545 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata)); 546 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
546 spin_unlock_bh(&sta->lock); 547 spin_unlock_bh(&sta->lock);
547 mpl_dbg(sdata, 548 mpl_dbg(sdata,
548 "Mesh plink: starting establishment with %pM\n", 549 "Mesh plink: starting establishment with %pM\n",
549 sta->sta.addr); 550 sta->sta.addr);
550 551
551 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN, 552 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
552 sta->sta.addr, llid, 0, 0); 553 sta->sta.addr, llid, 0, 0);
553 } 554 }
554 555
555 void mesh_plink_block(struct sta_info *sta) 556 void mesh_plink_block(struct sta_info *sta)
556 { 557 {
557 struct ieee80211_sub_if_data *sdata = sta->sdata; 558 struct ieee80211_sub_if_data *sdata = sta->sdata;
558 u32 changed; 559 u32 changed;
559 560
560 spin_lock_bh(&sta->lock); 561 spin_lock_bh(&sta->lock);
561 changed = __mesh_plink_deactivate(sta); 562 changed = __mesh_plink_deactivate(sta);
562 sta->plink_state = NL80211_PLINK_BLOCKED; 563 sta->plink_state = NL80211_PLINK_BLOCKED;
563 spin_unlock_bh(&sta->lock); 564 spin_unlock_bh(&sta->lock);
564 565
565 ieee80211_bss_info_change_notify(sdata, changed); 566 ieee80211_bss_info_change_notify(sdata, changed);
566 } 567 }
567 568
568 569
569 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt, 570 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
570 size_t len, struct ieee80211_rx_status *rx_status) 571 size_t len, struct ieee80211_rx_status *rx_status)
571 { 572 {
572 struct ieee802_11_elems elems; 573 struct ieee802_11_elems elems;
573 struct sta_info *sta; 574 struct sta_info *sta;
574 enum plink_event event; 575 enum plink_event event;
575 enum ieee80211_self_protected_actioncode ftype; 576 enum ieee80211_self_protected_actioncode ftype;
576 size_t baselen; 577 size_t baselen;
577 bool matches_local = true; 578 bool matches_local = true;
578 u8 ie_len; 579 u8 ie_len;
579 u8 *baseaddr; 580 u8 *baseaddr;
580 u32 changed = 0; 581 u32 changed = 0;
581 __le16 plid, llid, reason; 582 __le16 plid, llid, reason;
582 static const char *mplstates[] = { 583 static const char *mplstates[] = {
583 [NL80211_PLINK_LISTEN] = "LISTEN", 584 [NL80211_PLINK_LISTEN] = "LISTEN",
584 [NL80211_PLINK_OPN_SNT] = "OPN-SNT", 585 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
585 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD", 586 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
586 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD", 587 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
587 [NL80211_PLINK_ESTAB] = "ESTAB", 588 [NL80211_PLINK_ESTAB] = "ESTAB",
588 [NL80211_PLINK_HOLDING] = "HOLDING", 589 [NL80211_PLINK_HOLDING] = "HOLDING",
589 [NL80211_PLINK_BLOCKED] = "BLOCKED" 590 [NL80211_PLINK_BLOCKED] = "BLOCKED"
590 }; 591 };
591 592
592 /* need action_code, aux */ 593 /* need action_code, aux */
593 if (len < IEEE80211_MIN_ACTION_SIZE + 3) 594 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
594 return; 595 return;
595 596
596 if (is_multicast_ether_addr(mgmt->da)) { 597 if (is_multicast_ether_addr(mgmt->da)) {
597 mpl_dbg(sdata, 598 mpl_dbg(sdata,
598 "Mesh plink: ignore frame from multicast address\n"); 599 "Mesh plink: ignore frame from multicast address\n");
599 return; 600 return;
600 } 601 }
601 602
602 baseaddr = mgmt->u.action.u.self_prot.variable; 603 baseaddr = mgmt->u.action.u.self_prot.variable;
603 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt; 604 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
604 if (mgmt->u.action.u.self_prot.action_code == 605 if (mgmt->u.action.u.self_prot.action_code ==
605 WLAN_SP_MESH_PEERING_CONFIRM) { 606 WLAN_SP_MESH_PEERING_CONFIRM) {
606 baseaddr += 4; 607 baseaddr += 4;
607 baselen += 4; 608 baselen += 4;
608 } 609 }
609 ieee802_11_parse_elems(baseaddr, len - baselen, &elems); 610 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
610 if (!elems.peering) { 611 if (!elems.peering) {
611 mpl_dbg(sdata, 612 mpl_dbg(sdata,
612 "Mesh plink: missing necessary peer link ie\n"); 613 "Mesh plink: missing necessary peer link ie\n");
613 return; 614 return;
614 } 615 }
615 if (elems.rsn_len && 616 if (elems.rsn_len &&
616 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) { 617 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
617 mpl_dbg(sdata, 618 mpl_dbg(sdata,
618 "Mesh plink: can't establish link with secure peer\n"); 619 "Mesh plink: can't establish link with secure peer\n");
619 return; 620 return;
620 } 621 }
621 622
622 ftype = mgmt->u.action.u.self_prot.action_code; 623 ftype = mgmt->u.action.u.self_prot.action_code;
623 ie_len = elems.peering_len; 624 ie_len = elems.peering_len;
624 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) || 625 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
625 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) || 626 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
626 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6 627 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
627 && ie_len != 8)) { 628 && ie_len != 8)) {
628 mpl_dbg(sdata, 629 mpl_dbg(sdata,
629 "Mesh plink: incorrect plink ie length %d %d\n", 630 "Mesh plink: incorrect plink ie length %d %d\n",
630 ftype, ie_len); 631 ftype, ie_len);
631 return; 632 return;
632 } 633 }
633 634
634 if (ftype != WLAN_SP_MESH_PEERING_CLOSE && 635 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
635 (!elems.mesh_id || !elems.mesh_config)) { 636 (!elems.mesh_id || !elems.mesh_config)) {
636 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n"); 637 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
637 return; 638 return;
638 } 639 }
639 /* Note the lines below are correct, the llid in the frame is the plid 640 /* Note the lines below are correct, the llid in the frame is the plid
640 * from the point of view of this host. 641 * from the point of view of this host.
641 */ 642 */
642 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2); 643 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
643 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM || 644 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
644 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8)) 645 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
645 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2); 646 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
646 647
647 rcu_read_lock(); 648 rcu_read_lock();
648 649
649 sta = sta_info_get(sdata, mgmt->sa); 650 sta = sta_info_get(sdata, mgmt->sa);
650 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) { 651 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
651 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n"); 652 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
652 rcu_read_unlock(); 653 rcu_read_unlock();
653 return; 654 return;
654 } 655 }
655 656
656 if (ftype == WLAN_SP_MESH_PEERING_OPEN && 657 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
657 !rssi_threshold_check(sta, sdata)) { 658 !rssi_threshold_check(sta, sdata)) {
658 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n", 659 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
659 mgmt->sa); 660 mgmt->sa);
660 rcu_read_unlock(); 661 rcu_read_unlock();
661 return; 662 return;
662 } 663 }
663 664
664 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) { 665 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
665 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n"); 666 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
666 rcu_read_unlock(); 667 rcu_read_unlock();
667 return; 668 return;
668 } 669 }
669 670
670 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) { 671 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
671 rcu_read_unlock(); 672 rcu_read_unlock();
672 return; 673 return;
673 } 674 }
674 675
675 /* Now we will figure out the appropriate event... */ 676 /* Now we will figure out the appropriate event... */
676 event = PLINK_UNDEFINED; 677 event = PLINK_UNDEFINED;
677 if (ftype != WLAN_SP_MESH_PEERING_CLOSE && 678 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
678 !mesh_matches_local(sdata, &elems)) { 679 !mesh_matches_local(sdata, &elems)) {
679 matches_local = false; 680 matches_local = false;
680 switch (ftype) { 681 switch (ftype) {
681 case WLAN_SP_MESH_PEERING_OPEN: 682 case WLAN_SP_MESH_PEERING_OPEN:
682 event = OPN_RJCT; 683 event = OPN_RJCT;
683 break; 684 break;
684 case WLAN_SP_MESH_PEERING_CONFIRM: 685 case WLAN_SP_MESH_PEERING_CONFIRM:
685 event = CNF_RJCT; 686 event = CNF_RJCT;
686 break; 687 break;
687 default: 688 default:
688 break; 689 break;
689 } 690 }
690 } 691 }
691 692
692 if (!sta && !matches_local) { 693 if (!sta && !matches_local) {
693 rcu_read_unlock(); 694 rcu_read_unlock();
694 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG); 695 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
695 llid = 0; 696 llid = 0;
696 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE, 697 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
697 mgmt->sa, llid, plid, reason); 698 mgmt->sa, llid, plid, reason);
698 return; 699 return;
699 } else if (!sta) { 700 } else if (!sta) {
700 /* ftype == WLAN_SP_MESH_PEERING_OPEN */ 701 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
701 if (!mesh_plink_free_count(sdata)) { 702 if (!mesh_plink_free_count(sdata)) {
702 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n"); 703 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
703 rcu_read_unlock(); 704 rcu_read_unlock();
704 return; 705 return;
705 } 706 }
706 event = OPN_ACPT; 707 event = OPN_ACPT;
707 } else if (matches_local) { 708 } else if (matches_local) {
708 switch (ftype) { 709 switch (ftype) {
709 case WLAN_SP_MESH_PEERING_OPEN: 710 case WLAN_SP_MESH_PEERING_OPEN:
710 if (!mesh_plink_free_count(sdata) || 711 if (!mesh_plink_free_count(sdata) ||
711 (sta->plid && sta->plid != plid)) 712 (sta->plid && sta->plid != plid))
712 event = OPN_IGNR; 713 event = OPN_IGNR;
713 else 714 else
714 event = OPN_ACPT; 715 event = OPN_ACPT;
715 break; 716 break;
716 case WLAN_SP_MESH_PEERING_CONFIRM: 717 case WLAN_SP_MESH_PEERING_CONFIRM:
717 if (!mesh_plink_free_count(sdata) || 718 if (!mesh_plink_free_count(sdata) ||
718 (sta->llid != llid || sta->plid != plid)) 719 (sta->llid != llid || sta->plid != plid))
719 event = CNF_IGNR; 720 event = CNF_IGNR;
720 else 721 else
721 event = CNF_ACPT; 722 event = CNF_ACPT;
722 break; 723 break;
723 case WLAN_SP_MESH_PEERING_CLOSE: 724 case WLAN_SP_MESH_PEERING_CLOSE:
724 if (sta->plink_state == NL80211_PLINK_ESTAB) 725 if (sta->plink_state == NL80211_PLINK_ESTAB)
725 /* Do not check for llid or plid. This does not 726 /* Do not check for llid or plid. This does not
726 * follow the standard but since multiple plinks 727 * follow the standard but since multiple plinks
727 * per sta are not supported, it is necessary in 728 * per sta are not supported, it is necessary in
728 * order to avoid a livelock when MP A sees an 729 * order to avoid a livelock when MP A sees an
729 * establish peer link to MP B but MP B does not 730 * establish peer link to MP B but MP B does not
730 * see it. This can be caused by a timeout in 731 * see it. This can be caused by a timeout in
731 * B's peer link establishment or B beign 732 * B's peer link establishment or B beign
732 * restarted. 733 * restarted.
733 */ 734 */
734 event = CLS_ACPT; 735 event = CLS_ACPT;
735 else if (sta->plid != plid) 736 else if (sta->plid != plid)
736 event = CLS_IGNR; 737 event = CLS_IGNR;
737 else if (ie_len == 7 && sta->llid != llid) 738 else if (ie_len == 7 && sta->llid != llid)
738 event = CLS_IGNR; 739 event = CLS_IGNR;
739 else 740 else
740 event = CLS_ACPT; 741 event = CLS_ACPT;
741 break; 742 break;
742 default: 743 default:
743 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n"); 744 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
744 rcu_read_unlock(); 745 rcu_read_unlock();
745 return; 746 return;
746 } 747 }
747 } 748 }
748 749
749 if (event == OPN_ACPT) { 750 if (event == OPN_ACPT) {
750 /* allocate sta entry if necessary and update info */ 751 /* allocate sta entry if necessary and update info */
751 sta = mesh_peer_init(sdata, mgmt->sa, &elems); 752 sta = mesh_peer_init(sdata, mgmt->sa, &elems);
752 if (!sta) { 753 if (!sta) {
753 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n"); 754 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
754 rcu_read_unlock(); 755 rcu_read_unlock();
755 return; 756 return;
756 } 757 }
757 } 758 }
758 759
759 mpl_dbg(sdata, 760 mpl_dbg(sdata,
760 "Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n", 761 "Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
761 mgmt->sa, mplstates[sta->plink_state], 762 mgmt->sa, mplstates[sta->plink_state],
762 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid), 763 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
763 event); 764 event);
764 reason = 0; 765 reason = 0;
765 spin_lock_bh(&sta->lock); 766 spin_lock_bh(&sta->lock);
766 switch (sta->plink_state) { 767 switch (sta->plink_state) {
767 /* spin_unlock as soon as state is updated at each case */ 768 /* spin_unlock as soon as state is updated at each case */
768 case NL80211_PLINK_LISTEN: 769 case NL80211_PLINK_LISTEN:
769 switch (event) { 770 switch (event) {
770 case CLS_ACPT: 771 case CLS_ACPT:
771 mesh_plink_fsm_restart(sta); 772 mesh_plink_fsm_restart(sta);
772 spin_unlock_bh(&sta->lock); 773 spin_unlock_bh(&sta->lock);
773 break; 774 break;
774 case OPN_ACPT: 775 case OPN_ACPT:
775 sta->plink_state = NL80211_PLINK_OPN_RCVD; 776 sta->plink_state = NL80211_PLINK_OPN_RCVD;
776 sta->plid = plid; 777 sta->plid = plid;
777 get_random_bytes(&llid, 2); 778 get_random_bytes(&llid, 2);
778 sta->llid = llid; 779 sta->llid = llid;
779 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata)); 780 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
780 spin_unlock_bh(&sta->lock); 781 spin_unlock_bh(&sta->lock);
781 mesh_plink_frame_tx(sdata, 782 mesh_plink_frame_tx(sdata,
782 WLAN_SP_MESH_PEERING_OPEN, 783 WLAN_SP_MESH_PEERING_OPEN,
783 sta->sta.addr, llid, 0, 0); 784 sta->sta.addr, llid, 0, 0);
784 mesh_plink_frame_tx(sdata, 785 mesh_plink_frame_tx(sdata,
785 WLAN_SP_MESH_PEERING_CONFIRM, 786 WLAN_SP_MESH_PEERING_CONFIRM,
786 sta->sta.addr, llid, plid, 0); 787 sta->sta.addr, llid, plid, 0);
787 break; 788 break;
788 default: 789 default:
789 spin_unlock_bh(&sta->lock); 790 spin_unlock_bh(&sta->lock);
790 break; 791 break;
791 } 792 }
792 break; 793 break;
793 794
794 case NL80211_PLINK_OPN_SNT: 795 case NL80211_PLINK_OPN_SNT:
795 switch (event) { 796 switch (event) {
796 case OPN_RJCT: 797 case OPN_RJCT:
797 case CNF_RJCT: 798 case CNF_RJCT:
798 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG); 799 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
799 case CLS_ACPT: 800 case CLS_ACPT:
800 if (!reason) 801 if (!reason)
801 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE); 802 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
802 sta->reason = reason; 803 sta->reason = reason;
803 sta->plink_state = NL80211_PLINK_HOLDING; 804 sta->plink_state = NL80211_PLINK_HOLDING;
804 if (!mod_plink_timer(sta, 805 if (!mod_plink_timer(sta,
805 dot11MeshHoldingTimeout(sdata))) 806 dot11MeshHoldingTimeout(sdata)))
806 sta->ignore_plink_timer = true; 807 sta->ignore_plink_timer = true;
807 808
808 llid = sta->llid; 809 llid = sta->llid;
809 spin_unlock_bh(&sta->lock); 810 spin_unlock_bh(&sta->lock);
810 mesh_plink_frame_tx(sdata, 811 mesh_plink_frame_tx(sdata,
811 WLAN_SP_MESH_PEERING_CLOSE, 812 WLAN_SP_MESH_PEERING_CLOSE,
812 sta->sta.addr, llid, plid, reason); 813 sta->sta.addr, llid, plid, reason);
813 break; 814 break;
814 case OPN_ACPT: 815 case OPN_ACPT:
815 /* retry timer is left untouched */ 816 /* retry timer is left untouched */
816 sta->plink_state = NL80211_PLINK_OPN_RCVD; 817 sta->plink_state = NL80211_PLINK_OPN_RCVD;
817 sta->plid = plid; 818 sta->plid = plid;
818 llid = sta->llid; 819 llid = sta->llid;
819 spin_unlock_bh(&sta->lock); 820 spin_unlock_bh(&sta->lock);
820 mesh_plink_frame_tx(sdata, 821 mesh_plink_frame_tx(sdata,
821 WLAN_SP_MESH_PEERING_CONFIRM, 822 WLAN_SP_MESH_PEERING_CONFIRM,
822 sta->sta.addr, llid, plid, 0); 823 sta->sta.addr, llid, plid, 0);
823 break; 824 break;
824 case CNF_ACPT: 825 case CNF_ACPT:
825 sta->plink_state = NL80211_PLINK_CNF_RCVD; 826 sta->plink_state = NL80211_PLINK_CNF_RCVD;
826 if (!mod_plink_timer(sta, 827 if (!mod_plink_timer(sta,
827 dot11MeshConfirmTimeout(sdata))) 828 dot11MeshConfirmTimeout(sdata)))
828 sta->ignore_plink_timer = true; 829 sta->ignore_plink_timer = true;
829 830
830 spin_unlock_bh(&sta->lock); 831 spin_unlock_bh(&sta->lock);
831 break; 832 break;
832 default: 833 default:
833 spin_unlock_bh(&sta->lock); 834 spin_unlock_bh(&sta->lock);
834 break; 835 break;
835 } 836 }
836 break; 837 break;
837 838
838 case NL80211_PLINK_OPN_RCVD: 839 case NL80211_PLINK_OPN_RCVD:
839 switch (event) { 840 switch (event) {
840 case OPN_RJCT: 841 case OPN_RJCT:
841 case CNF_RJCT: 842 case CNF_RJCT:
842 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG); 843 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
843 case CLS_ACPT: 844 case CLS_ACPT:
844 if (!reason) 845 if (!reason)
845 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE); 846 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
846 sta->reason = reason; 847 sta->reason = reason;
847 sta->plink_state = NL80211_PLINK_HOLDING; 848 sta->plink_state = NL80211_PLINK_HOLDING;
848 if (!mod_plink_timer(sta, 849 if (!mod_plink_timer(sta,
849 dot11MeshHoldingTimeout(sdata))) 850 dot11MeshHoldingTimeout(sdata)))
850 sta->ignore_plink_timer = true; 851 sta->ignore_plink_timer = true;
851 852
852 llid = sta->llid; 853 llid = sta->llid;
853 spin_unlock_bh(&sta->lock); 854 spin_unlock_bh(&sta->lock);
854 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE, 855 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
855 sta->sta.addr, llid, plid, reason); 856 sta->sta.addr, llid, plid, reason);
856 break; 857 break;
857 case OPN_ACPT: 858 case OPN_ACPT:
858 llid = sta->llid; 859 llid = sta->llid;
859 spin_unlock_bh(&sta->lock); 860 spin_unlock_bh(&sta->lock);
860 mesh_plink_frame_tx(sdata, 861 mesh_plink_frame_tx(sdata,
861 WLAN_SP_MESH_PEERING_CONFIRM, 862 WLAN_SP_MESH_PEERING_CONFIRM,
862 sta->sta.addr, llid, plid, 0); 863 sta->sta.addr, llid, plid, 0);
863 break; 864 break;
864 case CNF_ACPT: 865 case CNF_ACPT:
865 del_timer(&sta->plink_timer); 866 del_timer(&sta->plink_timer);
866 sta->plink_state = NL80211_PLINK_ESTAB; 867 sta->plink_state = NL80211_PLINK_ESTAB;
867 spin_unlock_bh(&sta->lock); 868 spin_unlock_bh(&sta->lock);
868 changed |= mesh_plink_inc_estab_count(sdata); 869 changed |= mesh_plink_inc_estab_count(sdata);
869 changed |= mesh_set_ht_prot_mode(sdata); 870 changed |= mesh_set_ht_prot_mode(sdata);
870 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n", 871 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
871 sta->sta.addr); 872 sta->sta.addr);
872 break; 873 break;
873 default: 874 default:
874 spin_unlock_bh(&sta->lock); 875 spin_unlock_bh(&sta->lock);
875 break; 876 break;
876 } 877 }
877 break; 878 break;
878 879
879 case NL80211_PLINK_CNF_RCVD: 880 case NL80211_PLINK_CNF_RCVD:
880 switch (event) { 881 switch (event) {
881 case OPN_RJCT: 882 case OPN_RJCT:
882 case CNF_RJCT: 883 case CNF_RJCT:
883 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG); 884 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
884 case CLS_ACPT: 885 case CLS_ACPT:
885 if (!reason) 886 if (!reason)
886 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE); 887 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
887 sta->reason = reason; 888 sta->reason = reason;
888 sta->plink_state = NL80211_PLINK_HOLDING; 889 sta->plink_state = NL80211_PLINK_HOLDING;
889 if (!mod_plink_timer(sta, 890 if (!mod_plink_timer(sta,
890 dot11MeshHoldingTimeout(sdata))) 891 dot11MeshHoldingTimeout(sdata)))
891 sta->ignore_plink_timer = true; 892 sta->ignore_plink_timer = true;
892 893
893 llid = sta->llid; 894 llid = sta->llid;
894 spin_unlock_bh(&sta->lock); 895 spin_unlock_bh(&sta->lock);
895 mesh_plink_frame_tx(sdata, 896 mesh_plink_frame_tx(sdata,
896 WLAN_SP_MESH_PEERING_CLOSE, 897 WLAN_SP_MESH_PEERING_CLOSE,
897 sta->sta.addr, llid, plid, reason); 898 sta->sta.addr, llid, plid, reason);
898 break; 899 break;
899 case OPN_ACPT: 900 case OPN_ACPT:
900 del_timer(&sta->plink_timer); 901 del_timer(&sta->plink_timer);
901 sta->plink_state = NL80211_PLINK_ESTAB; 902 sta->plink_state = NL80211_PLINK_ESTAB;
902 spin_unlock_bh(&sta->lock); 903 spin_unlock_bh(&sta->lock);
903 changed |= mesh_plink_inc_estab_count(sdata); 904 changed |= mesh_plink_inc_estab_count(sdata);
904 changed |= mesh_set_ht_prot_mode(sdata); 905 changed |= mesh_set_ht_prot_mode(sdata);
905 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n", 906 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
906 sta->sta.addr); 907 sta->sta.addr);
907 mesh_plink_frame_tx(sdata, 908 mesh_plink_frame_tx(sdata,
908 WLAN_SP_MESH_PEERING_CONFIRM, 909 WLAN_SP_MESH_PEERING_CONFIRM,
909 sta->sta.addr, llid, plid, 0); 910 sta->sta.addr, llid, plid, 0);
910 break; 911 break;
911 default: 912 default:
912 spin_unlock_bh(&sta->lock); 913 spin_unlock_bh(&sta->lock);
913 break; 914 break;
914 } 915 }
915 break; 916 break;
916 917
917 case NL80211_PLINK_ESTAB: 918 case NL80211_PLINK_ESTAB:
918 switch (event) { 919 switch (event) {
919 case CLS_ACPT: 920 case CLS_ACPT:
920 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE); 921 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
921 sta->reason = reason; 922 sta->reason = reason;
922 changed |= __mesh_plink_deactivate(sta); 923 changed |= __mesh_plink_deactivate(sta);
923 sta->plink_state = NL80211_PLINK_HOLDING; 924 sta->plink_state = NL80211_PLINK_HOLDING;
924 llid = sta->llid; 925 llid = sta->llid;
925 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)); 926 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
926 spin_unlock_bh(&sta->lock); 927 spin_unlock_bh(&sta->lock);
927 changed |= mesh_set_ht_prot_mode(sdata); 928 changed |= mesh_set_ht_prot_mode(sdata);
928 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE, 929 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
929 sta->sta.addr, llid, plid, reason); 930 sta->sta.addr, llid, plid, reason);
930 break; 931 break;
931 case OPN_ACPT: 932 case OPN_ACPT:
932 llid = sta->llid; 933 llid = sta->llid;
933 spin_unlock_bh(&sta->lock); 934 spin_unlock_bh(&sta->lock);
934 mesh_plink_frame_tx(sdata, 935 mesh_plink_frame_tx(sdata,
935 WLAN_SP_MESH_PEERING_CONFIRM, 936 WLAN_SP_MESH_PEERING_CONFIRM,
936 sta->sta.addr, llid, plid, 0); 937 sta->sta.addr, llid, plid, 0);
937 break; 938 break;
938 default: 939 default:
939 spin_unlock_bh(&sta->lock); 940 spin_unlock_bh(&sta->lock);
940 break; 941 break;
941 } 942 }
942 break; 943 break;
943 case NL80211_PLINK_HOLDING: 944 case NL80211_PLINK_HOLDING:
944 switch (event) { 945 switch (event) {
945 case CLS_ACPT: 946 case CLS_ACPT:
946 if (del_timer(&sta->plink_timer)) 947 if (del_timer(&sta->plink_timer))
947 sta->ignore_plink_timer = 1; 948 sta->ignore_plink_timer = 1;
948 mesh_plink_fsm_restart(sta); 949 mesh_plink_fsm_restart(sta);
949 spin_unlock_bh(&sta->lock); 950 spin_unlock_bh(&sta->lock);
950 break; 951 break;
951 case OPN_ACPT: 952 case OPN_ACPT:
952 case CNF_ACPT: 953 case CNF_ACPT:
953 case OPN_RJCT: 954 case OPN_RJCT:
954 case CNF_RJCT: 955 case CNF_RJCT:
955 llid = sta->llid; 956 llid = sta->llid;
956 reason = sta->reason; 957 reason = sta->reason;
957 spin_unlock_bh(&sta->lock); 958 spin_unlock_bh(&sta->lock);
958 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE, 959 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
959 sta->sta.addr, llid, plid, reason); 960 sta->sta.addr, llid, plid, reason);
960 break; 961 break;
961 default: 962 default:
962 spin_unlock_bh(&sta->lock); 963 spin_unlock_bh(&sta->lock);
963 } 964 }
964 break; 965 break;
965 default: 966 default:
966 /* should not get here, PLINK_BLOCKED is dealt with at the 967 /* should not get here, PLINK_BLOCKED is dealt with at the
967 * beginning of the function 968 * beginning of the function
968 */ 969 */
969 spin_unlock_bh(&sta->lock); 970 spin_unlock_bh(&sta->lock);
970 break; 971 break;
971 } 972 }
972 973
973 rcu_read_unlock(); 974 rcu_read_unlock();
974 975
975 if (changed) 976 if (changed)
976 ieee80211_bss_info_change_notify(sdata, changed); 977 ieee80211_bss_info_change_notify(sdata, changed);
977 } 978 }
978 979