aboutsummaryrefslogtreecommitdiffstats
path: root/net/mac80211/mlme.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/mac80211/mlme.c')
-rw-r--r--net/mac80211/mlme.c1646
1 files changed, 421 insertions, 1225 deletions
diff --git a/net/mac80211/mlme.c b/net/mac80211/mlme.c
index bf872cbba09..ec5a0900cba 100644
--- a/net/mac80211/mlme.c
+++ b/net/mac80211/mlme.c
@@ -15,11 +15,8 @@
15#include <linux/if_ether.h> 15#include <linux/if_ether.h>
16#include <linux/skbuff.h> 16#include <linux/skbuff.h>
17#include <linux/if_arp.h> 17#include <linux/if_arp.h>
18#include <linux/wireless.h>
19#include <linux/random.h>
20#include <linux/etherdevice.h> 18#include <linux/etherdevice.h>
21#include <linux/rtnetlink.h> 19#include <linux/rtnetlink.h>
22#include <net/iw_handler.h>
23#include <net/mac80211.h> 20#include <net/mac80211.h>
24#include <asm/unaligned.h> 21#include <asm/unaligned.h>
25 22
@@ -35,15 +32,6 @@
35#define IEEE80211_MONITORING_INTERVAL (2 * HZ) 32#define IEEE80211_MONITORING_INTERVAL (2 * HZ)
36#define IEEE80211_PROBE_INTERVAL (60 * HZ) 33#define IEEE80211_PROBE_INTERVAL (60 * HZ)
37#define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ) 34#define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
38#define IEEE80211_SCAN_INTERVAL (2 * HZ)
39#define IEEE80211_SCAN_INTERVAL_SLOW (15 * HZ)
40#define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
41
42#define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
43#define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
44
45#define IEEE80211_IBSS_MAX_STA_ENTRIES 128
46
47 35
48/* utils */ 36/* utils */
49static int ecw2cw(int ecw) 37static int ecw2cw(int ecw)
@@ -92,43 +80,6 @@ static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
92 return count; 80 return count;
93} 81}
94 82
95/* also used by mesh code */
96u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
97 struct ieee802_11_elems *elems,
98 enum ieee80211_band band)
99{
100 struct ieee80211_supported_band *sband;
101 struct ieee80211_rate *bitrates;
102 size_t num_rates;
103 u32 supp_rates;
104 int i, j;
105 sband = local->hw.wiphy->bands[band];
106
107 if (!sband) {
108 WARN_ON(1);
109 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
110 }
111
112 bitrates = sband->bitrates;
113 num_rates = sband->n_bitrates;
114 supp_rates = 0;
115 for (i = 0; i < elems->supp_rates_len +
116 elems->ext_supp_rates_len; i++) {
117 u8 rate = 0;
118 int own_rate;
119 if (i < elems->supp_rates_len)
120 rate = elems->supp_rates[i];
121 else if (elems->ext_supp_rates)
122 rate = elems->ext_supp_rates
123 [i - elems->supp_rates_len];
124 own_rate = 5 * (rate & 0x7f);
125 for (j = 0; j < num_rates; j++)
126 if (bitrates[j].bitrate == own_rate)
127 supp_rates |= BIT(j);
128 }
129 return supp_rates;
130}
131
132/* frame sending functions */ 83/* frame sending functions */
133 84
134static void add_extra_ies(struct sk_buff *skb, u8 *ies, size_t ies_len) 85static void add_extra_ies(struct sk_buff *skb, u8 *ies, size_t ies_len)
@@ -137,113 +88,9 @@ static void add_extra_ies(struct sk_buff *skb, u8 *ies, size_t ies_len)
137 memcpy(skb_put(skb, ies_len), ies, ies_len); 88 memcpy(skb_put(skb, ies_len), ies, ies_len);
138} 89}
139 90
140/* also used by scanning code */ 91static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
141void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
142 u8 *ssid, size_t ssid_len)
143{
144 struct ieee80211_local *local = sdata->local;
145 struct ieee80211_supported_band *sband;
146 struct sk_buff *skb;
147 struct ieee80211_mgmt *mgmt;
148 u8 *pos, *supp_rates, *esupp_rates = NULL;
149 int i;
150
151 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 +
152 sdata->u.sta.ie_probereq_len);
153 if (!skb) {
154 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
155 "request\n", sdata->dev->name);
156 return;
157 }
158 skb_reserve(skb, local->hw.extra_tx_headroom);
159
160 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
161 memset(mgmt, 0, 24);
162 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
163 IEEE80211_STYPE_PROBE_REQ);
164 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
165 if (dst) {
166 memcpy(mgmt->da, dst, ETH_ALEN);
167 memcpy(mgmt->bssid, dst, ETH_ALEN);
168 } else {
169 memset(mgmt->da, 0xff, ETH_ALEN);
170 memset(mgmt->bssid, 0xff, ETH_ALEN);
171 }
172 pos = skb_put(skb, 2 + ssid_len);
173 *pos++ = WLAN_EID_SSID;
174 *pos++ = ssid_len;
175 memcpy(pos, ssid, ssid_len);
176
177 supp_rates = skb_put(skb, 2);
178 supp_rates[0] = WLAN_EID_SUPP_RATES;
179 supp_rates[1] = 0;
180 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
181
182 for (i = 0; i < sband->n_bitrates; i++) {
183 struct ieee80211_rate *rate = &sband->bitrates[i];
184 if (esupp_rates) {
185 pos = skb_put(skb, 1);
186 esupp_rates[1]++;
187 } else if (supp_rates[1] == 8) {
188 esupp_rates = skb_put(skb, 3);
189 esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
190 esupp_rates[1] = 1;
191 pos = &esupp_rates[2];
192 } else {
193 pos = skb_put(skb, 1);
194 supp_rates[1]++;
195 }
196 *pos = rate->bitrate / 5;
197 }
198
199 add_extra_ies(skb, sdata->u.sta.ie_probereq,
200 sdata->u.sta.ie_probereq_len);
201
202 ieee80211_tx_skb(sdata, skb, 0);
203}
204
205static void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
206 struct ieee80211_if_sta *ifsta,
207 int transaction, u8 *extra, size_t extra_len,
208 int encrypt)
209{
210 struct ieee80211_local *local = sdata->local;
211 struct sk_buff *skb;
212 struct ieee80211_mgmt *mgmt;
213
214 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
215 sizeof(*mgmt) + 6 + extra_len +
216 sdata->u.sta.ie_auth_len);
217 if (!skb) {
218 printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
219 "frame\n", sdata->dev->name);
220 return;
221 }
222 skb_reserve(skb, local->hw.extra_tx_headroom);
223
224 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
225 memset(mgmt, 0, 24 + 6);
226 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
227 IEEE80211_STYPE_AUTH);
228 if (encrypt)
229 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
230 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN);
231 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
232 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
233 mgmt->u.auth.auth_alg = cpu_to_le16(ifsta->auth_alg);
234 mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
235 ifsta->auth_transaction = transaction + 1;
236 mgmt->u.auth.status_code = cpu_to_le16(0);
237 if (extra)
238 memcpy(skb_put(skb, extra_len), extra, extra_len);
239 add_extra_ies(skb, sdata->u.sta.ie_auth, sdata->u.sta.ie_auth_len);
240
241 ieee80211_tx_skb(sdata, skb, encrypt);
242}
243
244static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
245 struct ieee80211_if_sta *ifsta)
246{ 92{
93 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
247 struct ieee80211_local *local = sdata->local; 94 struct ieee80211_local *local = sdata->local;
248 struct sk_buff *skb; 95 struct sk_buff *skb;
249 struct ieee80211_mgmt *mgmt; 96 struct ieee80211_mgmt *mgmt;
@@ -256,17 +103,17 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
256 u32 rates = 0; 103 u32 rates = 0;
257 size_t e_ies_len; 104 size_t e_ies_len;
258 105
259 if (ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) { 106 if (ifmgd->flags & IEEE80211_IBSS_PREV_BSSID_SET) {
260 e_ies = sdata->u.sta.ie_reassocreq; 107 e_ies = sdata->u.mgd.ie_reassocreq;
261 e_ies_len = sdata->u.sta.ie_reassocreq_len; 108 e_ies_len = sdata->u.mgd.ie_reassocreq_len;
262 } else { 109 } else {
263 e_ies = sdata->u.sta.ie_assocreq; 110 e_ies = sdata->u.mgd.ie_assocreq;
264 e_ies_len = sdata->u.sta.ie_assocreq_len; 111 e_ies_len = sdata->u.mgd.ie_assocreq_len;
265 } 112 }
266 113
267 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 114 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
268 sizeof(*mgmt) + 200 + ifsta->extra_ie_len + 115 sizeof(*mgmt) + 200 + ifmgd->extra_ie_len +
269 ifsta->ssid_len + e_ies_len); 116 ifmgd->ssid_len + e_ies_len);
270 if (!skb) { 117 if (!skb) {
271 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc " 118 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
272 "frame\n", sdata->dev->name); 119 "frame\n", sdata->dev->name);
@@ -276,7 +123,7 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
276 123
277 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 124 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
278 125
279 capab = ifsta->capab; 126 capab = ifmgd->capab;
280 127
281 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) { 128 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
282 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE)) 129 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
@@ -285,9 +132,9 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
285 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE; 132 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
286 } 133 }
287 134
288 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 135 bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
289 local->hw.conf.channel->center_freq, 136 local->hw.conf.channel->center_freq,
290 ifsta->ssid, ifsta->ssid_len); 137 ifmgd->ssid, ifmgd->ssid_len);
291 if (bss) { 138 if (bss) {
292 if (bss->cbss.capability & WLAN_CAPABILITY_PRIVACY) 139 if (bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
293 capab |= WLAN_CAPABILITY_PRIVACY; 140 capab |= WLAN_CAPABILITY_PRIVACY;
@@ -312,18 +159,18 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
312 159
313 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 160 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
314 memset(mgmt, 0, 24); 161 memset(mgmt, 0, 24);
315 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN); 162 memcpy(mgmt->da, ifmgd->bssid, ETH_ALEN);
316 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 163 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
317 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 164 memcpy(mgmt->bssid, ifmgd->bssid, ETH_ALEN);
318 165
319 if (ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) { 166 if (ifmgd->flags & IEEE80211_STA_PREV_BSSID_SET) {
320 skb_put(skb, 10); 167 skb_put(skb, 10);
321 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 168 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
322 IEEE80211_STYPE_REASSOC_REQ); 169 IEEE80211_STYPE_REASSOC_REQ);
323 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab); 170 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
324 mgmt->u.reassoc_req.listen_interval = 171 mgmt->u.reassoc_req.listen_interval =
325 cpu_to_le16(local->hw.conf.listen_interval); 172 cpu_to_le16(local->hw.conf.listen_interval);
326 memcpy(mgmt->u.reassoc_req.current_ap, ifsta->prev_bssid, 173 memcpy(mgmt->u.reassoc_req.current_ap, ifmgd->prev_bssid,
327 ETH_ALEN); 174 ETH_ALEN);
328 } else { 175 } else {
329 skb_put(skb, 4); 176 skb_put(skb, 4);
@@ -335,10 +182,10 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
335 } 182 }
336 183
337 /* SSID */ 184 /* SSID */
338 ies = pos = skb_put(skb, 2 + ifsta->ssid_len); 185 ies = pos = skb_put(skb, 2 + ifmgd->ssid_len);
339 *pos++ = WLAN_EID_SSID; 186 *pos++ = WLAN_EID_SSID;
340 *pos++ = ifsta->ssid_len; 187 *pos++ = ifmgd->ssid_len;
341 memcpy(pos, ifsta->ssid, ifsta->ssid_len); 188 memcpy(pos, ifmgd->ssid, ifmgd->ssid_len);
342 189
343 /* add all rates which were marked to be used above */ 190 /* add all rates which were marked to be used above */
344 supp_rates_len = rates_len; 191 supp_rates_len = rates_len;
@@ -393,12 +240,12 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
393 } 240 }
394 } 241 }
395 242
396 if (ifsta->extra_ie) { 243 if (ifmgd->extra_ie) {
397 pos = skb_put(skb, ifsta->extra_ie_len); 244 pos = skb_put(skb, ifmgd->extra_ie_len);
398 memcpy(pos, ifsta->extra_ie, ifsta->extra_ie_len); 245 memcpy(pos, ifmgd->extra_ie, ifmgd->extra_ie_len);
399 } 246 }
400 247
401 if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED)) { 248 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
402 pos = skb_put(skb, 9); 249 pos = skb_put(skb, 9);
403 *pos++ = WLAN_EID_VENDOR_SPECIFIC; 250 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
404 *pos++ = 7; /* len */ 251 *pos++ = 7; /* len */
@@ -418,11 +265,11 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
418 * mode (11a/b/g) if any one of these ciphers is 265 * mode (11a/b/g) if any one of these ciphers is
419 * configured as pairwise. 266 * configured as pairwise.
420 */ 267 */
421 if (wmm && (ifsta->flags & IEEE80211_STA_WMM_ENABLED) && 268 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
422 sband->ht_cap.ht_supported && 269 sband->ht_cap.ht_supported &&
423 (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) && 270 (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) &&
424 ht_ie[1] >= sizeof(struct ieee80211_ht_info) && 271 ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
425 (!(ifsta->flags & IEEE80211_STA_TKIP_WEP_USED))) { 272 (!(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED))) {
426 struct ieee80211_ht_info *ht_info = 273 struct ieee80211_ht_info *ht_info =
427 (struct ieee80211_ht_info *)(ht_ie + 2); 274 (struct ieee80211_ht_info *)(ht_ie + 2);
428 u16 cap = sband->ht_cap.cap; 275 u16 cap = sband->ht_cap.cap;
@@ -459,11 +306,11 @@ static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
459 306
460 add_extra_ies(skb, e_ies, e_ies_len); 307 add_extra_ies(skb, e_ies, e_ies_len);
461 308
462 kfree(ifsta->assocreq_ies); 309 kfree(ifmgd->assocreq_ies);
463 ifsta->assocreq_ies_len = (skb->data + skb->len) - ies; 310 ifmgd->assocreq_ies_len = (skb->data + skb->len) - ies;
464 ifsta->assocreq_ies = kmalloc(ifsta->assocreq_ies_len, GFP_KERNEL); 311 ifmgd->assocreq_ies = kmalloc(ifmgd->assocreq_ies_len, GFP_KERNEL);
465 if (ifsta->assocreq_ies) 312 if (ifmgd->assocreq_ies)
466 memcpy(ifsta->assocreq_ies, ies, ifsta->assocreq_ies_len); 313 memcpy(ifmgd->assocreq_ies, ies, ifmgd->assocreq_ies_len);
467 314
468 ieee80211_tx_skb(sdata, skb, 0); 315 ieee80211_tx_skb(sdata, skb, 0);
469} 316}
@@ -473,18 +320,18 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
473 u16 stype, u16 reason) 320 u16 stype, u16 reason)
474{ 321{
475 struct ieee80211_local *local = sdata->local; 322 struct ieee80211_local *local = sdata->local;
476 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 323 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
477 struct sk_buff *skb; 324 struct sk_buff *skb;
478 struct ieee80211_mgmt *mgmt; 325 struct ieee80211_mgmt *mgmt;
479 u8 *ies; 326 u8 *ies;
480 size_t ies_len; 327 size_t ies_len;
481 328
482 if (stype == IEEE80211_STYPE_DEAUTH) { 329 if (stype == IEEE80211_STYPE_DEAUTH) {
483 ies = sdata->u.sta.ie_deauth; 330 ies = sdata->u.mgd.ie_deauth;
484 ies_len = sdata->u.sta.ie_deauth_len; 331 ies_len = sdata->u.mgd.ie_deauth_len;
485 } else { 332 } else {
486 ies = sdata->u.sta.ie_disassoc; 333 ies = sdata->u.mgd.ie_disassoc;
487 ies_len = sdata->u.sta.ie_disassoc_len; 334 ies_len = sdata->u.mgd.ie_disassoc_len;
488 } 335 }
489 336
490 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 337 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) +
@@ -498,9 +345,9 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
498 345
499 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24); 346 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
500 memset(mgmt, 0, 24); 347 memset(mgmt, 0, 24);
501 memcpy(mgmt->da, ifsta->bssid, ETH_ALEN); 348 memcpy(mgmt->da, ifmgd->bssid, ETH_ALEN);
502 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); 349 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
503 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN); 350 memcpy(mgmt->bssid, ifmgd->bssid, ETH_ALEN);
504 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype); 351 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
505 skb_put(skb, 2); 352 skb_put(skb, 2);
506 /* u.deauth.reason_code == u.disassoc.reason_code */ 353 /* u.deauth.reason_code == u.disassoc.reason_code */
@@ -508,13 +355,13 @@ static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
508 355
509 add_extra_ies(skb, ies, ies_len); 356 add_extra_ies(skb, ies, ies_len);
510 357
511 ieee80211_tx_skb(sdata, skb, ifsta->flags & IEEE80211_STA_MFP_ENABLED); 358 ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);
512} 359}
513 360
514void ieee80211_send_pspoll(struct ieee80211_local *local, 361void ieee80211_send_pspoll(struct ieee80211_local *local,
515 struct ieee80211_sub_if_data *sdata) 362 struct ieee80211_sub_if_data *sdata)
516{ 363{
517 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 364 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
518 struct ieee80211_pspoll *pspoll; 365 struct ieee80211_pspoll *pspoll;
519 struct sk_buff *skb; 366 struct sk_buff *skb;
520 u16 fc; 367 u16 fc;
@@ -531,43 +378,20 @@ void ieee80211_send_pspoll(struct ieee80211_local *local,
531 memset(pspoll, 0, sizeof(*pspoll)); 378 memset(pspoll, 0, sizeof(*pspoll));
532 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM; 379 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
533 pspoll->frame_control = cpu_to_le16(fc); 380 pspoll->frame_control = cpu_to_le16(fc);
534 pspoll->aid = cpu_to_le16(ifsta->aid); 381 pspoll->aid = cpu_to_le16(ifmgd->aid);
535 382
536 /* aid in PS-Poll has its two MSBs each set to 1 */ 383 /* aid in PS-Poll has its two MSBs each set to 1 */
537 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14); 384 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
538 385
539 memcpy(pspoll->bssid, ifsta->bssid, ETH_ALEN); 386 memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
540 memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN); 387 memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);
541 388
542 ieee80211_tx_skb(sdata, skb, 0); 389 ieee80211_tx_skb(sdata, skb, 0);
543
544 return;
545} 390}
546 391
547/* MLME */ 392/* MLME */
548static void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
549 const size_t supp_rates_len,
550 const u8 *supp_rates)
551{
552 struct ieee80211_local *local = sdata->local;
553 int i, have_higher_than_11mbit = 0;
554
555 /* cf. IEEE 802.11 9.2.12 */
556 for (i = 0; i < supp_rates_len; i++)
557 if ((supp_rates[i] & 0x7f) * 5 > 110)
558 have_higher_than_11mbit = 1;
559
560 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
561 have_higher_than_11mbit)
562 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
563 else
564 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
565
566 ieee80211_set_wmm_default(sdata);
567}
568
569static void ieee80211_sta_wmm_params(struct ieee80211_local *local, 393static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
570 struct ieee80211_if_sta *ifsta, 394 struct ieee80211_if_managed *ifmgd,
571 u8 *wmm_param, size_t wmm_param_len) 395 u8 *wmm_param, size_t wmm_param_len)
572{ 396{
573 struct ieee80211_tx_queue_params params; 397 struct ieee80211_tx_queue_params params;
@@ -575,7 +399,7 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
575 int count; 399 int count;
576 u8 *pos; 400 u8 *pos;
577 401
578 if (!(ifsta->flags & IEEE80211_STA_WMM_ENABLED)) 402 if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
579 return; 403 return;
580 404
581 if (!wmm_param) 405 if (!wmm_param)
@@ -584,9 +408,9 @@ static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
584 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1) 408 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
585 return; 409 return;
586 count = wmm_param[6] & 0x0f; 410 count = wmm_param[6] & 0x0f;
587 if (count == ifsta->wmm_last_param_set) 411 if (count == ifmgd->wmm_last_param_set)
588 return; 412 return;
589 ifsta->wmm_last_param_set = count; 413 ifmgd->wmm_last_param_set = count;
590 414
591 pos = wmm_param + 8; 415 pos = wmm_param + 8;
592 left = wmm_param_len - 8; 416 left = wmm_param_len - 8;
@@ -671,7 +495,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
671{ 495{
672 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf; 496 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
673#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 497#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
674 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 498 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
675#endif 499#endif
676 u32 changed = 0; 500 u32 changed = 0;
677 bool use_protection; 501 bool use_protection;
@@ -694,7 +518,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
694 printk(KERN_DEBUG "%s: CTS protection %s (BSSID=%pM)\n", 518 printk(KERN_DEBUG "%s: CTS protection %s (BSSID=%pM)\n",
695 sdata->dev->name, 519 sdata->dev->name,
696 use_protection ? "enabled" : "disabled", 520 use_protection ? "enabled" : "disabled",
697 ifsta->bssid); 521 ifmgd->bssid);
698 } 522 }
699#endif 523#endif
700 bss_conf->use_cts_prot = use_protection; 524 bss_conf->use_cts_prot = use_protection;
@@ -708,7 +532,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
708 " (BSSID=%pM)\n", 532 " (BSSID=%pM)\n",
709 sdata->dev->name, 533 sdata->dev->name,
710 use_short_preamble ? "short" : "long", 534 use_short_preamble ? "short" : "long",
711 ifsta->bssid); 535 ifmgd->bssid);
712 } 536 }
713#endif 537#endif
714 bss_conf->use_short_preamble = use_short_preamble; 538 bss_conf->use_short_preamble = use_short_preamble;
@@ -722,7 +546,7 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
722 " (BSSID=%pM)\n", 546 " (BSSID=%pM)\n",
723 sdata->dev->name, 547 sdata->dev->name,
724 use_short_slot ? "short" : "long", 548 use_short_slot ? "short" : "long",
725 ifsta->bssid); 549 ifmgd->bssid);
726 } 550 }
727#endif 551#endif
728 bss_conf->use_short_slot = use_short_slot; 552 bss_conf->use_short_slot = use_short_slot;
@@ -732,57 +556,57 @@ static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
732 return changed; 556 return changed;
733} 557}
734 558
735static void ieee80211_sta_send_apinfo(struct ieee80211_sub_if_data *sdata, 559static void ieee80211_sta_send_apinfo(struct ieee80211_sub_if_data *sdata)
736 struct ieee80211_if_sta *ifsta)
737{ 560{
738 union iwreq_data wrqu; 561 union iwreq_data wrqu;
562
739 memset(&wrqu, 0, sizeof(wrqu)); 563 memset(&wrqu, 0, sizeof(wrqu));
740 if (ifsta->flags & IEEE80211_STA_ASSOCIATED) 564 if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED)
741 memcpy(wrqu.ap_addr.sa_data, sdata->u.sta.bssid, ETH_ALEN); 565 memcpy(wrqu.ap_addr.sa_data, sdata->u.mgd.bssid, ETH_ALEN);
742 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 566 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
743 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL); 567 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
744} 568}
745 569
746static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata, 570static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata)
747 struct ieee80211_if_sta *ifsta)
748{ 571{
572 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
749 char *buf; 573 char *buf;
750 size_t len; 574 size_t len;
751 int i; 575 int i;
752 union iwreq_data wrqu; 576 union iwreq_data wrqu;
753 577
754 if (!ifsta->assocreq_ies && !ifsta->assocresp_ies) 578 if (!ifmgd->assocreq_ies && !ifmgd->assocresp_ies)
755 return; 579 return;
756 580
757 buf = kmalloc(50 + 2 * (ifsta->assocreq_ies_len + 581 buf = kmalloc(50 + 2 * (ifmgd->assocreq_ies_len +
758 ifsta->assocresp_ies_len), GFP_KERNEL); 582 ifmgd->assocresp_ies_len), GFP_KERNEL);
759 if (!buf) 583 if (!buf)
760 return; 584 return;
761 585
762 len = sprintf(buf, "ASSOCINFO("); 586 len = sprintf(buf, "ASSOCINFO(");
763 if (ifsta->assocreq_ies) { 587 if (ifmgd->assocreq_ies) {
764 len += sprintf(buf + len, "ReqIEs="); 588 len += sprintf(buf + len, "ReqIEs=");
765 for (i = 0; i < ifsta->assocreq_ies_len; i++) { 589 for (i = 0; i < ifmgd->assocreq_ies_len; i++) {
766 len += sprintf(buf + len, "%02x", 590 len += sprintf(buf + len, "%02x",
767 ifsta->assocreq_ies[i]); 591 ifmgd->assocreq_ies[i]);
768 } 592 }
769 } 593 }
770 if (ifsta->assocresp_ies) { 594 if (ifmgd->assocresp_ies) {
771 if (ifsta->assocreq_ies) 595 if (ifmgd->assocreq_ies)
772 len += sprintf(buf + len, " "); 596 len += sprintf(buf + len, " ");
773 len += sprintf(buf + len, "RespIEs="); 597 len += sprintf(buf + len, "RespIEs=");
774 for (i = 0; i < ifsta->assocresp_ies_len; i++) { 598 for (i = 0; i < ifmgd->assocresp_ies_len; i++) {
775 len += sprintf(buf + len, "%02x", 599 len += sprintf(buf + len, "%02x",
776 ifsta->assocresp_ies[i]); 600 ifmgd->assocresp_ies[i]);
777 } 601 }
778 } 602 }
779 len += sprintf(buf + len, ")"); 603 len += sprintf(buf + len, ")");
780 604
781 if (len > IW_CUSTOM_MAX) { 605 if (len > IW_CUSTOM_MAX) {
782 len = sprintf(buf, "ASSOCRESPIE="); 606 len = sprintf(buf, "ASSOCRESPIE=");
783 for (i = 0; i < ifsta->assocresp_ies_len; i++) { 607 for (i = 0; i < ifmgd->assocresp_ies_len; i++) {
784 len += sprintf(buf + len, "%02x", 608 len += sprintf(buf + len, "%02x",
785 ifsta->assocresp_ies[i]); 609 ifmgd->assocresp_ies[i]);
786 } 610 }
787 } 611 }
788 612
@@ -797,20 +621,20 @@ static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata,
797 621
798 622
799static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata, 623static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
800 struct ieee80211_if_sta *ifsta,
801 u32 bss_info_changed) 624 u32 bss_info_changed)
802{ 625{
626 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
803 struct ieee80211_local *local = sdata->local; 627 struct ieee80211_local *local = sdata->local;
804 struct ieee80211_conf *conf = &local_to_hw(local)->conf; 628 struct ieee80211_conf *conf = &local_to_hw(local)->conf;
805 629
806 struct ieee80211_bss *bss; 630 struct ieee80211_bss *bss;
807 631
808 bss_info_changed |= BSS_CHANGED_ASSOC; 632 bss_info_changed |= BSS_CHANGED_ASSOC;
809 ifsta->flags |= IEEE80211_STA_ASSOCIATED; 633 ifmgd->flags |= IEEE80211_STA_ASSOCIATED;
810 634
811 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 635 bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
812 conf->channel->center_freq, 636 conf->channel->center_freq,
813 ifsta->ssid, ifsta->ssid_len); 637 ifmgd->ssid, ifmgd->ssid_len);
814 if (bss) { 638 if (bss) {
815 /* set timing information */ 639 /* set timing information */
816 sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval; 640 sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
@@ -823,11 +647,11 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
823 ieee80211_rx_bss_put(local, bss); 647 ieee80211_rx_bss_put(local, bss);
824 } 648 }
825 649
826 ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET; 650 ifmgd->flags |= IEEE80211_STA_PREV_BSSID_SET;
827 memcpy(ifsta->prev_bssid, sdata->u.sta.bssid, ETH_ALEN); 651 memcpy(ifmgd->prev_bssid, sdata->u.mgd.bssid, ETH_ALEN);
828 ieee80211_sta_send_associnfo(sdata, ifsta); 652 ieee80211_sta_send_associnfo(sdata);
829 653
830 ifsta->last_probe = jiffies; 654 ifmgd->last_probe = jiffies;
831 ieee80211_led_assoc(local, 1); 655 ieee80211_led_assoc(local, 1);
832 656
833 sdata->vif.bss_conf.assoc = 1; 657 sdata->vif.bss_conf.assoc = 1;
@@ -856,70 +680,74 @@ static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
856 netif_tx_start_all_queues(sdata->dev); 680 netif_tx_start_all_queues(sdata->dev);
857 netif_carrier_on(sdata->dev); 681 netif_carrier_on(sdata->dev);
858 682
859 ieee80211_sta_send_apinfo(sdata, ifsta); 683 ieee80211_sta_send_apinfo(sdata);
860} 684}
861 685
862static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata, 686static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata)
863 struct ieee80211_if_sta *ifsta)
864{ 687{
865 ifsta->direct_probe_tries++; 688 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
866 if (ifsta->direct_probe_tries > IEEE80211_AUTH_MAX_TRIES) { 689
690 ifmgd->direct_probe_tries++;
691 if (ifmgd->direct_probe_tries > IEEE80211_AUTH_MAX_TRIES) {
867 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n", 692 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
868 sdata->dev->name, ifsta->bssid); 693 sdata->dev->name, ifmgd->bssid);
869 ifsta->state = IEEE80211_STA_MLME_DISABLED; 694 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
870 ieee80211_sta_send_apinfo(sdata, ifsta); 695 ieee80211_sta_send_apinfo(sdata);
871 696
872 /* 697 /*
873 * Most likely AP is not in the range so remove the 698 * Most likely AP is not in the range so remove the
874 * bss information associated to the AP 699 * bss information associated to the AP
875 */ 700 */
876 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 701 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
877 sdata->local->hw.conf.channel->center_freq, 702 sdata->local->hw.conf.channel->center_freq,
878 ifsta->ssid, ifsta->ssid_len); 703 ifmgd->ssid, ifmgd->ssid_len);
879 return; 704 return;
880 } 705 }
881 706
882 printk(KERN_DEBUG "%s: direct probe to AP %pM try %d\n", 707 printk(KERN_DEBUG "%s: direct probe to AP %pM try %d\n",
883 sdata->dev->name, ifsta->bssid, 708 sdata->dev->name, ifmgd->bssid,
884 ifsta->direct_probe_tries); 709 ifmgd->direct_probe_tries);
885 710
886 ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE; 711 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
887 712
888 set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifsta->request); 713 set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifmgd->request);
889 714
890 /* Direct probe is sent to broadcast address as some APs 715 /* Direct probe is sent to broadcast address as some APs
891 * will not answer to direct packet in unassociated state. 716 * will not answer to direct packet in unassociated state.
892 */ 717 */
893 ieee80211_send_probe_req(sdata, NULL, 718 ieee80211_send_probe_req(sdata, NULL,
894 ifsta->ssid, ifsta->ssid_len); 719 ifmgd->ssid, ifmgd->ssid_len);
895 720
896 mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT); 721 mod_timer(&ifmgd->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
897} 722}
898 723
899 724
900static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata, 725static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata)
901 struct ieee80211_if_sta *ifsta)
902{ 726{
903 ifsta->auth_tries++; 727 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
904 if (ifsta->auth_tries > IEEE80211_AUTH_MAX_TRIES) { 728
729 ifmgd->auth_tries++;
730 if (ifmgd->auth_tries > IEEE80211_AUTH_MAX_TRIES) {
905 printk(KERN_DEBUG "%s: authentication with AP %pM" 731 printk(KERN_DEBUG "%s: authentication with AP %pM"
906 " timed out\n", 732 " timed out\n",
907 sdata->dev->name, ifsta->bssid); 733 sdata->dev->name, ifmgd->bssid);
908 ifsta->state = IEEE80211_STA_MLME_DISABLED; 734 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
909 ieee80211_sta_send_apinfo(sdata, ifsta); 735 ieee80211_sta_send_apinfo(sdata);
910 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 736 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
911 sdata->local->hw.conf.channel->center_freq, 737 sdata->local->hw.conf.channel->center_freq,
912 ifsta->ssid, ifsta->ssid_len); 738 ifmgd->ssid, ifmgd->ssid_len);
913 return; 739 return;
914 } 740 }
915 741
916 ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; 742 ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
917 printk(KERN_DEBUG "%s: authenticate with AP %pM\n", 743 printk(KERN_DEBUG "%s: authenticate with AP %pM\n",
918 sdata->dev->name, ifsta->bssid); 744 sdata->dev->name, ifmgd->bssid);
919 745
920 ieee80211_send_auth(sdata, ifsta, 1, NULL, 0, 0); 746 ieee80211_send_auth(sdata, 1, ifmgd->auth_alg, NULL, 0,
747 ifmgd->bssid, 0);
748 ifmgd->auth_transaction = 2;
921 749
922 mod_timer(&ifsta->timer, jiffies + IEEE80211_AUTH_TIMEOUT); 750 mod_timer(&ifmgd->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
923} 751}
924 752
925/* 753/*
@@ -927,27 +755,28 @@ static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
927 * if self disconnected or a reason code from the AP. 755 * if self disconnected or a reason code from the AP.
928 */ 756 */
929static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata, 757static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
930 struct ieee80211_if_sta *ifsta, bool deauth, 758 bool deauth, bool self_disconnected,
931 bool self_disconnected, u16 reason) 759 u16 reason)
932{ 760{
761 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
933 struct ieee80211_local *local = sdata->local; 762 struct ieee80211_local *local = sdata->local;
934 struct sta_info *sta; 763 struct sta_info *sta;
935 u32 changed = 0, config_changed = 0; 764 u32 changed = 0, config_changed = 0;
936 765
937 rcu_read_lock(); 766 rcu_read_lock();
938 767
939 sta = sta_info_get(local, ifsta->bssid); 768 sta = sta_info_get(local, ifmgd->bssid);
940 if (!sta) { 769 if (!sta) {
941 rcu_read_unlock(); 770 rcu_read_unlock();
942 return; 771 return;
943 } 772 }
944 773
945 if (deauth) { 774 if (deauth) {
946 ifsta->direct_probe_tries = 0; 775 ifmgd->direct_probe_tries = 0;
947 ifsta->auth_tries = 0; 776 ifmgd->auth_tries = 0;
948 } 777 }
949 ifsta->assoc_scan_tries = 0; 778 ifmgd->assoc_scan_tries = 0;
950 ifsta->assoc_tries = 0; 779 ifmgd->assoc_tries = 0;
951 780
952 netif_tx_stop_all_queues(sdata->dev); 781 netif_tx_stop_all_queues(sdata->dev);
953 netif_carrier_off(sdata->dev); 782 netif_carrier_off(sdata->dev);
@@ -963,20 +792,20 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
963 IEEE80211_STYPE_DISASSOC, reason); 792 IEEE80211_STYPE_DISASSOC, reason);
964 } 793 }
965 794
966 ifsta->flags &= ~IEEE80211_STA_ASSOCIATED; 795 ifmgd->flags &= ~IEEE80211_STA_ASSOCIATED;
967 changed |= ieee80211_reset_erp_info(sdata); 796 changed |= ieee80211_reset_erp_info(sdata);
968 797
969 ieee80211_led_assoc(local, 0); 798 ieee80211_led_assoc(local, 0);
970 changed |= BSS_CHANGED_ASSOC; 799 changed |= BSS_CHANGED_ASSOC;
971 sdata->vif.bss_conf.assoc = false; 800 sdata->vif.bss_conf.assoc = false;
972 801
973 ieee80211_sta_send_apinfo(sdata, ifsta); 802 ieee80211_sta_send_apinfo(sdata);
974 803
975 if (self_disconnected || reason == WLAN_REASON_DISASSOC_STA_HAS_LEFT) { 804 if (self_disconnected || reason == WLAN_REASON_DISASSOC_STA_HAS_LEFT) {
976 ifsta->state = IEEE80211_STA_MLME_DISABLED; 805 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
977 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 806 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
978 sdata->local->hw.conf.channel->center_freq, 807 sdata->local->hw.conf.channel->center_freq,
979 ifsta->ssid, ifsta->ssid_len); 808 ifmgd->ssid, ifmgd->ssid_len);
980 } 809 }
981 810
982 rcu_read_unlock(); 811 rcu_read_unlock();
@@ -999,7 +828,7 @@ static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
999 828
1000 rcu_read_lock(); 829 rcu_read_lock();
1001 830
1002 sta = sta_info_get(local, ifsta->bssid); 831 sta = sta_info_get(local, ifmgd->bssid);
1003 if (!sta) { 832 if (!sta) {
1004 rcu_read_unlock(); 833 rcu_read_unlock();
1005 return; 834 return;
@@ -1020,27 +849,27 @@ static int ieee80211_sta_wep_configured(struct ieee80211_sub_if_data *sdata)
1020 return 1; 849 return 1;
1021} 850}
1022 851
1023static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata, 852static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata)
1024 struct ieee80211_if_sta *ifsta)
1025{ 853{
854 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1026 struct ieee80211_local *local = sdata->local; 855 struct ieee80211_local *local = sdata->local;
1027 struct ieee80211_bss *bss; 856 struct ieee80211_bss *bss;
1028 int bss_privacy; 857 int bss_privacy;
1029 int wep_privacy; 858 int wep_privacy;
1030 int privacy_invoked; 859 int privacy_invoked;
1031 860
1032 if (!ifsta || (ifsta->flags & IEEE80211_STA_MIXED_CELL)) 861 if (!ifmgd || (ifmgd->flags & IEEE80211_STA_MIXED_CELL))
1033 return 0; 862 return 0;
1034 863
1035 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 864 bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
1036 local->hw.conf.channel->center_freq, 865 local->hw.conf.channel->center_freq,
1037 ifsta->ssid, ifsta->ssid_len); 866 ifmgd->ssid, ifmgd->ssid_len);
1038 if (!bss) 867 if (!bss)
1039 return 0; 868 return 0;
1040 869
1041 bss_privacy = !!(bss->cbss.capability & WLAN_CAPABILITY_PRIVACY); 870 bss_privacy = !!(bss->cbss.capability & WLAN_CAPABILITY_PRIVACY);
1042 wep_privacy = !!ieee80211_sta_wep_configured(sdata); 871 wep_privacy = !!ieee80211_sta_wep_configured(sdata);
1043 privacy_invoked = !!(ifsta->flags & IEEE80211_STA_PRIVACY_INVOKED); 872 privacy_invoked = !!(ifmgd->flags & IEEE80211_STA_PRIVACY_INVOKED);
1044 873
1045 ieee80211_rx_bss_put(local, bss); 874 ieee80211_rx_bss_put(local, bss);
1046 875
@@ -1050,41 +879,42 @@ static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata,
1050 return 1; 879 return 1;
1051} 880}
1052 881
1053static void ieee80211_associate(struct ieee80211_sub_if_data *sdata, 882static void ieee80211_associate(struct ieee80211_sub_if_data *sdata)
1054 struct ieee80211_if_sta *ifsta)
1055{ 883{
1056 ifsta->assoc_tries++; 884 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1057 if (ifsta->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) { 885
886 ifmgd->assoc_tries++;
887 if (ifmgd->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) {
1058 printk(KERN_DEBUG "%s: association with AP %pM" 888 printk(KERN_DEBUG "%s: association with AP %pM"
1059 " timed out\n", 889 " timed out\n",
1060 sdata->dev->name, ifsta->bssid); 890 sdata->dev->name, ifmgd->bssid);
1061 ifsta->state = IEEE80211_STA_MLME_DISABLED; 891 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
1062 ieee80211_sta_send_apinfo(sdata, ifsta); 892 ieee80211_sta_send_apinfo(sdata);
1063 ieee80211_rx_bss_remove(sdata, ifsta->bssid, 893 ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
1064 sdata->local->hw.conf.channel->center_freq, 894 sdata->local->hw.conf.channel->center_freq,
1065 ifsta->ssid, ifsta->ssid_len); 895 ifmgd->ssid, ifmgd->ssid_len);
1066 return; 896 return;
1067 } 897 }
1068 898
1069 ifsta->state = IEEE80211_STA_MLME_ASSOCIATE; 899 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATE;
1070 printk(KERN_DEBUG "%s: associate with AP %pM\n", 900 printk(KERN_DEBUG "%s: associate with AP %pM\n",
1071 sdata->dev->name, ifsta->bssid); 901 sdata->dev->name, ifmgd->bssid);
1072 if (ieee80211_privacy_mismatch(sdata, ifsta)) { 902 if (ieee80211_privacy_mismatch(sdata)) {
1073 printk(KERN_DEBUG "%s: mismatch in privacy configuration and " 903 printk(KERN_DEBUG "%s: mismatch in privacy configuration and "
1074 "mixed-cell disabled - abort association\n", sdata->dev->name); 904 "mixed-cell disabled - abort association\n", sdata->dev->name);
1075 ifsta->state = IEEE80211_STA_MLME_DISABLED; 905 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
1076 return; 906 return;
1077 } 907 }
1078 908
1079 ieee80211_send_assoc(sdata, ifsta); 909 ieee80211_send_assoc(sdata);
1080 910
1081 mod_timer(&ifsta->timer, jiffies + IEEE80211_ASSOC_TIMEOUT); 911 mod_timer(&ifmgd->timer, jiffies + IEEE80211_ASSOC_TIMEOUT);
1082} 912}
1083 913
1084 914
1085static void ieee80211_associated(struct ieee80211_sub_if_data *sdata, 915static void ieee80211_associated(struct ieee80211_sub_if_data *sdata)
1086 struct ieee80211_if_sta *ifsta)
1087{ 916{
917 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1088 struct ieee80211_local *local = sdata->local; 918 struct ieee80211_local *local = sdata->local;
1089 struct sta_info *sta; 919 struct sta_info *sta;
1090 int disassoc; 920 int disassoc;
@@ -1094,38 +924,38 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
1094 * for better APs. */ 924 * for better APs. */
1095 /* TODO: remove expired BSSes */ 925 /* TODO: remove expired BSSes */
1096 926
1097 ifsta->state = IEEE80211_STA_MLME_ASSOCIATED; 927 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATED;
1098 928
1099 rcu_read_lock(); 929 rcu_read_lock();
1100 930
1101 sta = sta_info_get(local, ifsta->bssid); 931 sta = sta_info_get(local, ifmgd->bssid);
1102 if (!sta) { 932 if (!sta) {
1103 printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n", 933 printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n",
1104 sdata->dev->name, ifsta->bssid); 934 sdata->dev->name, ifmgd->bssid);
1105 disassoc = 1; 935 disassoc = 1;
1106 } else { 936 } else {
1107 disassoc = 0; 937 disassoc = 0;
1108 if (time_after(jiffies, 938 if (time_after(jiffies,
1109 sta->last_rx + IEEE80211_MONITORING_INTERVAL)) { 939 sta->last_rx + IEEE80211_MONITORING_INTERVAL)) {
1110 if (ifsta->flags & IEEE80211_STA_PROBEREQ_POLL) { 940 if (ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL) {
1111 printk(KERN_DEBUG "%s: No ProbeResp from " 941 printk(KERN_DEBUG "%s: No ProbeResp from "
1112 "current AP %pM - assume out of " 942 "current AP %pM - assume out of "
1113 "range\n", 943 "range\n",
1114 sdata->dev->name, ifsta->bssid); 944 sdata->dev->name, ifmgd->bssid);
1115 disassoc = 1; 945 disassoc = 1;
1116 } else 946 } else
1117 ieee80211_send_probe_req(sdata, ifsta->bssid, 947 ieee80211_send_probe_req(sdata, ifmgd->bssid,
1118 ifsta->ssid, 948 ifmgd->ssid,
1119 ifsta->ssid_len); 949 ifmgd->ssid_len);
1120 ifsta->flags ^= IEEE80211_STA_PROBEREQ_POLL; 950 ifmgd->flags ^= IEEE80211_STA_PROBEREQ_POLL;
1121 } else { 951 } else {
1122 ifsta->flags &= ~IEEE80211_STA_PROBEREQ_POLL; 952 ifmgd->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
1123 if (time_after(jiffies, ifsta->last_probe + 953 if (time_after(jiffies, ifmgd->last_probe +
1124 IEEE80211_PROBE_INTERVAL)) { 954 IEEE80211_PROBE_INTERVAL)) {
1125 ifsta->last_probe = jiffies; 955 ifmgd->last_probe = jiffies;
1126 ieee80211_send_probe_req(sdata, ifsta->bssid, 956 ieee80211_send_probe_req(sdata, ifmgd->bssid,
1127 ifsta->ssid, 957 ifmgd->ssid,
1128 ifsta->ssid_len); 958 ifmgd->ssid_len);
1129 } 959 }
1130 } 960 }
1131 } 961 }
@@ -1133,25 +963,25 @@ static void ieee80211_associated(struct ieee80211_sub_if_data *sdata,
1133 rcu_read_unlock(); 963 rcu_read_unlock();
1134 964
1135 if (disassoc) 965 if (disassoc)
1136 ieee80211_set_disassoc(sdata, ifsta, true, true, 966 ieee80211_set_disassoc(sdata, true, true,
1137 WLAN_REASON_PREV_AUTH_NOT_VALID); 967 WLAN_REASON_PREV_AUTH_NOT_VALID);
1138 else 968 else
1139 mod_timer(&ifsta->timer, jiffies + 969 mod_timer(&ifmgd->timer, jiffies +
1140 IEEE80211_MONITORING_INTERVAL); 970 IEEE80211_MONITORING_INTERVAL);
1141} 971}
1142 972
1143 973
1144static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata, 974static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata)
1145 struct ieee80211_if_sta *ifsta)
1146{ 975{
976 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
977
1147 printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name); 978 printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
1148 ifsta->flags |= IEEE80211_STA_AUTHENTICATED; 979 ifmgd->flags |= IEEE80211_STA_AUTHENTICATED;
1149 ieee80211_associate(sdata, ifsta); 980 ieee80211_associate(sdata);
1150} 981}
1151 982
1152 983
1153static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata, 984static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1154 struct ieee80211_if_sta *ifsta,
1155 struct ieee80211_mgmt *mgmt, 985 struct ieee80211_mgmt *mgmt,
1156 size_t len) 986 size_t len)
1157{ 987{
@@ -1162,59 +992,37 @@ static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1162 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems); 992 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1163 if (!elems.challenge) 993 if (!elems.challenge)
1164 return; 994 return;
1165 ieee80211_send_auth(sdata, ifsta, 3, elems.challenge - 2, 995 ieee80211_send_auth(sdata, 3, sdata->u.mgd.auth_alg,
1166 elems.challenge_len + 2, 1); 996 elems.challenge - 2, elems.challenge_len + 2,
1167} 997 sdata->u.mgd.bssid, 1);
1168 998 sdata->u.mgd.auth_transaction = 4;
1169static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
1170 struct ieee80211_if_sta *ifsta,
1171 struct ieee80211_mgmt *mgmt,
1172 size_t len)
1173{
1174 u16 auth_alg, auth_transaction, status_code;
1175
1176 if (len < 24 + 6)
1177 return;
1178
1179 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1180 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1181 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1182
1183 /*
1184 * IEEE 802.11 standard does not require authentication in IBSS
1185 * networks and most implementations do not seem to use it.
1186 * However, try to reply to authentication attempts if someone
1187 * has actually implemented this.
1188 */
1189 if (auth_alg == WLAN_AUTH_OPEN && auth_transaction == 1)
1190 ieee80211_send_auth(sdata, ifsta, 2, NULL, 0, 0);
1191} 999}
1192 1000
1193static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata, 1001static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1194 struct ieee80211_if_sta *ifsta,
1195 struct ieee80211_mgmt *mgmt, 1002 struct ieee80211_mgmt *mgmt,
1196 size_t len) 1003 size_t len)
1197{ 1004{
1005 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1198 u16 auth_alg, auth_transaction, status_code; 1006 u16 auth_alg, auth_transaction, status_code;
1199 1007
1200 if (ifsta->state != IEEE80211_STA_MLME_AUTHENTICATE) 1008 if (ifmgd->state != IEEE80211_STA_MLME_AUTHENTICATE)
1201 return; 1009 return;
1202 1010
1203 if (len < 24 + 6) 1011 if (len < 24 + 6)
1204 return; 1012 return;
1205 1013
1206 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) 1014 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN) != 0)
1207 return; 1015 return;
1208 1016
1209 if (memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0) 1017 if (memcmp(ifmgd->bssid, mgmt->bssid, ETH_ALEN) != 0)
1210 return; 1018 return;
1211 1019
1212 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg); 1020 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1213 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction); 1021 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1214 status_code = le16_to_cpu(mgmt->u.auth.status_code); 1022 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1215 1023
1216 if (auth_alg != ifsta->auth_alg || 1024 if (auth_alg != ifmgd->auth_alg ||
1217 auth_transaction != ifsta->auth_transaction) 1025 auth_transaction != ifmgd->auth_transaction)
1218 return; 1026 return;
1219 1027
1220 if (status_code != WLAN_STATUS_SUCCESS) { 1028 if (status_code != WLAN_STATUS_SUCCESS) {
@@ -1223,15 +1031,15 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1223 const int num_algs = ARRAY_SIZE(algs); 1031 const int num_algs = ARRAY_SIZE(algs);
1224 int i, pos; 1032 int i, pos;
1225 algs[0] = algs[1] = algs[2] = 0xff; 1033 algs[0] = algs[1] = algs[2] = 0xff;
1226 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN) 1034 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_OPEN)
1227 algs[0] = WLAN_AUTH_OPEN; 1035 algs[0] = WLAN_AUTH_OPEN;
1228 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY) 1036 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
1229 algs[1] = WLAN_AUTH_SHARED_KEY; 1037 algs[1] = WLAN_AUTH_SHARED_KEY;
1230 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP) 1038 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_LEAP)
1231 algs[2] = WLAN_AUTH_LEAP; 1039 algs[2] = WLAN_AUTH_LEAP;
1232 if (ifsta->auth_alg == WLAN_AUTH_OPEN) 1040 if (ifmgd->auth_alg == WLAN_AUTH_OPEN)
1233 pos = 0; 1041 pos = 0;
1234 else if (ifsta->auth_alg == WLAN_AUTH_SHARED_KEY) 1042 else if (ifmgd->auth_alg == WLAN_AUTH_SHARED_KEY)
1235 pos = 1; 1043 pos = 1;
1236 else 1044 else
1237 pos = 2; 1045 pos = 2;
@@ -1239,101 +1047,101 @@ static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1239 pos++; 1047 pos++;
1240 if (pos >= num_algs) 1048 if (pos >= num_algs)
1241 pos = 0; 1049 pos = 0;
1242 if (algs[pos] == ifsta->auth_alg || 1050 if (algs[pos] == ifmgd->auth_alg ||
1243 algs[pos] == 0xff) 1051 algs[pos] == 0xff)
1244 continue; 1052 continue;
1245 if (algs[pos] == WLAN_AUTH_SHARED_KEY && 1053 if (algs[pos] == WLAN_AUTH_SHARED_KEY &&
1246 !ieee80211_sta_wep_configured(sdata)) 1054 !ieee80211_sta_wep_configured(sdata))
1247 continue; 1055 continue;
1248 ifsta->auth_alg = algs[pos]; 1056 ifmgd->auth_alg = algs[pos];
1249 break; 1057 break;
1250 } 1058 }
1251 } 1059 }
1252 return; 1060 return;
1253 } 1061 }
1254 1062
1255 switch (ifsta->auth_alg) { 1063 switch (ifmgd->auth_alg) {
1256 case WLAN_AUTH_OPEN: 1064 case WLAN_AUTH_OPEN:
1257 case WLAN_AUTH_LEAP: 1065 case WLAN_AUTH_LEAP:
1258 ieee80211_auth_completed(sdata, ifsta); 1066 ieee80211_auth_completed(sdata);
1259 break; 1067 break;
1260 case WLAN_AUTH_SHARED_KEY: 1068 case WLAN_AUTH_SHARED_KEY:
1261 if (ifsta->auth_transaction == 4) 1069 if (ifmgd->auth_transaction == 4)
1262 ieee80211_auth_completed(sdata, ifsta); 1070 ieee80211_auth_completed(sdata);
1263 else 1071 else
1264 ieee80211_auth_challenge(sdata, ifsta, mgmt, len); 1072 ieee80211_auth_challenge(sdata, mgmt, len);
1265 break; 1073 break;
1266 } 1074 }
1267} 1075}
1268 1076
1269 1077
1270static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata, 1078static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
1271 struct ieee80211_if_sta *ifsta,
1272 struct ieee80211_mgmt *mgmt, 1079 struct ieee80211_mgmt *mgmt,
1273 size_t len) 1080 size_t len)
1274{ 1081{
1082 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1275 u16 reason_code; 1083 u16 reason_code;
1276 1084
1277 if (len < 24 + 2) 1085 if (len < 24 + 2)
1278 return; 1086 return;
1279 1087
1280 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN)) 1088 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN))
1281 return; 1089 return;
1282 1090
1283 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code); 1091 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1284 1092
1285 if (ifsta->flags & IEEE80211_STA_AUTHENTICATED) 1093 if (ifmgd->flags & IEEE80211_STA_AUTHENTICATED)
1286 printk(KERN_DEBUG "%s: deauthenticated (Reason: %u)\n", 1094 printk(KERN_DEBUG "%s: deauthenticated (Reason: %u)\n",
1287 sdata->dev->name, reason_code); 1095 sdata->dev->name, reason_code);
1288 1096
1289 if (ifsta->state == IEEE80211_STA_MLME_AUTHENTICATE || 1097 if (ifmgd->state == IEEE80211_STA_MLME_AUTHENTICATE ||
1290 ifsta->state == IEEE80211_STA_MLME_ASSOCIATE || 1098 ifmgd->state == IEEE80211_STA_MLME_ASSOCIATE ||
1291 ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) { 1099 ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
1292 ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE; 1100 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
1293 mod_timer(&ifsta->timer, jiffies + 1101 mod_timer(&ifmgd->timer, jiffies +
1294 IEEE80211_RETRY_AUTH_INTERVAL); 1102 IEEE80211_RETRY_AUTH_INTERVAL);
1295 } 1103 }
1296 1104
1297 ieee80211_set_disassoc(sdata, ifsta, true, false, 0); 1105 ieee80211_set_disassoc(sdata, true, false, 0);
1298 ifsta->flags &= ~IEEE80211_STA_AUTHENTICATED; 1106 ifmgd->flags &= ~IEEE80211_STA_AUTHENTICATED;
1299} 1107}
1300 1108
1301 1109
1302static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata, 1110static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1303 struct ieee80211_if_sta *ifsta,
1304 struct ieee80211_mgmt *mgmt, 1111 struct ieee80211_mgmt *mgmt,
1305 size_t len) 1112 size_t len)
1306{ 1113{
1114 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1307 u16 reason_code; 1115 u16 reason_code;
1308 1116
1309 if (len < 24 + 2) 1117 if (len < 24 + 2)
1310 return; 1118 return;
1311 1119
1312 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN)) 1120 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN))
1313 return; 1121 return;
1314 1122
1315 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code); 1123 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1316 1124
1317 if (ifsta->flags & IEEE80211_STA_ASSOCIATED) 1125 if (ifmgd->flags & IEEE80211_STA_ASSOCIATED)
1318 printk(KERN_DEBUG "%s: disassociated (Reason: %u)\n", 1126 printk(KERN_DEBUG "%s: disassociated (Reason: %u)\n",
1319 sdata->dev->name, reason_code); 1127 sdata->dev->name, reason_code);
1320 1128
1321 if (ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) { 1129 if (ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED) {
1322 ifsta->state = IEEE80211_STA_MLME_ASSOCIATE; 1130 ifmgd->state = IEEE80211_STA_MLME_ASSOCIATE;
1323 mod_timer(&ifsta->timer, jiffies + 1131 mod_timer(&ifmgd->timer, jiffies +
1324 IEEE80211_RETRY_AUTH_INTERVAL); 1132 IEEE80211_RETRY_AUTH_INTERVAL);
1325 } 1133 }
1326 1134
1327 ieee80211_set_disassoc(sdata, ifsta, false, false, reason_code); 1135 ieee80211_set_disassoc(sdata, false, false, reason_code);
1328} 1136}
1329 1137
1330 1138
1331static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata, 1139static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1332 struct ieee80211_if_sta *ifsta,
1333 struct ieee80211_mgmt *mgmt, 1140 struct ieee80211_mgmt *mgmt,
1334 size_t len, 1141 size_t len,
1335 int reassoc) 1142 int reassoc)
1336{ 1143{
1144 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1337 struct ieee80211_local *local = sdata->local; 1145 struct ieee80211_local *local = sdata->local;
1338 struct ieee80211_supported_band *sband; 1146 struct ieee80211_supported_band *sband;
1339 struct sta_info *sta; 1147 struct sta_info *sta;
@@ -1350,13 +1158,13 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1350 /* AssocResp and ReassocResp have identical structure, so process both 1158 /* AssocResp and ReassocResp have identical structure, so process both
1351 * of them in this function. */ 1159 * of them in this function. */
1352 1160
1353 if (ifsta->state != IEEE80211_STA_MLME_ASSOCIATE) 1161 if (ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE)
1354 return; 1162 return;
1355 1163
1356 if (len < 24 + 6) 1164 if (len < 24 + 6)
1357 return; 1165 return;
1358 1166
1359 if (memcmp(ifsta->bssid, mgmt->sa, ETH_ALEN) != 0) 1167 if (memcmp(ifmgd->bssid, mgmt->sa, ETH_ALEN) != 0)
1360 return; 1168 return;
1361 1169
1362 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info); 1170 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
@@ -1381,7 +1189,7 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1381 "comeback duration %u TU (%u ms)\n", 1189 "comeback duration %u TU (%u ms)\n",
1382 sdata->dev->name, tu, ms); 1190 sdata->dev->name, tu, ms);
1383 if (ms > IEEE80211_ASSOC_TIMEOUT) 1191 if (ms > IEEE80211_ASSOC_TIMEOUT)
1384 mod_timer(&ifsta->timer, 1192 mod_timer(&ifmgd->timer,
1385 jiffies + msecs_to_jiffies(ms)); 1193 jiffies + msecs_to_jiffies(ms));
1386 return; 1194 return;
1387 } 1195 }
@@ -1392,7 +1200,7 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1392 /* if this was a reassociation, ensure we try a "full" 1200 /* if this was a reassociation, ensure we try a "full"
1393 * association next time. This works around some broken APs 1201 * association next time. This works around some broken APs
1394 * which do not correctly reject reassociation requests. */ 1202 * which do not correctly reject reassociation requests. */
1395 ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET; 1203 ifmgd->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
1396 return; 1204 return;
1397 } 1205 }
1398 1206
@@ -1408,23 +1216,23 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1408 } 1216 }
1409 1217
1410 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name); 1218 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
1411 ifsta->aid = aid; 1219 ifmgd->aid = aid;
1412 ifsta->ap_capab = capab_info; 1220 ifmgd->ap_capab = capab_info;
1413 1221
1414 kfree(ifsta->assocresp_ies); 1222 kfree(ifmgd->assocresp_ies);
1415 ifsta->assocresp_ies_len = len - (pos - (u8 *) mgmt); 1223 ifmgd->assocresp_ies_len = len - (pos - (u8 *) mgmt);
1416 ifsta->assocresp_ies = kmalloc(ifsta->assocresp_ies_len, GFP_KERNEL); 1224 ifmgd->assocresp_ies = kmalloc(ifmgd->assocresp_ies_len, GFP_KERNEL);
1417 if (ifsta->assocresp_ies) 1225 if (ifmgd->assocresp_ies)
1418 memcpy(ifsta->assocresp_ies, pos, ifsta->assocresp_ies_len); 1226 memcpy(ifmgd->assocresp_ies, pos, ifmgd->assocresp_ies_len);
1419 1227
1420 rcu_read_lock(); 1228 rcu_read_lock();
1421 1229
1422 /* Add STA entry for the AP */ 1230 /* Add STA entry for the AP */
1423 sta = sta_info_get(local, ifsta->bssid); 1231 sta = sta_info_get(local, ifmgd->bssid);
1424 if (!sta) { 1232 if (!sta) {
1425 newsta = true; 1233 newsta = true;
1426 1234
1427 sta = sta_info_alloc(sdata, ifsta->bssid, GFP_ATOMIC); 1235 sta = sta_info_alloc(sdata, ifmgd->bssid, GFP_ATOMIC);
1428 if (!sta) { 1236 if (!sta) {
1429 printk(KERN_DEBUG "%s: failed to alloc STA entry for" 1237 printk(KERN_DEBUG "%s: failed to alloc STA entry for"
1430 " the AP\n", sdata->dev->name); 1238 " the AP\n", sdata->dev->name);
@@ -1505,7 +1313,7 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1505 1313
1506 rate_control_rate_init(sta); 1314 rate_control_rate_init(sta);
1507 1315
1508 if (ifsta->flags & IEEE80211_STA_MFP_ENABLED) 1316 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
1509 set_sta_flags(sta, WLAN_STA_MFP); 1317 set_sta_flags(sta, WLAN_STA_MFP);
1510 1318
1511 if (elems.wmm_param) 1319 if (elems.wmm_param)
@@ -1524,12 +1332,12 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1524 rcu_read_unlock(); 1332 rcu_read_unlock();
1525 1333
1526 if (elems.wmm_param) 1334 if (elems.wmm_param)
1527 ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param, 1335 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1528 elems.wmm_param_len); 1336 elems.wmm_param_len);
1529 1337
1530 if (elems.ht_info_elem && elems.wmm_param && 1338 if (elems.ht_info_elem && elems.wmm_param &&
1531 (ifsta->flags & IEEE80211_STA_WMM_ENABLED) && 1339 (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
1532 !(ifsta->flags & IEEE80211_STA_TKIP_WEP_USED)) 1340 !(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED))
1533 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem, 1341 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1534 ap_ht_cap_flags); 1342 ap_ht_cap_flags);
1535 1343
@@ -1537,163 +1345,12 @@ static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1537 * ieee80211_set_associated() will tell the driver */ 1345 * ieee80211_set_associated() will tell the driver */
1538 bss_conf->aid = aid; 1346 bss_conf->aid = aid;
1539 bss_conf->assoc_capability = capab_info; 1347 bss_conf->assoc_capability = capab_info;
1540 ieee80211_set_associated(sdata, ifsta, changed); 1348 ieee80211_set_associated(sdata, changed);
1541 1349
1542 ieee80211_associated(sdata, ifsta); 1350 ieee80211_associated(sdata);
1543} 1351}
1544 1352
1545 1353
1546static int __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
1547 struct ieee80211_if_sta *ifsta,
1548 const u8 *bssid, const int beacon_int,
1549 const int freq,
1550 const size_t supp_rates_len,
1551 const u8 *supp_rates,
1552 const u16 capability)
1553{
1554 struct ieee80211_local *local = sdata->local;
1555 int res = 0, rates, i, j;
1556 struct sk_buff *skb;
1557 struct ieee80211_mgmt *mgmt;
1558 u8 *pos;
1559 struct ieee80211_supported_band *sband;
1560 union iwreq_data wrqu;
1561
1562 if (local->ops->reset_tsf) {
1563 /* Reset own TSF to allow time synchronization work. */
1564 local->ops->reset_tsf(local_to_hw(local));
1565 }
1566
1567 if ((ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) &&
1568 memcmp(ifsta->bssid, bssid, ETH_ALEN) == 0)
1569 return res;
1570
1571 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400 +
1572 sdata->u.sta.ie_proberesp_len);
1573 if (!skb) {
1574 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
1575 "response\n", sdata->dev->name);
1576 return -ENOMEM;
1577 }
1578
1579 if (!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET)) {
1580 /* Remove possible STA entries from other IBSS networks. */
1581 sta_info_flush_delayed(sdata);
1582 }
1583
1584 memcpy(ifsta->bssid, bssid, ETH_ALEN);
1585 res = ieee80211_if_config(sdata, IEEE80211_IFCC_BSSID);
1586 if (res)
1587 return res;
1588
1589 local->hw.conf.beacon_int = beacon_int >= 10 ? beacon_int : 10;
1590
1591 sdata->drop_unencrypted = capability &
1592 WLAN_CAPABILITY_PRIVACY ? 1 : 0;
1593
1594 res = ieee80211_set_freq(sdata, freq);
1595
1596 if (res)
1597 return res;
1598
1599 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1600
1601 /* Build IBSS probe response */
1602
1603 skb_reserve(skb, local->hw.extra_tx_headroom);
1604
1605 mgmt = (struct ieee80211_mgmt *)
1606 skb_put(skb, 24 + sizeof(mgmt->u.beacon));
1607 memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
1608 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1609 IEEE80211_STYPE_PROBE_RESP);
1610 memset(mgmt->da, 0xff, ETH_ALEN);
1611 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
1612 memcpy(mgmt->bssid, ifsta->bssid, ETH_ALEN);
1613 mgmt->u.beacon.beacon_int =
1614 cpu_to_le16(local->hw.conf.beacon_int);
1615 mgmt->u.beacon.capab_info = cpu_to_le16(capability);
1616
1617 pos = skb_put(skb, 2 + ifsta->ssid_len);
1618 *pos++ = WLAN_EID_SSID;
1619 *pos++ = ifsta->ssid_len;
1620 memcpy(pos, ifsta->ssid, ifsta->ssid_len);
1621
1622 rates = supp_rates_len;
1623 if (rates > 8)
1624 rates = 8;
1625 pos = skb_put(skb, 2 + rates);
1626 *pos++ = WLAN_EID_SUPP_RATES;
1627 *pos++ = rates;
1628 memcpy(pos, supp_rates, rates);
1629
1630 if (sband->band == IEEE80211_BAND_2GHZ) {
1631 pos = skb_put(skb, 2 + 1);
1632 *pos++ = WLAN_EID_DS_PARAMS;
1633 *pos++ = 1;
1634 *pos++ = ieee80211_frequency_to_channel(freq);
1635 }
1636
1637 pos = skb_put(skb, 2 + 2);
1638 *pos++ = WLAN_EID_IBSS_PARAMS;
1639 *pos++ = 2;
1640 /* FIX: set ATIM window based on scan results */
1641 *pos++ = 0;
1642 *pos++ = 0;
1643
1644 if (supp_rates_len > 8) {
1645 rates = supp_rates_len - 8;
1646 pos = skb_put(skb, 2 + rates);
1647 *pos++ = WLAN_EID_EXT_SUPP_RATES;
1648 *pos++ = rates;
1649 memcpy(pos, &supp_rates[8], rates);
1650 }
1651
1652 add_extra_ies(skb, sdata->u.sta.ie_proberesp,
1653 sdata->u.sta.ie_proberesp_len);
1654
1655 ifsta->probe_resp = skb;
1656
1657 ieee80211_if_config(sdata, IEEE80211_IFCC_BEACON |
1658 IEEE80211_IFCC_BEACON_ENABLED);
1659
1660
1661 rates = 0;
1662 for (i = 0; i < supp_rates_len; i++) {
1663 int bitrate = (supp_rates[i] & 0x7f) * 5;
1664 for (j = 0; j < sband->n_bitrates; j++)
1665 if (sband->bitrates[j].bitrate == bitrate)
1666 rates |= BIT(j);
1667 }
1668 ifsta->supp_rates_bits[local->hw.conf.channel->band] = rates;
1669
1670 ieee80211_sta_def_wmm_params(sdata, supp_rates_len, supp_rates);
1671
1672 ifsta->flags |= IEEE80211_STA_PREV_BSSID_SET;
1673 ifsta->state = IEEE80211_STA_MLME_IBSS_JOINED;
1674 mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
1675
1676 ieee80211_led_assoc(local, true);
1677
1678 memset(&wrqu, 0, sizeof(wrqu));
1679 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
1680 wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
1681
1682 return res;
1683}
1684
1685static int ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
1686 struct ieee80211_if_sta *ifsta,
1687 struct ieee80211_bss *bss)
1688{
1689 return __ieee80211_sta_join_ibss(sdata, ifsta,
1690 bss->cbss.bssid,
1691 bss->cbss.beacon_interval,
1692 bss->cbss.channel->center_freq,
1693 bss->supp_rates_len, bss->supp_rates,
1694 bss->cbss.capability);
1695}
1696
1697static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata, 1354static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1698 struct ieee80211_mgmt *mgmt, 1355 struct ieee80211_mgmt *mgmt,
1699 size_t len, 1356 size_t len,
@@ -1704,11 +1361,7 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1704 struct ieee80211_local *local = sdata->local; 1361 struct ieee80211_local *local = sdata->local;
1705 int freq; 1362 int freq;
1706 struct ieee80211_bss *bss; 1363 struct ieee80211_bss *bss;
1707 struct sta_info *sta;
1708 struct ieee80211_channel *channel; 1364 struct ieee80211_channel *channel;
1709 u64 beacon_timestamp, rx_timestamp;
1710 u32 supp_rates = 0;
1711 enum ieee80211_band band = rx_status->band;
1712 1365
1713 if (elems->ds_params && elems->ds_params_len == 1) 1366 if (elems->ds_params && elems->ds_params_len == 1)
1714 freq = ieee80211_channel_to_frequency(elems->ds_params[0]); 1367 freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
@@ -1720,133 +1373,18 @@ static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1720 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 1373 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
1721 return; 1374 return;
1722 1375
1723 if (sdata->vif.type == NL80211_IFTYPE_ADHOC && elems->supp_rates &&
1724 memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0) {
1725 supp_rates = ieee80211_sta_get_rates(local, elems, band);
1726
1727 rcu_read_lock();
1728
1729 sta = sta_info_get(local, mgmt->sa);
1730 if (sta) {
1731 u32 prev_rates;
1732
1733 prev_rates = sta->sta.supp_rates[band];
1734 /* make sure mandatory rates are always added */
1735 sta->sta.supp_rates[band] = supp_rates |
1736 ieee80211_mandatory_rates(local, band);
1737
1738#ifdef CONFIG_MAC80211_IBSS_DEBUG
1739 if (sta->sta.supp_rates[band] != prev_rates)
1740 printk(KERN_DEBUG "%s: updated supp_rates set "
1741 "for %pM based on beacon info (0x%llx | "
1742 "0x%llx -> 0x%llx)\n",
1743 sdata->dev->name,
1744 sta->sta.addr,
1745 (unsigned long long) prev_rates,
1746 (unsigned long long) supp_rates,
1747 (unsigned long long) sta->sta.supp_rates[band]);
1748#endif
1749 } else {
1750 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
1751 }
1752
1753 rcu_read_unlock();
1754 }
1755
1756 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems, 1376 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
1757 channel, beacon); 1377 channel, beacon);
1758 if (!bss) 1378 if (!bss)
1759 return; 1379 return;
1760 1380
1761 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) && 1381 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
1762 (memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0)) { 1382 (memcmp(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN) == 0)) {
1763 struct ieee80211_channel_sw_ie *sw_elem = 1383 struct ieee80211_channel_sw_ie *sw_elem =
1764 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem; 1384 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
1765 ieee80211_process_chanswitch(sdata, sw_elem, bss); 1385 ieee80211_process_chanswitch(sdata, sw_elem, bss);
1766 } 1386 }
1767 1387
1768 /* was just updated in ieee80211_bss_info_update */
1769 beacon_timestamp = bss->cbss.tsf;
1770
1771 if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
1772 goto put_bss;
1773
1774 /* check if we need to merge IBSS */
1775
1776 /* merge only on beacons (???) */
1777 if (!beacon)
1778 goto put_bss;
1779
1780 /* we use a fixed BSSID */
1781 if (sdata->u.sta.flags & IEEE80211_STA_BSSID_SET)
1782 goto put_bss;
1783
1784 /* not an IBSS */
1785 if (!(bss->cbss.capability & WLAN_CAPABILITY_IBSS))
1786 goto put_bss;
1787
1788 /* different channel */
1789 if (bss->cbss.channel != local->oper_channel)
1790 goto put_bss;
1791
1792 /* different SSID */
1793 if (elems->ssid_len != sdata->u.sta.ssid_len ||
1794 memcmp(elems->ssid, sdata->u.sta.ssid,
1795 sdata->u.sta.ssid_len))
1796 goto put_bss;
1797
1798 if (rx_status->flag & RX_FLAG_TSFT) {
1799 /*
1800 * For correct IBSS merging we need mactime; since mactime is
1801 * defined as the time the first data symbol of the frame hits
1802 * the PHY, and the timestamp of the beacon is defined as "the
1803 * time that the data symbol containing the first bit of the
1804 * timestamp is transmitted to the PHY plus the transmitting
1805 * STA's delays through its local PHY from the MAC-PHY
1806 * interface to its interface with the WM" (802.11 11.1.2)
1807 * - equals the time this bit arrives at the receiver - we have
1808 * to take into account the offset between the two.
1809 *
1810 * E.g. at 1 MBit that means mactime is 192 usec earlier
1811 * (=24 bytes * 8 usecs/byte) than the beacon timestamp.
1812 */
1813 int rate;
1814
1815 if (rx_status->flag & RX_FLAG_HT)
1816 rate = 65; /* TODO: HT rates */
1817 else
1818 rate = local->hw.wiphy->bands[band]->
1819 bitrates[rx_status->rate_idx].bitrate;
1820
1821 rx_timestamp = rx_status->mactime + (24 * 8 * 10 / rate);
1822 } else if (local && local->ops && local->ops->get_tsf)
1823 /* second best option: get current TSF */
1824 rx_timestamp = local->ops->get_tsf(local_to_hw(local));
1825 else
1826 /* can't merge without knowing the TSF */
1827 rx_timestamp = -1LLU;
1828
1829#ifdef CONFIG_MAC80211_IBSS_DEBUG
1830 printk(KERN_DEBUG "RX beacon SA=%pM BSSID="
1831 "%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
1832 mgmt->sa, mgmt->bssid,
1833 (unsigned long long)rx_timestamp,
1834 (unsigned long long)beacon_timestamp,
1835 (unsigned long long)(rx_timestamp - beacon_timestamp),
1836 jiffies);
1837#endif
1838
1839 if (beacon_timestamp > rx_timestamp) {
1840#ifdef CONFIG_MAC80211_IBSS_DEBUG
1841 printk(KERN_DEBUG "%s: beacon TSF higher than "
1842 "local TSF - IBSS merge with BSSID %pM\n",
1843 sdata->dev->name, mgmt->bssid);
1844#endif
1845 ieee80211_sta_join_ibss(sdata, &sdata->u.sta, bss);
1846 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa, supp_rates);
1847 }
1848
1849 put_bss:
1850 ieee80211_rx_bss_put(local, bss); 1388 ieee80211_rx_bss_put(local, bss);
1851} 1389}
1852 1390
@@ -1858,7 +1396,6 @@ static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1858{ 1396{
1859 size_t baselen; 1397 size_t baselen;
1860 struct ieee802_11_elems elems; 1398 struct ieee802_11_elems elems;
1861 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
1862 1399
1863 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN)) 1400 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
1864 return; /* ignore ProbeResp to foreign address */ 1401 return; /* ignore ProbeResp to foreign address */
@@ -1874,20 +1411,19 @@ static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1874 1411
1875 /* direct probe may be part of the association flow */ 1412 /* direct probe may be part of the association flow */
1876 if (test_and_clear_bit(IEEE80211_STA_REQ_DIRECT_PROBE, 1413 if (test_and_clear_bit(IEEE80211_STA_REQ_DIRECT_PROBE,
1877 &ifsta->request)) { 1414 &sdata->u.mgd.request)) {
1878 printk(KERN_DEBUG "%s direct probe responded\n", 1415 printk(KERN_DEBUG "%s direct probe responded\n",
1879 sdata->dev->name); 1416 sdata->dev->name);
1880 ieee80211_authenticate(sdata, ifsta); 1417 ieee80211_authenticate(sdata);
1881 } 1418 }
1882} 1419}
1883 1420
1884
1885static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata, 1421static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1886 struct ieee80211_mgmt *mgmt, 1422 struct ieee80211_mgmt *mgmt,
1887 size_t len, 1423 size_t len,
1888 struct ieee80211_rx_status *rx_status) 1424 struct ieee80211_rx_status *rx_status)
1889{ 1425{
1890 struct ieee80211_if_sta *ifsta; 1426 struct ieee80211_if_managed *ifmgd;
1891 size_t baselen; 1427 size_t baselen;
1892 struct ieee802_11_elems elems; 1428 struct ieee802_11_elems elems;
1893 struct ieee80211_local *local = sdata->local; 1429 struct ieee80211_local *local = sdata->local;
@@ -1906,21 +1442,22 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1906 1442
1907 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1443 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1908 return; 1444 return;
1909 ifsta = &sdata->u.sta;
1910 1445
1911 if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED) || 1446 ifmgd = &sdata->u.mgd;
1912 memcmp(ifsta->bssid, mgmt->bssid, ETH_ALEN) != 0) 1447
1448 if (!(ifmgd->flags & IEEE80211_STA_ASSOCIATED) ||
1449 memcmp(ifmgd->bssid, mgmt->bssid, ETH_ALEN) != 0)
1913 return; 1450 return;
1914 1451
1915 if (rx_status->freq != local->hw.conf.channel->center_freq) 1452 if (rx_status->freq != local->hw.conf.channel->center_freq)
1916 return; 1453 return;
1917 1454
1918 ieee80211_sta_wmm_params(local, ifsta, elems.wmm_param, 1455 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1919 elems.wmm_param_len); 1456 elems.wmm_param_len);
1920 1457
1921 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK && 1458 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK &&
1922 local->hw.conf.flags & IEEE80211_CONF_PS) { 1459 local->hw.conf.flags & IEEE80211_CONF_PS) {
1923 directed_tim = ieee80211_check_tim(&elems, ifsta->aid); 1460 directed_tim = ieee80211_check_tim(&elems, ifmgd->aid);
1924 1461
1925 if (directed_tim) { 1462 if (directed_tim) {
1926 if (local->hw.conf.dynamic_ps_timeout > 0) { 1463 if (local->hw.conf.dynamic_ps_timeout > 0) {
@@ -1956,14 +1493,14 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1956 1493
1957 1494
1958 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param && 1495 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
1959 !(ifsta->flags & IEEE80211_STA_TKIP_WEP_USED)) { 1496 !(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED)) {
1960 struct sta_info *sta; 1497 struct sta_info *sta;
1961 struct ieee80211_supported_band *sband; 1498 struct ieee80211_supported_band *sband;
1962 u16 ap_ht_cap_flags; 1499 u16 ap_ht_cap_flags;
1963 1500
1964 rcu_read_lock(); 1501 rcu_read_lock();
1965 1502
1966 sta = sta_info_get(local, ifsta->bssid); 1503 sta = sta_info_get(local, ifmgd->bssid);
1967 if (!sta) { 1504 if (!sta) {
1968 rcu_read_unlock(); 1505 rcu_read_unlock();
1969 return; 1506 return;
@@ -1999,85 +1536,16 @@ static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1999 ieee80211_bss_info_change_notify(sdata, changed); 1536 ieee80211_bss_info_change_notify(sdata, changed);
2000} 1537}
2001 1538
2002 1539ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
2003static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata, 1540 struct sk_buff *skb,
2004 struct ieee80211_if_sta *ifsta, 1541 struct ieee80211_rx_status *rx_status)
2005 struct ieee80211_mgmt *mgmt,
2006 size_t len)
2007{ 1542{
2008 struct ieee80211_local *local = sdata->local; 1543 struct ieee80211_local *local = sdata->local;
2009 int tx_last_beacon;
2010 struct sk_buff *skb;
2011 struct ieee80211_mgmt *resp;
2012 u8 *pos, *end;
2013
2014 if (ifsta->state != IEEE80211_STA_MLME_IBSS_JOINED ||
2015 len < 24 + 2 || !ifsta->probe_resp)
2016 return;
2017
2018 if (local->ops->tx_last_beacon)
2019 tx_last_beacon = local->ops->tx_last_beacon(local_to_hw(local));
2020 else
2021 tx_last_beacon = 1;
2022
2023#ifdef CONFIG_MAC80211_IBSS_DEBUG
2024 printk(KERN_DEBUG "%s: RX ProbeReq SA=%pM DA=%pM BSSID=%pM"
2025 " (tx_last_beacon=%d)\n",
2026 sdata->dev->name, mgmt->sa, mgmt->da,
2027 mgmt->bssid, tx_last_beacon);
2028#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2029
2030 if (!tx_last_beacon)
2031 return;
2032
2033 if (memcmp(mgmt->bssid, ifsta->bssid, ETH_ALEN) != 0 &&
2034 memcmp(mgmt->bssid, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
2035 return;
2036
2037 end = ((u8 *) mgmt) + len;
2038 pos = mgmt->u.probe_req.variable;
2039 if (pos[0] != WLAN_EID_SSID ||
2040 pos + 2 + pos[1] > end) {
2041#ifdef CONFIG_MAC80211_IBSS_DEBUG
2042 printk(KERN_DEBUG "%s: Invalid SSID IE in ProbeReq "
2043 "from %pM\n",
2044 sdata->dev->name, mgmt->sa);
2045#endif
2046 return;
2047 }
2048 if (pos[1] != 0 &&
2049 (pos[1] != ifsta->ssid_len ||
2050 memcmp(pos + 2, ifsta->ssid, ifsta->ssid_len) != 0)) {
2051 /* Ignore ProbeReq for foreign SSID */
2052 return;
2053 }
2054
2055 /* Reply with ProbeResp */
2056 skb = skb_copy(ifsta->probe_resp, GFP_KERNEL);
2057 if (!skb)
2058 return;
2059
2060 resp = (struct ieee80211_mgmt *) skb->data;
2061 memcpy(resp->da, mgmt->sa, ETH_ALEN);
2062#ifdef CONFIG_MAC80211_IBSS_DEBUG
2063 printk(KERN_DEBUG "%s: Sending ProbeResp to %pM\n",
2064 sdata->dev->name, resp->da);
2065#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2066 ieee80211_tx_skb(sdata, skb, 0);
2067}
2068
2069void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
2070 struct ieee80211_rx_status *rx_status)
2071{
2072 struct ieee80211_local *local = sdata->local;
2073 struct ieee80211_if_sta *ifsta;
2074 struct ieee80211_mgmt *mgmt; 1544 struct ieee80211_mgmt *mgmt;
2075 u16 fc; 1545 u16 fc;
2076 1546
2077 if (skb->len < 24) 1547 if (skb->len < 24)
2078 goto fail; 1548 return RX_DROP_MONITOR;
2079
2080 ifsta = &sdata->u.sta;
2081 1549
2082 mgmt = (struct ieee80211_mgmt *) skb->data; 1550 mgmt = (struct ieee80211_mgmt *) skb->data;
2083 fc = le16_to_cpu(mgmt->frame_control); 1551 fc = le16_to_cpu(mgmt->frame_control);
@@ -2092,147 +1560,68 @@ void ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, struct sk_buff *
2092 case IEEE80211_STYPE_REASSOC_RESP: 1560 case IEEE80211_STYPE_REASSOC_RESP:
2093 case IEEE80211_STYPE_DEAUTH: 1561 case IEEE80211_STYPE_DEAUTH:
2094 case IEEE80211_STYPE_DISASSOC: 1562 case IEEE80211_STYPE_DISASSOC:
2095 skb_queue_tail(&ifsta->skb_queue, skb); 1563 skb_queue_tail(&sdata->u.mgd.skb_queue, skb);
2096 queue_work(local->hw.workqueue, &ifsta->work); 1564 queue_work(local->hw.workqueue, &sdata->u.mgd.work);
2097 return; 1565 return RX_QUEUED;
2098 } 1566 }
2099 1567
2100 fail: 1568 return RX_DROP_MONITOR;
2101 kfree_skb(skb);
2102} 1569}
2103 1570
2104static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 1571static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2105 struct sk_buff *skb) 1572 struct sk_buff *skb)
2106{ 1573{
2107 struct ieee80211_rx_status *rx_status; 1574 struct ieee80211_rx_status *rx_status;
2108 struct ieee80211_if_sta *ifsta;
2109 struct ieee80211_mgmt *mgmt; 1575 struct ieee80211_mgmt *mgmt;
2110 u16 fc; 1576 u16 fc;
2111 1577
2112 ifsta = &sdata->u.sta;
2113
2114 rx_status = (struct ieee80211_rx_status *) skb->cb; 1578 rx_status = (struct ieee80211_rx_status *) skb->cb;
2115 mgmt = (struct ieee80211_mgmt *) skb->data; 1579 mgmt = (struct ieee80211_mgmt *) skb->data;
2116 fc = le16_to_cpu(mgmt->frame_control); 1580 fc = le16_to_cpu(mgmt->frame_control);
2117 1581
2118 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) { 1582 switch (fc & IEEE80211_FCTL_STYPE) {
2119 switch (fc & IEEE80211_FCTL_STYPE) { 1583 case IEEE80211_STYPE_PROBE_RESP:
2120 case IEEE80211_STYPE_PROBE_REQ: 1584 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len,
2121 ieee80211_rx_mgmt_probe_req(sdata, ifsta, mgmt, 1585 rx_status);
2122 skb->len); 1586 break;
2123 break; 1587 case IEEE80211_STYPE_BEACON:
2124 case IEEE80211_STYPE_PROBE_RESP: 1588 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
2125 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, 1589 rx_status);
2126 rx_status); 1590 break;
2127 break; 1591 case IEEE80211_STYPE_AUTH:
2128 case IEEE80211_STYPE_BEACON: 1592 ieee80211_rx_mgmt_auth(sdata, mgmt, skb->len);
2129 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, 1593 break;
2130 rx_status); 1594 case IEEE80211_STYPE_ASSOC_RESP:
2131 break; 1595 ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, 0);
2132 case IEEE80211_STYPE_AUTH: 1596 break;
2133 ieee80211_rx_mgmt_auth_ibss(sdata, ifsta, mgmt, 1597 case IEEE80211_STYPE_REASSOC_RESP:
2134 skb->len); 1598 ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, 1);
2135 break; 1599 break;
2136 } 1600 case IEEE80211_STYPE_DEAUTH:
2137 } else { /* NL80211_IFTYPE_STATION */ 1601 ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
2138 switch (fc & IEEE80211_FCTL_STYPE) { 1602 break;
2139 case IEEE80211_STYPE_PROBE_RESP: 1603 case IEEE80211_STYPE_DISASSOC:
2140 ieee80211_rx_mgmt_probe_resp(sdata, mgmt, skb->len, 1604 ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
2141 rx_status); 1605 break;
2142 break;
2143 case IEEE80211_STYPE_BEACON:
2144 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
2145 rx_status);
2146 break;
2147 case IEEE80211_STYPE_AUTH:
2148 ieee80211_rx_mgmt_auth(sdata, ifsta, mgmt, skb->len);
2149 break;
2150 case IEEE80211_STYPE_ASSOC_RESP:
2151 ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt,
2152 skb->len, 0);
2153 break;
2154 case IEEE80211_STYPE_REASSOC_RESP:
2155 ieee80211_rx_mgmt_assoc_resp(sdata, ifsta, mgmt,
2156 skb->len, 1);
2157 break;
2158 case IEEE80211_STYPE_DEAUTH:
2159 ieee80211_rx_mgmt_deauth(sdata, ifsta, mgmt, skb->len);
2160 break;
2161 case IEEE80211_STYPE_DISASSOC:
2162 ieee80211_rx_mgmt_disassoc(sdata, ifsta, mgmt,
2163 skb->len);
2164 break;
2165 }
2166 } 1606 }
2167 1607
2168 kfree_skb(skb); 1608 kfree_skb(skb);
2169} 1609}
2170 1610
2171
2172static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
2173{
2174 struct ieee80211_local *local = sdata->local;
2175 int active = 0;
2176 struct sta_info *sta;
2177
2178 rcu_read_lock();
2179
2180 list_for_each_entry_rcu(sta, &local->sta_list, list) {
2181 if (sta->sdata == sdata &&
2182 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL,
2183 jiffies)) {
2184 active++;
2185 break;
2186 }
2187 }
2188
2189 rcu_read_unlock();
2190
2191 return active;
2192}
2193
2194
2195static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata,
2196 struct ieee80211_if_sta *ifsta)
2197{
2198 mod_timer(&ifsta->timer, jiffies + IEEE80211_IBSS_MERGE_INTERVAL);
2199
2200 ieee80211_sta_expire(sdata, IEEE80211_IBSS_INACTIVITY_LIMIT);
2201 if (ieee80211_sta_active_ibss(sdata))
2202 return;
2203
2204 if ((sdata->u.sta.flags & IEEE80211_STA_BSSID_SET) &&
2205 (!(sdata->u.sta.flags & IEEE80211_STA_AUTO_CHANNEL_SEL)))
2206 return;
2207
2208 printk(KERN_DEBUG "%s: No active IBSS STAs - trying to scan for other "
2209 "IBSS networks with same SSID (merge)\n", sdata->dev->name);
2210
2211 /* XXX maybe racy? */
2212 if (sdata->local->scan_req)
2213 return;
2214
2215 memcpy(sdata->local->int_scan_req.ssids[0].ssid,
2216 ifsta->ssid, IEEE80211_MAX_SSID_LEN);
2217 sdata->local->int_scan_req.ssids[0].ssid_len = ifsta->ssid_len;
2218 ieee80211_request_scan(sdata, &sdata->local->int_scan_req);
2219}
2220
2221
2222static void ieee80211_sta_timer(unsigned long data) 1611static void ieee80211_sta_timer(unsigned long data)
2223{ 1612{
2224 struct ieee80211_sub_if_data *sdata = 1613 struct ieee80211_sub_if_data *sdata =
2225 (struct ieee80211_sub_if_data *) data; 1614 (struct ieee80211_sub_if_data *) data;
2226 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1615 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2227 struct ieee80211_local *local = sdata->local; 1616 struct ieee80211_local *local = sdata->local;
2228 1617
2229 set_bit(IEEE80211_STA_REQ_RUN, &ifsta->request); 1618 set_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request);
2230 queue_work(local->hw.workqueue, &ifsta->work); 1619 queue_work(local->hw.workqueue, &ifmgd->work);
2231} 1620}
2232 1621
2233static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata, 1622static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata)
2234 struct ieee80211_if_sta *ifsta)
2235{ 1623{
1624 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2236 struct ieee80211_local *local = sdata->local; 1625 struct ieee80211_local *local = sdata->local;
2237 1626
2238 if (local->ops->reset_tsf) { 1627 if (local->ops->reset_tsf) {
@@ -2240,191 +1629,39 @@ static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data *sdata,
2240 local->ops->reset_tsf(local_to_hw(local)); 1629 local->ops->reset_tsf(local_to_hw(local));
2241 } 1630 }
2242 1631
2243 ifsta->wmm_last_param_set = -1; /* allow any WMM update */ 1632 ifmgd->wmm_last_param_set = -1; /* allow any WMM update */
2244 1633
2245 1634
2246 if (ifsta->auth_algs & IEEE80211_AUTH_ALG_OPEN) 1635 if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_OPEN)
2247 ifsta->auth_alg = WLAN_AUTH_OPEN; 1636 ifmgd->auth_alg = WLAN_AUTH_OPEN;
2248 else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY) 1637 else if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_SHARED_KEY)
2249 ifsta->auth_alg = WLAN_AUTH_SHARED_KEY; 1638 ifmgd->auth_alg = WLAN_AUTH_SHARED_KEY;
2250 else if (ifsta->auth_algs & IEEE80211_AUTH_ALG_LEAP) 1639 else if (ifmgd->auth_algs & IEEE80211_AUTH_ALG_LEAP)
2251 ifsta->auth_alg = WLAN_AUTH_LEAP; 1640 ifmgd->auth_alg = WLAN_AUTH_LEAP;
2252 else 1641 else
2253 ifsta->auth_alg = WLAN_AUTH_OPEN; 1642 ifmgd->auth_alg = WLAN_AUTH_OPEN;
2254 ifsta->auth_transaction = -1; 1643 ifmgd->auth_transaction = -1;
2255 ifsta->flags &= ~IEEE80211_STA_ASSOCIATED; 1644 ifmgd->flags &= ~IEEE80211_STA_ASSOCIATED;
2256 ifsta->assoc_scan_tries = 0; 1645 ifmgd->assoc_scan_tries = 0;
2257 ifsta->direct_probe_tries = 0; 1646 ifmgd->direct_probe_tries = 0;
2258 ifsta->auth_tries = 0; 1647 ifmgd->auth_tries = 0;
2259 ifsta->assoc_tries = 0; 1648 ifmgd->assoc_tries = 0;
2260 netif_tx_stop_all_queues(sdata->dev); 1649 netif_tx_stop_all_queues(sdata->dev);
2261 netif_carrier_off(sdata->dev); 1650 netif_carrier_off(sdata->dev);
2262} 1651}
2263 1652
2264static int ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata, 1653static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata)
2265 struct ieee80211_if_sta *ifsta)
2266{
2267 struct ieee80211_local *local = sdata->local;
2268 struct ieee80211_supported_band *sband;
2269 u8 *pos;
2270 u8 bssid[ETH_ALEN];
2271 u8 supp_rates[IEEE80211_MAX_SUPP_RATES];
2272 u16 capability;
2273 int i;
2274
2275 if (sdata->u.sta.flags & IEEE80211_STA_BSSID_SET) {
2276 memcpy(bssid, ifsta->bssid, ETH_ALEN);
2277 } else {
2278 /* Generate random, not broadcast, locally administered BSSID. Mix in
2279 * own MAC address to make sure that devices that do not have proper
2280 * random number generator get different BSSID. */
2281 get_random_bytes(bssid, ETH_ALEN);
2282 for (i = 0; i < ETH_ALEN; i++)
2283 bssid[i] ^= sdata->dev->dev_addr[i];
2284 bssid[0] &= ~0x01;
2285 bssid[0] |= 0x02;
2286 }
2287
2288 printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID %pM\n",
2289 sdata->dev->name, bssid);
2290
2291 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
2292
2293 if (local->hw.conf.beacon_int == 0)
2294 local->hw.conf.beacon_int = 100;
2295
2296 capability = WLAN_CAPABILITY_IBSS;
2297
2298 if (sdata->default_key)
2299 capability |= WLAN_CAPABILITY_PRIVACY;
2300 else
2301 sdata->drop_unencrypted = 0;
2302
2303 pos = supp_rates;
2304 for (i = 0; i < sband->n_bitrates; i++) {
2305 int rate = sband->bitrates[i].bitrate;
2306 *pos++ = (u8) (rate / 5);
2307 }
2308
2309 return __ieee80211_sta_join_ibss(sdata, ifsta,
2310 bssid, local->hw.conf.beacon_int,
2311 local->hw.conf.channel->center_freq,
2312 sband->n_bitrates, supp_rates,
2313 capability);
2314}
2315
2316
2317static int ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata,
2318 struct ieee80211_if_sta *ifsta)
2319{ 1654{
1655 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2320 struct ieee80211_local *local = sdata->local; 1656 struct ieee80211_local *local = sdata->local;
2321 struct ieee80211_bss *bss; 1657 struct ieee80211_bss *bss;
2322 int active_ibss; 1658 u8 *bssid = ifmgd->bssid, *ssid = ifmgd->ssid;
2323 1659 u8 ssid_len = ifmgd->ssid_len;
2324 if (ifsta->ssid_len == 0)
2325 return -EINVAL;
2326
2327 active_ibss = ieee80211_sta_active_ibss(sdata);
2328#ifdef CONFIG_MAC80211_IBSS_DEBUG
2329 printk(KERN_DEBUG "%s: sta_find_ibss (active_ibss=%d)\n",
2330 sdata->dev->name, active_ibss);
2331#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2332
2333 if (active_ibss)
2334 return 0;
2335
2336 if (ifsta->flags & IEEE80211_STA_BSSID_SET)
2337 bss = ieee80211_rx_bss_get(local, ifsta->bssid, 0,
2338 ifsta->ssid, ifsta->ssid_len);
2339 else
2340 bss = (void *)cfg80211_get_ibss(local->hw.wiphy,
2341 NULL,
2342 ifsta->ssid, ifsta->ssid_len);
2343
2344#ifdef CONFIG_MAC80211_IBSS_DEBUG
2345 if (bss)
2346 printk(KERN_DEBUG " sta_find_ibss: selected %pM current "
2347 "%pM\n", bss->cbss.bssid, ifsta->bssid);
2348#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2349
2350 if (bss &&
2351 (!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET) ||
2352 memcmp(ifsta->bssid, bss->cbss.bssid, ETH_ALEN))) {
2353 int ret;
2354
2355 printk(KERN_DEBUG "%s: Selected IBSS BSSID %pM"
2356 " based on configured SSID\n",
2357 sdata->dev->name, bss->cbss.bssid);
2358
2359 ret = ieee80211_sta_join_ibss(sdata, ifsta, bss);
2360 ieee80211_rx_bss_put(local, bss);
2361 return ret;
2362 } else if (bss)
2363 ieee80211_rx_bss_put(local, bss);
2364
2365#ifdef CONFIG_MAC80211_IBSS_DEBUG
2366 printk(KERN_DEBUG " did not try to join ibss\n");
2367#endif /* CONFIG_MAC80211_IBSS_DEBUG */
2368
2369 /* Selected IBSS not found in current scan results - try to scan */
2370 if (ifsta->state == IEEE80211_STA_MLME_IBSS_JOINED &&
2371 !ieee80211_sta_active_ibss(sdata)) {
2372 mod_timer(&ifsta->timer, jiffies +
2373 IEEE80211_IBSS_MERGE_INTERVAL);
2374 } else if (time_after(jiffies, local->last_scan_completed +
2375 IEEE80211_SCAN_INTERVAL)) {
2376 printk(KERN_DEBUG "%s: Trigger new scan to find an IBSS to "
2377 "join\n", sdata->dev->name);
2378
2379 /* XXX maybe racy? */
2380 if (local->scan_req)
2381 return -EBUSY;
2382
2383 memcpy(local->int_scan_req.ssids[0].ssid,
2384 ifsta->ssid, IEEE80211_MAX_SSID_LEN);
2385 local->int_scan_req.ssids[0].ssid_len = ifsta->ssid_len;
2386 return ieee80211_request_scan(sdata, &local->int_scan_req);
2387 } else if (ifsta->state != IEEE80211_STA_MLME_IBSS_JOINED) {
2388 int interval = IEEE80211_SCAN_INTERVAL;
2389
2390 if (time_after(jiffies, ifsta->ibss_join_req +
2391 IEEE80211_IBSS_JOIN_TIMEOUT)) {
2392 if ((ifsta->flags & IEEE80211_STA_CREATE_IBSS) &&
2393 (!(local->oper_channel->flags &
2394 IEEE80211_CHAN_NO_IBSS)))
2395 return ieee80211_sta_create_ibss(sdata, ifsta);
2396 if (ifsta->flags & IEEE80211_STA_CREATE_IBSS) {
2397 printk(KERN_DEBUG "%s: IBSS not allowed on"
2398 " %d MHz\n", sdata->dev->name,
2399 local->hw.conf.channel->center_freq);
2400 }
2401
2402 /* No IBSS found - decrease scan interval and continue
2403 * scanning. */
2404 interval = IEEE80211_SCAN_INTERVAL_SLOW;
2405 }
2406
2407 ifsta->state = IEEE80211_STA_MLME_IBSS_SEARCH;
2408 mod_timer(&ifsta->timer, jiffies + interval);
2409 return 0;
2410 }
2411
2412 return 0;
2413}
2414
2415
2416static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2417 struct ieee80211_if_sta *ifsta)
2418{
2419 struct ieee80211_local *local = sdata->local;
2420 struct ieee80211_bss *bss;
2421 u8 *bssid = ifsta->bssid, *ssid = ifsta->ssid;
2422 u8 ssid_len = ifsta->ssid_len;
2423 u16 capa_mask = WLAN_CAPABILITY_ESS; 1660 u16 capa_mask = WLAN_CAPABILITY_ESS;
2424 u16 capa_val = WLAN_CAPABILITY_ESS; 1661 u16 capa_val = WLAN_CAPABILITY_ESS;
2425 struct ieee80211_channel *chan = local->oper_channel; 1662 struct ieee80211_channel *chan = local->oper_channel;
2426 1663
2427 if (ifsta->flags & (IEEE80211_STA_AUTO_SSID_SEL | 1664 if (ifmgd->flags & (IEEE80211_STA_AUTO_SSID_SEL |
2428 IEEE80211_STA_AUTO_BSSID_SEL | 1665 IEEE80211_STA_AUTO_BSSID_SEL |
2429 IEEE80211_STA_AUTO_CHANNEL_SEL)) { 1666 IEEE80211_STA_AUTO_CHANNEL_SEL)) {
2430 capa_mask |= WLAN_CAPABILITY_PRIVACY; 1667 capa_mask |= WLAN_CAPABILITY_PRIVACY;
@@ -2432,13 +1669,13 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2432 capa_val |= WLAN_CAPABILITY_PRIVACY; 1669 capa_val |= WLAN_CAPABILITY_PRIVACY;
2433 } 1670 }
2434 1671
2435 if (ifsta->flags & IEEE80211_STA_AUTO_CHANNEL_SEL) 1672 if (ifmgd->flags & IEEE80211_STA_AUTO_CHANNEL_SEL)
2436 chan = NULL; 1673 chan = NULL;
2437 1674
2438 if (ifsta->flags & IEEE80211_STA_AUTO_BSSID_SEL) 1675 if (ifmgd->flags & IEEE80211_STA_AUTO_BSSID_SEL)
2439 bssid = NULL; 1676 bssid = NULL;
2440 1677
2441 if (ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL) { 1678 if (ifmgd->flags & IEEE80211_STA_AUTO_SSID_SEL) {
2442 ssid = NULL; 1679 ssid = NULL;
2443 ssid_len = 0; 1680 ssid_len = 0;
2444 } 1681 }
@@ -2449,16 +1686,16 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2449 1686
2450 if (bss) { 1687 if (bss) {
2451 ieee80211_set_freq(sdata, bss->cbss.channel->center_freq); 1688 ieee80211_set_freq(sdata, bss->cbss.channel->center_freq);
2452 if (!(ifsta->flags & IEEE80211_STA_SSID_SET)) 1689 if (!(ifmgd->flags & IEEE80211_STA_SSID_SET))
2453 ieee80211_sta_set_ssid(sdata, bss->ssid, 1690 ieee80211_sta_set_ssid(sdata, bss->ssid,
2454 bss->ssid_len); 1691 bss->ssid_len);
2455 ieee80211_sta_set_bssid(sdata, bss->cbss.bssid); 1692 ieee80211_sta_set_bssid(sdata, bss->cbss.bssid);
2456 ieee80211_sta_def_wmm_params(sdata, bss->supp_rates_len, 1693 ieee80211_sta_def_wmm_params(sdata, bss->supp_rates_len,
2457 bss->supp_rates); 1694 bss->supp_rates);
2458 if (sdata->u.sta.mfp == IEEE80211_MFP_REQUIRED) 1695 if (sdata->u.mgd.mfp == IEEE80211_MFP_REQUIRED)
2459 sdata->u.sta.flags |= IEEE80211_STA_MFP_ENABLED; 1696 sdata->u.mgd.flags |= IEEE80211_STA_MFP_ENABLED;
2460 else 1697 else
2461 sdata->u.sta.flags &= ~IEEE80211_STA_MFP_ENABLED; 1698 sdata->u.mgd.flags &= ~IEEE80211_STA_MFP_ENABLED;
2462 1699
2463 /* Send out direct probe if no probe resp was received or 1700 /* Send out direct probe if no probe resp was received or
2464 * the one we have is outdated 1701 * the one we have is outdated
@@ -2466,31 +1703,31 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2466 if (!bss->last_probe_resp || 1703 if (!bss->last_probe_resp ||
2467 time_after(jiffies, bss->last_probe_resp 1704 time_after(jiffies, bss->last_probe_resp
2468 + IEEE80211_SCAN_RESULT_EXPIRE)) 1705 + IEEE80211_SCAN_RESULT_EXPIRE))
2469 ifsta->state = IEEE80211_STA_MLME_DIRECT_PROBE; 1706 ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
2470 else 1707 else
2471 ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; 1708 ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
2472 1709
2473 ieee80211_rx_bss_put(local, bss); 1710 ieee80211_rx_bss_put(local, bss);
2474 ieee80211_sta_reset_auth(sdata, ifsta); 1711 ieee80211_sta_reset_auth(sdata);
2475 return 0; 1712 return 0;
2476 } else { 1713 } else {
2477 if (ifsta->assoc_scan_tries < IEEE80211_ASSOC_SCANS_MAX_TRIES) { 1714 if (ifmgd->assoc_scan_tries < IEEE80211_ASSOC_SCANS_MAX_TRIES) {
2478 ifsta->assoc_scan_tries++; 1715 ifmgd->assoc_scan_tries++;
2479 /* XXX maybe racy? */ 1716 /* XXX maybe racy? */
2480 if (local->scan_req) 1717 if (local->scan_req)
2481 return -1; 1718 return -1;
2482 memcpy(local->int_scan_req.ssids[0].ssid, 1719 memcpy(local->int_scan_req.ssids[0].ssid,
2483 ifsta->ssid, IEEE80211_MAX_SSID_LEN); 1720 ifmgd->ssid, IEEE80211_MAX_SSID_LEN);
2484 if (ifsta->flags & IEEE80211_STA_AUTO_SSID_SEL) 1721 if (ifmgd->flags & IEEE80211_STA_AUTO_SSID_SEL)
2485 local->int_scan_req.ssids[0].ssid_len = 0; 1722 local->int_scan_req.ssids[0].ssid_len = 0;
2486 else 1723 else
2487 local->int_scan_req.ssids[0].ssid_len = ifsta->ssid_len; 1724 local->int_scan_req.ssids[0].ssid_len = ifmgd->ssid_len;
2488 ieee80211_start_scan(sdata, &local->int_scan_req); 1725 ieee80211_start_scan(sdata, &local->int_scan_req);
2489 ifsta->state = IEEE80211_STA_MLME_AUTHENTICATE; 1726 ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
2490 set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request); 1727 set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
2491 } else { 1728 } else {
2492 ifsta->assoc_scan_tries = 0; 1729 ifmgd->assoc_scan_tries = 0;
2493 ifsta->state = IEEE80211_STA_MLME_DISABLED; 1730 ifmgd->state = IEEE80211_STA_MLME_DISABLED;
2494 } 1731 }
2495 } 1732 }
2496 return -1; 1733 return -1;
@@ -2500,9 +1737,9 @@ static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data *sdata,
2500static void ieee80211_sta_work(struct work_struct *work) 1737static void ieee80211_sta_work(struct work_struct *work)
2501{ 1738{
2502 struct ieee80211_sub_if_data *sdata = 1739 struct ieee80211_sub_if_data *sdata =
2503 container_of(work, struct ieee80211_sub_if_data, u.sta.work); 1740 container_of(work, struct ieee80211_sub_if_data, u.mgd.work);
2504 struct ieee80211_local *local = sdata->local; 1741 struct ieee80211_local *local = sdata->local;
2505 struct ieee80211_if_sta *ifsta; 1742 struct ieee80211_if_managed *ifmgd;
2506 struct sk_buff *skb; 1743 struct sk_buff *skb;
2507 1744
2508 if (!netif_running(sdata->dev)) 1745 if (!netif_running(sdata->dev))
@@ -2511,60 +1748,53 @@ static void ieee80211_sta_work(struct work_struct *work)
2511 if (local->sw_scanning || local->hw_scanning) 1748 if (local->sw_scanning || local->hw_scanning)
2512 return; 1749 return;
2513 1750
2514 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION && 1751 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2515 sdata->vif.type != NL80211_IFTYPE_ADHOC))
2516 return; 1752 return;
2517 ifsta = &sdata->u.sta; 1753 ifmgd = &sdata->u.mgd;
2518 1754
2519 while ((skb = skb_dequeue(&ifsta->skb_queue))) 1755 while ((skb = skb_dequeue(&ifmgd->skb_queue)))
2520 ieee80211_sta_rx_queued_mgmt(sdata, skb); 1756 ieee80211_sta_rx_queued_mgmt(sdata, skb);
2521 1757
2522 if (ifsta->state != IEEE80211_STA_MLME_DIRECT_PROBE && 1758 if (ifmgd->state != IEEE80211_STA_MLME_DIRECT_PROBE &&
2523 ifsta->state != IEEE80211_STA_MLME_AUTHENTICATE && 1759 ifmgd->state != IEEE80211_STA_MLME_AUTHENTICATE &&
2524 ifsta->state != IEEE80211_STA_MLME_ASSOCIATE && 1760 ifmgd->state != IEEE80211_STA_MLME_ASSOCIATE &&
2525 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifsta->request)) { 1761 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request)) {
2526 ieee80211_start_scan(sdata, local->scan_req); 1762 ieee80211_start_scan(sdata, local->scan_req);
2527 return; 1763 return;
2528 } 1764 }
2529 1765
2530 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request)) { 1766 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request)) {
2531 if (ieee80211_sta_config_auth(sdata, ifsta)) 1767 if (ieee80211_sta_config_auth(sdata))
2532 return; 1768 return;
2533 clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request); 1769 clear_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request);
2534 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifsta->request)) 1770 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN, &ifmgd->request))
2535 return; 1771 return;
2536 1772
2537 switch (ifsta->state) { 1773 switch (ifmgd->state) {
2538 case IEEE80211_STA_MLME_DISABLED: 1774 case IEEE80211_STA_MLME_DISABLED:
2539 break; 1775 break;
2540 case IEEE80211_STA_MLME_DIRECT_PROBE: 1776 case IEEE80211_STA_MLME_DIRECT_PROBE:
2541 ieee80211_direct_probe(sdata, ifsta); 1777 ieee80211_direct_probe(sdata);
2542 break; 1778 break;
2543 case IEEE80211_STA_MLME_AUTHENTICATE: 1779 case IEEE80211_STA_MLME_AUTHENTICATE:
2544 ieee80211_authenticate(sdata, ifsta); 1780 ieee80211_authenticate(sdata);
2545 break; 1781 break;
2546 case IEEE80211_STA_MLME_ASSOCIATE: 1782 case IEEE80211_STA_MLME_ASSOCIATE:
2547 ieee80211_associate(sdata, ifsta); 1783 ieee80211_associate(sdata);
2548 break; 1784 break;
2549 case IEEE80211_STA_MLME_ASSOCIATED: 1785 case IEEE80211_STA_MLME_ASSOCIATED:
2550 ieee80211_associated(sdata, ifsta); 1786 ieee80211_associated(sdata);
2551 break;
2552 case IEEE80211_STA_MLME_IBSS_SEARCH:
2553 ieee80211_sta_find_ibss(sdata, ifsta);
2554 break;
2555 case IEEE80211_STA_MLME_IBSS_JOINED:
2556 ieee80211_sta_merge_ibss(sdata, ifsta);
2557 break; 1787 break;
2558 default: 1788 default:
2559 WARN_ON(1); 1789 WARN_ON(1);
2560 break; 1790 break;
2561 } 1791 }
2562 1792
2563 if (ieee80211_privacy_mismatch(sdata, ifsta)) { 1793 if (ieee80211_privacy_mismatch(sdata)) {
2564 printk(KERN_DEBUG "%s: privacy configuration mismatch and " 1794 printk(KERN_DEBUG "%s: privacy configuration mismatch and "
2565 "mixed-cell disabled - disassociate\n", sdata->dev->name); 1795 "mixed-cell disabled - disassociate\n", sdata->dev->name);
2566 1796
2567 ieee80211_set_disassoc(sdata, ifsta, false, true, 1797 ieee80211_set_disassoc(sdata, false, true,
2568 WLAN_REASON_UNSPECIFIED); 1798 WLAN_REASON_UNSPECIFIED);
2569 } 1799 }
2570} 1800}
@@ -2573,155 +1803,99 @@ static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2573{ 1803{
2574 if (sdata->vif.type == NL80211_IFTYPE_STATION) 1804 if (sdata->vif.type == NL80211_IFTYPE_STATION)
2575 queue_work(sdata->local->hw.workqueue, 1805 queue_work(sdata->local->hw.workqueue,
2576 &sdata->u.sta.work); 1806 &sdata->u.mgd.work);
2577} 1807}
2578 1808
2579/* interface setup */ 1809/* interface setup */
2580void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata) 1810void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2581{ 1811{
2582 struct ieee80211_if_sta *ifsta; 1812 struct ieee80211_if_managed *ifmgd;
2583 1813
2584 ifsta = &sdata->u.sta; 1814 ifmgd = &sdata->u.mgd;
2585 INIT_WORK(&ifsta->work, ieee80211_sta_work); 1815 INIT_WORK(&ifmgd->work, ieee80211_sta_work);
2586 INIT_WORK(&ifsta->chswitch_work, ieee80211_chswitch_work); 1816 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
2587 setup_timer(&ifsta->timer, ieee80211_sta_timer, 1817 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
2588 (unsigned long) sdata); 1818 (unsigned long) sdata);
2589 setup_timer(&ifsta->chswitch_timer, ieee80211_chswitch_timer, 1819 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
2590 (unsigned long) sdata); 1820 (unsigned long) sdata);
2591 skb_queue_head_init(&ifsta->skb_queue); 1821 skb_queue_head_init(&ifmgd->skb_queue);
2592 1822
2593 ifsta->capab = WLAN_CAPABILITY_ESS; 1823 ifmgd->capab = WLAN_CAPABILITY_ESS;
2594 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN | 1824 ifmgd->auth_algs = IEEE80211_AUTH_ALG_OPEN |
2595 IEEE80211_AUTH_ALG_SHARED_KEY; 1825 IEEE80211_AUTH_ALG_SHARED_KEY;
2596 ifsta->flags |= IEEE80211_STA_CREATE_IBSS | 1826 ifmgd->flags |= IEEE80211_STA_CREATE_IBSS |
2597 IEEE80211_STA_AUTO_BSSID_SEL | 1827 IEEE80211_STA_AUTO_BSSID_SEL |
2598 IEEE80211_STA_AUTO_CHANNEL_SEL; 1828 IEEE80211_STA_AUTO_CHANNEL_SEL;
2599 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4) 1829 if (ieee80211_num_regular_queues(&sdata->local->hw) >= 4)
2600 ifsta->flags |= IEEE80211_STA_WMM_ENABLED; 1830 ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
2601}
2602
2603/*
2604 * Add a new IBSS station, will also be called by the RX code when,
2605 * in IBSS mode, receiving a frame from a yet-unknown station, hence
2606 * must be callable in atomic context.
2607 */
2608struct sta_info *ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata,
2609 u8 *bssid,u8 *addr, u32 supp_rates)
2610{
2611 struct ieee80211_local *local = sdata->local;
2612 struct sta_info *sta;
2613 int band = local->hw.conf.channel->band;
2614
2615 /* TODO: Could consider removing the least recently used entry and
2616 * allow new one to be added. */
2617 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
2618 if (net_ratelimit()) {
2619 printk(KERN_DEBUG "%s: No room for a new IBSS STA "
2620 "entry %pM\n", sdata->dev->name, addr);
2621 }
2622 return NULL;
2623 }
2624
2625 if (compare_ether_addr(bssid, sdata->u.sta.bssid))
2626 return NULL;
2627
2628#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2629 printk(KERN_DEBUG "%s: Adding new IBSS station %pM (dev=%s)\n",
2630 wiphy_name(local->hw.wiphy), addr, sdata->dev->name);
2631#endif
2632
2633 sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
2634 if (!sta)
2635 return NULL;
2636
2637 set_sta_flags(sta, WLAN_STA_AUTHORIZED);
2638
2639 /* make sure mandatory rates are always added */
2640 sta->sta.supp_rates[band] = supp_rates |
2641 ieee80211_mandatory_rates(local, band);
2642
2643 rate_control_rate_init(sta);
2644
2645 if (sta_info_insert(sta))
2646 return NULL;
2647
2648 return sta;
2649} 1831}
2650 1832
2651/* configuration hooks */ 1833/* configuration hooks */
2652void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata, 1834void ieee80211_sta_req_auth(struct ieee80211_sub_if_data *sdata)
2653 struct ieee80211_if_sta *ifsta)
2654{ 1835{
1836 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2655 struct ieee80211_local *local = sdata->local; 1837 struct ieee80211_local *local = sdata->local;
2656 1838
2657 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1839 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2658 return; 1840 return;
2659 1841
2660 if ((ifsta->flags & (IEEE80211_STA_BSSID_SET | 1842 if ((ifmgd->flags & (IEEE80211_STA_BSSID_SET |
2661 IEEE80211_STA_AUTO_BSSID_SEL)) && 1843 IEEE80211_STA_AUTO_BSSID_SEL)) &&
2662 (ifsta->flags & (IEEE80211_STA_SSID_SET | 1844 (ifmgd->flags & (IEEE80211_STA_SSID_SET |
2663 IEEE80211_STA_AUTO_SSID_SEL))) { 1845 IEEE80211_STA_AUTO_SSID_SEL))) {
2664 1846
2665 if (ifsta->state == IEEE80211_STA_MLME_ASSOCIATED) 1847 if (ifmgd->state == IEEE80211_STA_MLME_ASSOCIATED)
2666 ieee80211_set_disassoc(sdata, ifsta, true, true, 1848 ieee80211_set_disassoc(sdata, true, true,
2667 WLAN_REASON_DEAUTH_LEAVING); 1849 WLAN_REASON_DEAUTH_LEAVING);
2668 1850
2669 set_bit(IEEE80211_STA_REQ_AUTH, &ifsta->request); 1851 set_bit(IEEE80211_STA_REQ_AUTH, &ifmgd->request);
2670 queue_work(local->hw.workqueue, &ifsta->work); 1852 queue_work(local->hw.workqueue, &ifmgd->work);
2671 } 1853 }
2672} 1854}
2673 1855
2674int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len) 1856int ieee80211_sta_set_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t len)
2675{ 1857{
2676 struct ieee80211_if_sta *ifsta; 1858 struct ieee80211_if_managed *ifmgd;
2677 1859
2678 if (len > IEEE80211_MAX_SSID_LEN) 1860 if (len > IEEE80211_MAX_SSID_LEN)
2679 return -EINVAL; 1861 return -EINVAL;
2680 1862
2681 ifsta = &sdata->u.sta; 1863 ifmgd = &sdata->u.mgd;
2682 1864
2683 if (ifsta->ssid_len != len || memcmp(ifsta->ssid, ssid, len) != 0) { 1865 if (ifmgd->ssid_len != len || memcmp(ifmgd->ssid, ssid, len) != 0) {
2684 memset(ifsta->ssid, 0, sizeof(ifsta->ssid)); 1866 memset(ifmgd->ssid, 0, sizeof(ifmgd->ssid));
2685 memcpy(ifsta->ssid, ssid, len); 1867 memcpy(ifmgd->ssid, ssid, len);
2686 ifsta->ssid_len = len; 1868 ifmgd->ssid_len = len;
2687 } 1869 }
2688 1870
2689 ifsta->flags &= ~IEEE80211_STA_PREV_BSSID_SET; 1871 ifmgd->flags &= ~IEEE80211_STA_PREV_BSSID_SET;
2690 1872
2691 if (len) 1873 if (len)
2692 ifsta->flags |= IEEE80211_STA_SSID_SET; 1874 ifmgd->flags |= IEEE80211_STA_SSID_SET;
2693 else 1875 else
2694 ifsta->flags &= ~IEEE80211_STA_SSID_SET; 1876 ifmgd->flags &= ~IEEE80211_STA_SSID_SET;
2695
2696 if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2697 ifsta->ibss_join_req = jiffies;
2698 ifsta->state = IEEE80211_STA_MLME_IBSS_SEARCH;
2699 return ieee80211_sta_find_ibss(sdata, ifsta);
2700 }
2701 1877
2702 return 0; 1878 return 0;
2703} 1879}
2704 1880
2705int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len) 1881int ieee80211_sta_get_ssid(struct ieee80211_sub_if_data *sdata, char *ssid, size_t *len)
2706{ 1882{
2707 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1883 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2708 memcpy(ssid, ifsta->ssid, ifsta->ssid_len); 1884 memcpy(ssid, ifmgd->ssid, ifmgd->ssid_len);
2709 *len = ifsta->ssid_len; 1885 *len = ifmgd->ssid_len;
2710 return 0; 1886 return 0;
2711} 1887}
2712 1888
2713int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid) 1889int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
2714{ 1890{
2715 struct ieee80211_if_sta *ifsta; 1891 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2716
2717 ifsta = &sdata->u.sta;
2718 1892
2719 if (is_valid_ether_addr(bssid)) { 1893 if (is_valid_ether_addr(bssid)) {
2720 memcpy(ifsta->bssid, bssid, ETH_ALEN); 1894 memcpy(ifmgd->bssid, bssid, ETH_ALEN);
2721 ifsta->flags |= IEEE80211_STA_BSSID_SET; 1895 ifmgd->flags |= IEEE80211_STA_BSSID_SET;
2722 } else { 1896 } else {
2723 memset(ifsta->bssid, 0, ETH_ALEN); 1897 memset(ifmgd->bssid, 0, ETH_ALEN);
2724 ifsta->flags &= ~IEEE80211_STA_BSSID_SET; 1898 ifmgd->flags &= ~IEEE80211_STA_BSSID_SET;
2725 } 1899 }
2726 1900
2727 if (netif_running(sdata->dev)) { 1901 if (netif_running(sdata->dev)) {
@@ -2731,47 +1905,44 @@ int ieee80211_sta_set_bssid(struct ieee80211_sub_if_data *sdata, u8 *bssid)
2731 } 1905 }
2732 } 1906 }
2733 1907
2734 return ieee80211_sta_set_ssid(sdata, ifsta->ssid, ifsta->ssid_len); 1908 return ieee80211_sta_set_ssid(sdata, ifmgd->ssid, ifmgd->ssid_len);
2735} 1909}
2736 1910
2737int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len) 1911int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data *sdata, char *ie, size_t len)
2738{ 1912{
2739 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1913 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2740 1914
2741 kfree(ifsta->extra_ie); 1915 kfree(ifmgd->extra_ie);
2742 if (len == 0) { 1916 if (len == 0) {
2743 ifsta->extra_ie = NULL; 1917 ifmgd->extra_ie = NULL;
2744 ifsta->extra_ie_len = 0; 1918 ifmgd->extra_ie_len = 0;
2745 return 0; 1919 return 0;
2746 } 1920 }
2747 ifsta->extra_ie = kmalloc(len, GFP_KERNEL); 1921 ifmgd->extra_ie = kmalloc(len, GFP_KERNEL);
2748 if (!ifsta->extra_ie) { 1922 if (!ifmgd->extra_ie) {
2749 ifsta->extra_ie_len = 0; 1923 ifmgd->extra_ie_len = 0;
2750 return -ENOMEM; 1924 return -ENOMEM;
2751 } 1925 }
2752 memcpy(ifsta->extra_ie, ie, len); 1926 memcpy(ifmgd->extra_ie, ie, len);
2753 ifsta->extra_ie_len = len; 1927 ifmgd->extra_ie_len = len;
2754 return 0; 1928 return 0;
2755} 1929}
2756 1930
2757int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason) 1931int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data *sdata, u16 reason)
2758{ 1932{
2759 struct ieee80211_if_sta *ifsta = &sdata->u.sta;
2760
2761 printk(KERN_DEBUG "%s: deauthenticating by local choice (reason=%d)\n", 1933 printk(KERN_DEBUG "%s: deauthenticating by local choice (reason=%d)\n",
2762 sdata->dev->name, reason); 1934 sdata->dev->name, reason);
2763 1935
2764 if (sdata->vif.type != NL80211_IFTYPE_STATION && 1936 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2765 sdata->vif.type != NL80211_IFTYPE_ADHOC)
2766 return -EINVAL; 1937 return -EINVAL;
2767 1938
2768 ieee80211_set_disassoc(sdata, ifsta, true, true, reason); 1939 ieee80211_set_disassoc(sdata, true, true, reason);
2769 return 0; 1940 return 0;
2770} 1941}
2771 1942
2772int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason) 1943int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
2773{ 1944{
2774 struct ieee80211_if_sta *ifsta = &sdata->u.sta; 1945 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2775 1946
2776 printk(KERN_DEBUG "%s: disassociating by local choice (reason=%d)\n", 1947 printk(KERN_DEBUG "%s: disassociating by local choice (reason=%d)\n",
2777 sdata->dev->name, reason); 1948 sdata->dev->name, reason);
@@ -2779,10 +1950,10 @@ int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
2779 if (sdata->vif.type != NL80211_IFTYPE_STATION) 1950 if (sdata->vif.type != NL80211_IFTYPE_STATION)
2780 return -EINVAL; 1951 return -EINVAL;
2781 1952
2782 if (!(ifsta->flags & IEEE80211_STA_ASSOCIATED)) 1953 if (!(ifmgd->flags & IEEE80211_STA_ASSOCIATED))
2783 return -1; 1954 return -ENOLINK;
2784 1955
2785 ieee80211_set_disassoc(sdata, ifsta, false, true, reason); 1956 ieee80211_set_disassoc(sdata, false, true, reason);
2786 return 0; 1957 return 0;
2787} 1958}
2788 1959
@@ -2790,14 +1961,6 @@ int ieee80211_sta_disassociate(struct ieee80211_sub_if_data *sdata, u16 reason)
2790void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local) 1961void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
2791{ 1962{
2792 struct ieee80211_sub_if_data *sdata = local->scan_sdata; 1963 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
2793 struct ieee80211_if_sta *ifsta;
2794
2795 if (sdata && sdata->vif.type == NL80211_IFTYPE_ADHOC) {
2796 ifsta = &sdata->u.sta;
2797 if ((!(ifsta->flags & IEEE80211_STA_PREV_BSSID_SET)) ||
2798 !ieee80211_sta_active_ibss(sdata))
2799 ieee80211_sta_find_ibss(sdata, ifsta);
2800 }
2801 1964
2802 /* Restart STA timers */ 1965 /* Restart STA timers */
2803 rcu_read_lock(); 1966 rcu_read_lock();
@@ -2844,3 +2007,36 @@ void ieee80211_dynamic_ps_timer(unsigned long data)
2844 2007
2845 queue_work(local->hw.workqueue, &local->dynamic_ps_enable_work); 2008 queue_work(local->hw.workqueue, &local->dynamic_ps_enable_work);
2846} 2009}
2010
2011void ieee80211_send_nullfunc(struct ieee80211_local *local,
2012 struct ieee80211_sub_if_data *sdata,
2013 int powersave)
2014{
2015 struct sk_buff *skb;
2016 struct ieee80211_hdr *nullfunc;
2017 __le16 fc;
2018
2019 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2020 return;
2021
2022 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
2023 if (!skb) {
2024 printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
2025 "frame\n", sdata->dev->name);
2026 return;
2027 }
2028 skb_reserve(skb, local->hw.extra_tx_headroom);
2029
2030 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
2031 memset(nullfunc, 0, 24);
2032 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
2033 IEEE80211_FCTL_TODS);
2034 if (powersave)
2035 fc |= cpu_to_le16(IEEE80211_FCTL_PM);
2036 nullfunc->frame_control = fc;
2037 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
2038 memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
2039 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
2040
2041 ieee80211_tx_skb(sdata, skb, 0);
2042}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-23 08:05:49 -0500