1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/delay.h>
15#include <linux/if_ether.h>
16#include <linux/skbuff.h>
17#include <linux/if_arp.h>
18#include <linux/etherdevice.h>
19#include <linux/rtnetlink.h>
20#include <linux/pm_qos_params.h>
21#include <linux/crc32.h>
22#include <net/mac80211.h>
23#include <asm/unaligned.h>
24
25#include "ieee80211_i.h"
26#include "driver-ops.h"
27#include "rate.h"
28#include "led.h"
29
30#define IEEE80211_AUTH_TIMEOUT (HZ / 5)
31#define IEEE80211_AUTH_MAX_TRIES 3
32#define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
33#define IEEE80211_ASSOC_MAX_TRIES 3
34#define IEEE80211_MAX_PROBE_TRIES 5
35
36
37
38
39
40#define IEEE80211_BEACON_LOSS_TIME (2 * HZ)
41
42
43
44
45#define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)
46
47
48
49
50
51#define IEEE80211_PROBE_WAIT (HZ / 2)
52
53#define TMR_RUNNING_TIMER 0
54#define TMR_RUNNING_CHANSW 1
55
56
57
58
59
60
61
62enum rx_mgmt_action {
63
64 RX_MGMT_NONE,
65
66
67 RX_MGMT_CFG80211_AUTH,
68
69
70 RX_MGMT_CFG80211_ASSOC,
71
72
73 RX_MGMT_CFG80211_DEAUTH,
74
75
76 RX_MGMT_CFG80211_DISASSOC,
77
78
79 RX_MGMT_CFG80211_AUTH_TO,
80
81
82 RX_MGMT_CFG80211_ASSOC_TO,
83};
84
85
86static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
87{
88 WARN_ON(!mutex_is_locked(&ifmgd->mtx));
89}
90
91
92
93
94
95
96
97
98
99
100
101static void run_again(struct ieee80211_if_managed *ifmgd,
102 unsigned long timeout)
103{
104 ASSERT_MGD_MTX(ifmgd);
105
106 if (!timer_pending(&ifmgd->timer) ||
107 time_before(timeout, ifmgd->timer.expires))
108 mod_timer(&ifmgd->timer, timeout);
109}
110
111static void mod_beacon_timer(struct ieee80211_sub_if_data *sdata)
112{
113 if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)
114 return;
115
116 mod_timer(&sdata->u.mgd.bcn_mon_timer,
117 round_jiffies_up(jiffies + IEEE80211_BEACON_LOSS_TIME));
118}
119
120static int ecw2cw(int ecw)
121{
122 return (1 << ecw) - 1;
123}
124
125static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
126 struct ieee80211_supported_band *sband,
127 u32 *rates)
128{
129 int i, j, count;
130 *rates = 0;
131 count = 0;
132 for (i = 0; i < bss->supp_rates_len; i++) {
133 int rate = (bss->supp_rates[i] & 0x7F) * 5;
134
135 for (j = 0; j < sband->n_bitrates; j++)
136 if (sband->bitrates[j].bitrate == rate) {
137 *rates |= BIT(j);
138 count++;
139 break;
140 }
141 }
142
143 return count;
144}
145
146
147
148
149
150
151static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
152 struct ieee80211_ht_info *hti,
153 const u8 *bssid, u16 ap_ht_cap_flags)
154{
155 struct ieee80211_local *local = sdata->local;
156 struct ieee80211_supported_band *sband;
157 struct sta_info *sta;
158 u32 changed = 0;
159 u16 ht_opmode;
160 bool enable_ht = true, ht_changed;
161 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
162
163 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
164
165
166 if (!sband->ht_cap.ht_supported)
167 enable_ht = false;
168
169
170 if (local->hw.conf.channel->center_freq !=
171 ieee80211_channel_to_frequency(hti->control_chan))
172 enable_ht = false;
173
174 if (enable_ht) {
175 channel_type = NL80211_CHAN_HT20;
176
177 if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
178 (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
179 (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
180 switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
181 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
182 if (!(local->hw.conf.channel->flags &
183 IEEE80211_CHAN_NO_HT40PLUS))
184 channel_type = NL80211_CHAN_HT40PLUS;
185 break;
186 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
187 if (!(local->hw.conf.channel->flags &
188 IEEE80211_CHAN_NO_HT40MINUS))
189 channel_type = NL80211_CHAN_HT40MINUS;
190 break;
191 }
192 }
193 }
194
195 ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||
196 channel_type != local->hw.conf.channel_type;
197
198 local->oper_channel_type = channel_type;
199
200 if (ht_changed) {
201
202 ieee80211_hw_config(local, 0);
203
204 rcu_read_lock();
205 sta = sta_info_get(local, bssid);
206 if (sta)
207 rate_control_rate_update(local, sband, sta,
208 IEEE80211_RC_HT_CHANGED);
209 rcu_read_unlock();
210 }
211
212
213 if (!enable_ht)
214 return 0;
215
216 ht_opmode = le16_to_cpu(hti->operation_mode);
217
218
219 if (!sdata->ht_opmode_valid ||
220 sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
221 changed |= BSS_CHANGED_HT;
222 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
223 sdata->ht_opmode_valid = true;
224 }
225
226 return changed;
227}
228
229
230
231static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
232 struct ieee80211_mgd_work *wk)
233{
234 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
235 struct ieee80211_local *local = sdata->local;
236 struct sk_buff *skb;
237 struct ieee80211_mgmt *mgmt;
238 u8 *pos;
239 const u8 *ies, *ht_ie;
240 int i, len, count, rates_len, supp_rates_len;
241 u16 capab;
242 int wmm = 0;
243 struct ieee80211_supported_band *sband;
244 u32 rates = 0;
245
246 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
247 sizeof(*mgmt) + 200 + wk->ie_len +
248 wk->ssid_len);
249 if (!skb) {
250 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
251 "frame\n", sdata->dev->name);
252 return;
253 }
254 skb_reserve(skb, local->hw.extra_tx_headroom);
255
256 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
257
258 capab = ifmgd->capab;
259
260 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
261 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
262 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
263 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
264 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
265 }
266
267 if (wk->bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
268 capab |= WLAN_CAPABILITY_PRIVACY;
269 if (wk->bss->wmm_used)
270 wmm = 1;
271
272
273
274
275
276 rates_len = ieee80211_compatible_rates(wk->bss, sband, &rates);
277
278 if ((wk->bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
279 (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
280 capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
281
282 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
283 memset(mgmt, 0, 24);
284 memcpy(mgmt->da, wk->bss->cbss.bssid, ETH_ALEN);
285 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
286 memcpy(mgmt->bssid, wk->bss->cbss.bssid, ETH_ALEN);
287
288 if (!is_zero_ether_addr(wk->prev_bssid)) {
289 skb_put(skb, 10);
290 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
291 IEEE80211_STYPE_REASSOC_REQ);
292 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
293 mgmt->u.reassoc_req.listen_interval =
294 cpu_to_le16(local->hw.conf.listen_interval);
295 memcpy(mgmt->u.reassoc_req.current_ap, wk->prev_bssid,
296 ETH_ALEN);
297 } else {
298 skb_put(skb, 4);
299 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
300 IEEE80211_STYPE_ASSOC_REQ);
301 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
302 mgmt->u.assoc_req.listen_interval =
303 cpu_to_le16(local->hw.conf.listen_interval);
304 }
305
306
307 ies = pos = skb_put(skb, 2 + wk->ssid_len);
308 *pos++ = WLAN_EID_SSID;
309 *pos++ = wk->ssid_len;
310 memcpy(pos, wk->ssid, wk->ssid_len);
311
312
313 supp_rates_len = rates_len;
314 if (supp_rates_len > 8)
315 supp_rates_len = 8;
316
317 len = sband->n_bitrates;
318 pos = skb_put(skb, supp_rates_len + 2);
319 *pos++ = WLAN_EID_SUPP_RATES;
320 *pos++ = supp_rates_len;
321
322 count = 0;
323 for (i = 0; i < sband->n_bitrates; i++) {
324 if (BIT(i) & rates) {
325 int rate = sband->bitrates[i].bitrate;
326 *pos++ = (u8) (rate / 5);
327 if (++count == 8)
328 break;
329 }
330 }
331
332 if (rates_len > count) {
333 pos = skb_put(skb, rates_len - count + 2);
334 *pos++ = WLAN_EID_EXT_SUPP_RATES;
335 *pos++ = rates_len - count;
336
337 for (i++; i < sband->n_bitrates; i++) {
338 if (BIT(i) & rates) {
339 int rate = sband->bitrates[i].bitrate;
340 *pos++ = (u8) (rate / 5);
341 }
342 }
343 }
344
345 if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
346
347 pos = skb_put(skb, 4);
348 *pos++ = WLAN_EID_PWR_CAPABILITY;
349 *pos++ = 2;
350 *pos++ = 0;
351 *pos++ = local->hw.conf.channel->max_power;
352
353
354
355 pos = skb_put(skb, 2 * sband->n_channels + 2);
356 *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
357 *pos++ = 2 * sband->n_channels;
358 for (i = 0; i < sband->n_channels; i++) {
359 *pos++ = ieee80211_frequency_to_channel(
360 sband->channels[i].center_freq);
361 *pos++ = 1;
362 }
363 }
364
365 if (wk->ie_len && wk->ie) {
366 pos = skb_put(skb, wk->ie_len);
367 memcpy(pos, wk->ie, wk->ie_len);
368 }
369
370 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
371 pos = skb_put(skb, 9);
372 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
373 *pos++ = 7;
374 *pos++ = 0x00;
375 *pos++ = 0x50;
376 *pos++ = 0xf2;
377 *pos++ = 2;
378 *pos++ = 0;
379 *pos++ = 1;
380 *pos++ = 0;
381 }
382
383
384
385
386
387
388
389
390 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
391 sband->ht_cap.ht_supported &&
392 (ht_ie = ieee80211_bss_get_ie(&wk->bss->cbss, WLAN_EID_HT_INFORMATION)) &&
393 ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
394 (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))) {
395 struct ieee80211_ht_info *ht_info =
396 (struct ieee80211_ht_info *)(ht_ie + 2);
397 u16 cap = sband->ht_cap.cap;
398 __le16 tmp;
399 u32 flags = local->hw.conf.channel->flags;
400
401 switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
402 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
403 if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
404 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
405 cap &= ~IEEE80211_HT_CAP_SGI_40;
406 }
407 break;
408 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
409 if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
410 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
411 cap &= ~IEEE80211_HT_CAP_SGI_40;
412 }
413 break;
414 }
415
416 tmp = cpu_to_le16(cap);
417 pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
418 *pos++ = WLAN_EID_HT_CAPABILITY;
419 *pos++ = sizeof(struct ieee80211_ht_cap);
420 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
421 memcpy(pos, &tmp, sizeof(u16));
422 pos += sizeof(u16);
423
424 *pos++ = sband->ht_cap.ampdu_factor |
425 (sband->ht_cap.ampdu_density << 2);
426 memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
427 }
428
429 ieee80211_tx_skb(sdata, skb, 0);
430}
431
432
433static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
434 const u8 *bssid, u16 stype, u16 reason,
435 void *cookie)
436{
437 struct ieee80211_local *local = sdata->local;
438 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
439 struct sk_buff *skb;
440 struct ieee80211_mgmt *mgmt;
441
442 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
443 if (!skb) {
444 printk(KERN_DEBUG "%s: failed to allocate buffer for "
445 "deauth/disassoc frame\n", sdata->dev->name);
446 return;
447 }
448 skb_reserve(skb, local->hw.extra_tx_headroom);
449
450 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
451 memset(mgmt, 0, 24);
452 memcpy(mgmt->da, bssid, ETH_ALEN);
453 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
454 memcpy(mgmt->bssid, bssid, ETH_ALEN);
455 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
456 skb_put(skb, 2);
457
458 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
459
460 if (stype == IEEE80211_STYPE_DEAUTH)
461 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, cookie);
462 else
463 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len, cookie);
464 ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);
465}
466
467void ieee80211_send_pspoll(struct ieee80211_local *local,
468 struct ieee80211_sub_if_data *sdata)
469{
470 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
471 struct ieee80211_pspoll *pspoll;
472 struct sk_buff *skb;
473 u16 fc;
474
475 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
476 if (!skb) {
477 printk(KERN_DEBUG "%s: failed to allocate buffer for "
478 "pspoll frame\n", sdata->dev->name);
479 return;
480 }
481 skb_reserve(skb, local->hw.extra_tx_headroom);
482
483 pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
484 memset(pspoll, 0, sizeof(*pspoll));
485 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
486 pspoll->frame_control = cpu_to_le16(fc);
487 pspoll->aid = cpu_to_le16(ifmgd->aid);
488
489
490 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
491
492 memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
493 memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);
494
495 ieee80211_tx_skb(sdata, skb, 0);
496}
497
498void ieee80211_send_nullfunc(struct ieee80211_local *local,
499 struct ieee80211_sub_if_data *sdata,
500 int powersave)
501{
502 struct sk_buff *skb;
503 struct ieee80211_hdr *nullfunc;
504 __le16 fc;
505
506 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
507 return;
508
509 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
510 if (!skb) {
511 printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
512 "frame\n", sdata->dev->name);
513 return;
514 }
515 skb_reserve(skb, local->hw.extra_tx_headroom);
516
517 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
518 memset(nullfunc, 0, 24);
519 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
520 IEEE80211_FCTL_TODS);
521 if (powersave)
522 fc |= cpu_to_le16(IEEE80211_FCTL_PM);
523 nullfunc->frame_control = fc;
524 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
525 memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
526 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
527
528 ieee80211_tx_skb(sdata, skb, 0);
529}
530
531
532static void ieee80211_chswitch_work(struct work_struct *work)
533{
534 struct ieee80211_sub_if_data *sdata =
535 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
536 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
537
538 if (!netif_running(sdata->dev))
539 return;
540
541 mutex_lock(&ifmgd->mtx);
542 if (!ifmgd->associated)
543 goto out;
544
545 sdata->local->oper_channel = sdata->local->csa_channel;
546 ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL);
547
548
549 ifmgd->associated->cbss.channel = sdata->local->oper_channel;
550
551 ieee80211_wake_queues_by_reason(&sdata->local->hw,
552 IEEE80211_QUEUE_STOP_REASON_CSA);
553 out:
554 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
555 mutex_unlock(&ifmgd->mtx);
556}
557
558static void ieee80211_chswitch_timer(unsigned long data)
559{
560 struct ieee80211_sub_if_data *sdata =
561 (struct ieee80211_sub_if_data *) data;
562 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
563
564 if (sdata->local->quiescing) {
565 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
566 return;
567 }
568
569 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
570}
571
572void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
573 struct ieee80211_channel_sw_ie *sw_elem,
574 struct ieee80211_bss *bss)
575{
576 struct ieee80211_channel *new_ch;
577 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
578 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
579
580 ASSERT_MGD_MTX(ifmgd);
581
582 if (!ifmgd->associated)
583 return;
584
585 if (sdata->local->scanning)
586 return;
587
588
589
590
591 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
592 return;
593
594 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
595 if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
596 return;
597
598 sdata->local->csa_channel = new_ch;
599
600 if (sw_elem->count <= 1) {
601 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
602 } else {
603 ieee80211_stop_queues_by_reason(&sdata->local->hw,
604 IEEE80211_QUEUE_STOP_REASON_CSA);
605 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
606 mod_timer(&ifmgd->chswitch_timer,
607 jiffies +
608 msecs_to_jiffies(sw_elem->count *
609 bss->cbss.beacon_interval));
610 }
611}
612
613static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
614 u16 capab_info, u8 *pwr_constr_elem,
615 u8 pwr_constr_elem_len)
616{
617 struct ieee80211_conf *conf = &sdata->local->hw.conf;
618
619 if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
620 return;
621
622
623 if (pwr_constr_elem_len != 1)
624 return;
625
626 if ((*pwr_constr_elem <= conf->channel->max_power) &&
627 (*pwr_constr_elem != sdata->local->power_constr_level)) {
628 sdata->local->power_constr_level = *pwr_constr_elem;
629 ieee80211_hw_config(sdata->local, 0);
630 }
631}
632
633
634static void ieee80211_enable_ps(struct ieee80211_local *local,
635 struct ieee80211_sub_if_data *sdata)
636{
637 struct ieee80211_conf *conf = &local->hw.conf;
638
639
640
641
642
643 if (local->scanning)
644 return;
645
646 if (conf->dynamic_ps_timeout > 0 &&
647 !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
648 mod_timer(&local->dynamic_ps_timer, jiffies +
649 msecs_to_jiffies(conf->dynamic_ps_timeout));
650 } else {
651 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
652 ieee80211_send_nullfunc(local, sdata, 1);
653 conf->flags |= IEEE80211_CONF_PS;
654 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
655 }
656}
657
658static void ieee80211_change_ps(struct ieee80211_local *local)
659{
660 struct ieee80211_conf *conf = &local->hw.conf;
661
662 if (local->ps_sdata) {
663 ieee80211_enable_ps(local, local->ps_sdata);
664 } else if (conf->flags & IEEE80211_CONF_PS) {
665 conf->flags &= ~IEEE80211_CONF_PS;
666 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
667 del_timer_sync(&local->dynamic_ps_timer);
668 cancel_work_sync(&local->dynamic_ps_enable_work);
669 }
670}
671
672
673void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
674{
675 struct ieee80211_sub_if_data *sdata, *found = NULL;
676 int count = 0;
677
678 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
679 local->ps_sdata = NULL;
680 return;
681 }
682
683 list_for_each_entry(sdata, &local->interfaces, list) {
684 if (!netif_running(sdata->dev))
685 continue;
686 if (sdata->vif.type != NL80211_IFTYPE_STATION)
687 continue;
688 found = sdata;
689 count++;
690 }
691
692 if (count == 1 && found->u.mgd.powersave &&
693 found->u.mgd.associated && list_empty(&found->u.mgd.work_list) &&
694 !(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |
695 IEEE80211_STA_CONNECTION_POLL))) {
696 s32 beaconint_us;
697
698 if (latency < 0)
699 latency = pm_qos_requirement(PM_QOS_NETWORK_LATENCY);
700
701 beaconint_us = ieee80211_tu_to_usec(
702 found->vif.bss_conf.beacon_int);
703
704 if (beaconint_us > latency) {
705 local->ps_sdata = NULL;
706 } else {
707 u8 dtimper = found->vif.bss_conf.dtim_period;
708 int maxslp = 1;
709
710 if (dtimper > 1)
711 maxslp = min_t(int, dtimper,
712 latency / beaconint_us);
713
714 local->hw.conf.max_sleep_period = maxslp;
715 local->ps_sdata = found;
716 }
717 } else {
718 local->ps_sdata = NULL;
719 }
720
721 ieee80211_change_ps(local);
722}
723
724void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
725{
726 struct ieee80211_local *local =
727 container_of(work, struct ieee80211_local,
728 dynamic_ps_disable_work);
729
730 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
731 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
732 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
733 }
734
735 ieee80211_wake_queues_by_reason(&local->hw,
736 IEEE80211_QUEUE_STOP_REASON_PS);
737}
738
739void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
740{
741 struct ieee80211_local *local =
742 container_of(work, struct ieee80211_local,
743 dynamic_ps_enable_work);
744 struct ieee80211_sub_if_data *sdata = local->ps_sdata;
745
746
747 if (!sdata)
748 return;
749
750 if (local->hw.conf.flags & IEEE80211_CONF_PS)
751 return;
752
753 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
754 ieee80211_send_nullfunc(local, sdata, 1);
755
756 local->hw.conf.flags |= IEEE80211_CONF_PS;
757 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
758}
759
760void ieee80211_dynamic_ps_timer(unsigned long data)
761{
762 struct ieee80211_local *local = (void *) data;
763
764 if (local->quiescing || local->suspended)
765 return;
766
767 ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
768}
769
770
771static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
772 struct ieee80211_if_managed *ifmgd,
773 u8 *wmm_param, size_t wmm_param_len)
774{
775 struct ieee80211_tx_queue_params params;
776 size_t left;
777 int count;
778 u8 *pos;
779
780 if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
781 return;
782
783 if (!wmm_param)
784 return;
785
786 if (wmm_param_len < 8 || wmm_param[5] != 1)
787 return;
788 count = wmm_param[6] & 0x0f;
789 if (count == ifmgd->wmm_last_param_set)
790 return;
791 ifmgd->wmm_last_param_set = count;
792
793 pos = wmm_param + 8;
794 left = wmm_param_len - 8;
795
796 memset(¶ms, 0, sizeof(params));
797
798 local->wmm_acm = 0;
799 for (; left >= 4; left -= 4, pos += 4) {
800 int aci = (pos[0] >> 5) & 0x03;
801 int acm = (pos[0] >> 4) & 0x01;
802 int queue;
803
804 switch (aci) {
805 case 1:
806 queue = 3;
807 if (acm)
808 local->wmm_acm |= BIT(1) | BIT(2);
809 break;
810 case 2:
811 queue = 1;
812 if (acm)
813 local->wmm_acm |= BIT(4) | BIT(5);
814 break;
815 case 3:
816 queue = 0;
817 if (acm)
818 local->wmm_acm |= BIT(6) | BIT(7);
819 break;
820 case 0:
821 default:
822 queue = 2;
823 if (acm)
824 local->wmm_acm |= BIT(0) | BIT(3);
825 break;
826 }
827
828 params.aifs = pos[0] & 0x0f;
829 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
830 params.cw_min = ecw2cw(pos[1] & 0x0f);
831 params.txop = get_unaligned_le16(pos + 2);
832#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
833 printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
834 "cWmin=%d cWmax=%d txop=%d\n",
835 wiphy_name(local->hw.wiphy), queue, aci, acm,
836 params.aifs, params.cw_min, params.cw_max, params.txop);
837#endif
838 if (drv_conf_tx(local, queue, ¶ms) && local->ops->conf_tx)
839 printk(KERN_DEBUG "%s: failed to set TX queue "
840 "parameters for queue %d\n",
841 wiphy_name(local->hw.wiphy), queue);
842 }
843}
844
845static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
846 u16 capab, bool erp_valid, u8 erp)
847{
848 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
849 u32 changed = 0;
850 bool use_protection;
851 bool use_short_preamble;
852 bool use_short_slot;
853
854 if (erp_valid) {
855 use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
856 use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
857 } else {
858 use_protection = false;
859 use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
860 }
861
862 use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
863
864 if (use_protection != bss_conf->use_cts_prot) {
865 bss_conf->use_cts_prot = use_protection;
866 changed |= BSS_CHANGED_ERP_CTS_PROT;
867 }
868
869 if (use_short_preamble != bss_conf->use_short_preamble) {
870 bss_conf->use_short_preamble = use_short_preamble;
871 changed |= BSS_CHANGED_ERP_PREAMBLE;
872 }
873
874 if (use_short_slot != bss_conf->use_short_slot) {
875 bss_conf->use_short_slot = use_short_slot;
876 changed |= BSS_CHANGED_ERP_SLOT;
877 }
878
879 return changed;
880}
881
882static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
883 struct ieee80211_mgd_work *wk,
884 u32 bss_info_changed)
885{
886 struct ieee80211_local *local = sdata->local;
887 struct ieee80211_bss *bss = wk->bss;
888
889 bss_info_changed |= BSS_CHANGED_ASSOC;
890
891 sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
892 sdata->vif.bss_conf.timestamp = bss->cbss.tsf;
893 sdata->vif.bss_conf.dtim_period = bss->dtim_period;
894
895 bss_info_changed |= BSS_CHANGED_BEACON_INT;
896 bss_info_changed |= ieee80211_handle_bss_capability(sdata,
897 bss->cbss.capability, bss->has_erp_value, bss->erp_value);
898
899 sdata->u.mgd.associated = bss;
900 sdata->u.mgd.old_associate_work = wk;
901 memcpy(sdata->u.mgd.bssid, bss->cbss.bssid, ETH_ALEN);
902
903
904 sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
905 IEEE80211_STA_BEACON_POLL);
906
907 ieee80211_led_assoc(local, 1);
908
909 sdata->vif.bss_conf.assoc = 1;
910
911
912
913
914
915 bss_info_changed |= BSS_CHANGED_BASIC_RATES;
916
917
918 bss_info_changed |= BSS_CHANGED_BSSID;
919
920 ieee80211_bss_info_change_notify(sdata, bss_info_changed);
921
922 mutex_lock(&local->iflist_mtx);
923 ieee80211_recalc_ps(local, -1);
924 mutex_unlock(&local->iflist_mtx);
925
926 netif_tx_start_all_queues(sdata->dev);
927 netif_carrier_on(sdata->dev);
928}
929
930static enum rx_mgmt_action __must_check
931ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,
932 struct ieee80211_mgd_work *wk)
933{
934 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
935 struct ieee80211_local *local = sdata->local;
936
937 wk->tries++;
938 if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
939 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
940 sdata->dev->name, wk->bss->cbss.bssid);
941
942
943
944
945
946 cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
947
948
949
950
951
952
953 ieee80211_queue_work(&local->hw, &ifmgd->work);
954 return RX_MGMT_CFG80211_AUTH_TO;
955 }
956
957 printk(KERN_DEBUG "%s: direct probe to AP %pM (try %d)\n",
958 sdata->dev->name, wk->bss->cbss.bssid,
959 wk->tries);
960
961
962
963
964
965 ieee80211_send_probe_req(sdata, NULL, wk->ssid, wk->ssid_len, NULL, 0);
966
967 wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
968 run_again(ifmgd, wk->timeout);
969
970 return RX_MGMT_NONE;
971}
972
973
974static enum rx_mgmt_action __must_check
975ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
976 struct ieee80211_mgd_work *wk)
977{
978 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
979 struct ieee80211_local *local = sdata->local;
980
981 wk->tries++;
982 if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
983 printk(KERN_DEBUG "%s: authentication with AP %pM"
984 " timed out\n",
985 sdata->dev->name, wk->bss->cbss.bssid);
986
987
988
989
990
991 cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
992
993
994
995
996
997
998 ieee80211_queue_work(&local->hw, &ifmgd->work);
999 return RX_MGMT_CFG80211_AUTH_TO;
1000 }
1001
1002 printk(KERN_DEBUG "%s: authenticate with AP %pM (try %d)\n",
1003 sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
1004
1005 ieee80211_send_auth(sdata, 1, wk->auth_alg, wk->ie, wk->ie_len,
1006 wk->bss->cbss.bssid, NULL, 0, 0);
1007 wk->auth_transaction = 2;
1008
1009 wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
1010 run_again(ifmgd, wk->timeout);
1011
1012 return RX_MGMT_NONE;
1013}
1014
1015static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
1016 bool deauth)
1017{
1018 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1019 struct ieee80211_local *local = sdata->local;
1020 struct sta_info *sta;
1021 u32 changed = 0, config_changed = 0;
1022 u8 bssid[ETH_ALEN];
1023
1024 ASSERT_MGD_MTX(ifmgd);
1025
1026 if (WARN_ON(!ifmgd->associated))
1027 return;
1028
1029 memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
1030
1031 ifmgd->associated = NULL;
1032 memset(ifmgd->bssid, 0, ETH_ALEN);
1033
1034 if (deauth) {
1035 kfree(ifmgd->old_associate_work);
1036 ifmgd->old_associate_work = NULL;
1037 } else {
1038 struct ieee80211_mgd_work *wk = ifmgd->old_associate_work;
1039
1040 wk->state = IEEE80211_MGD_STATE_IDLE;
1041 list_add(&wk->list, &ifmgd->work_list);
1042 }
1043
1044
1045
1046
1047
1048
1049
1050 smp_mb();
1051
1052
1053
1054
1055
1056
1057
1058 netif_tx_stop_all_queues(sdata->dev);
1059 netif_carrier_off(sdata->dev);
1060
1061 rcu_read_lock();
1062 sta = sta_info_get(local, bssid);
1063 if (sta)
1064 ieee80211_sta_tear_down_BA_sessions(sta);
1065 rcu_read_unlock();
1066
1067 changed |= ieee80211_reset_erp_info(sdata);
1068
1069 ieee80211_led_assoc(local, 0);
1070 changed |= BSS_CHANGED_ASSOC;
1071 sdata->vif.bss_conf.assoc = false;
1072
1073 ieee80211_set_wmm_default(sdata);
1074
1075 ieee80211_recalc_idle(local);
1076
1077
1078 local->oper_channel_type = NL80211_CHAN_NO_HT;
1079
1080
1081 sdata->ht_opmode_valid = false;
1082
1083 local->power_constr_level = 0;
1084
1085 del_timer_sync(&local->dynamic_ps_timer);
1086 cancel_work_sync(&local->dynamic_ps_enable_work);
1087
1088 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1089 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1090 config_changed |= IEEE80211_CONF_CHANGE_PS;
1091 }
1092
1093 ieee80211_hw_config(local, config_changed);
1094
1095
1096 changed |= BSS_CHANGED_BSSID;
1097 ieee80211_bss_info_change_notify(sdata, changed);
1098
1099 rcu_read_lock();
1100
1101 sta = sta_info_get(local, bssid);
1102 if (!sta) {
1103 rcu_read_unlock();
1104 return;
1105 }
1106
1107 sta_info_unlink(&sta);
1108
1109 rcu_read_unlock();
1110
1111 sta_info_destroy(sta);
1112}
1113
1114static enum rx_mgmt_action __must_check
1115ieee80211_associate(struct ieee80211_sub_if_data *sdata,
1116 struct ieee80211_mgd_work *wk)
1117{
1118 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1119 struct ieee80211_local *local = sdata->local;
1120
1121 wk->tries++;
1122 if (wk->tries > IEEE80211_ASSOC_MAX_TRIES) {
1123 printk(KERN_DEBUG "%s: association with AP %pM"
1124 " timed out\n",
1125 sdata->dev->name, wk->bss->cbss.bssid);
1126
1127
1128
1129
1130
1131 cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
1132
1133
1134
1135
1136
1137
1138 ieee80211_queue_work(&local->hw, &ifmgd->work);
1139 return RX_MGMT_CFG80211_ASSOC_TO;
1140 }
1141
1142 printk(KERN_DEBUG "%s: associate with AP %pM (try %d)\n",
1143 sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
1144 ieee80211_send_assoc(sdata, wk);
1145
1146 wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
1147 run_again(ifmgd, wk->timeout);
1148
1149 return RX_MGMT_NONE;
1150}
1151
1152void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
1153 struct ieee80211_hdr *hdr)
1154{
1155
1156
1157
1158
1159
1160
1161
1162
1163 if (is_multicast_ether_addr(hdr->addr1))
1164 return;
1165
1166 mod_timer(&sdata->u.mgd.conn_mon_timer,
1167 round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
1168}
1169
1170static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
1171{
1172 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1173 const u8 *ssid;
1174
1175 ssid = ieee80211_bss_get_ie(&ifmgd->associated->cbss, WLAN_EID_SSID);
1176 ieee80211_send_probe_req(sdata, ifmgd->associated->cbss.bssid,
1177 ssid + 2, ssid[1], NULL, 0);
1178
1179 ifmgd->probe_send_count++;
1180 ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT;
1181 run_again(ifmgd, ifmgd->probe_timeout);
1182}
1183
1184static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
1185 bool beacon)
1186{
1187 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1188 bool already = false;
1189
1190 if (!netif_running(sdata->dev))
1191 return;
1192
1193 if (sdata->local->scanning)
1194 return;
1195
1196 mutex_lock(&ifmgd->mtx);
1197
1198 if (!ifmgd->associated)
1199 goto out;
1200
1201#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1202 if (beacon && net_ratelimit())
1203 printk(KERN_DEBUG "%s: detected beacon loss from AP "
1204 "- sending probe request\n", sdata->dev->name);
1205#endif
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1219 IEEE80211_STA_CONNECTION_POLL))
1220 already = true;
1221
1222 if (beacon)
1223 ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
1224 else
1225 ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
1226
1227 if (already)
1228 goto out;
1229
1230 mutex_lock(&sdata->local->iflist_mtx);
1231 ieee80211_recalc_ps(sdata->local, -1);
1232 mutex_unlock(&sdata->local->iflist_mtx);
1233
1234 ifmgd->probe_send_count = 0;
1235 ieee80211_mgd_probe_ap_send(sdata);
1236 out:
1237 mutex_unlock(&ifmgd->mtx);
1238}
1239
1240void ieee80211_beacon_loss_work(struct work_struct *work)
1241{
1242 struct ieee80211_sub_if_data *sdata =
1243 container_of(work, struct ieee80211_sub_if_data,
1244 u.mgd.beacon_loss_work);
1245
1246 ieee80211_mgd_probe_ap(sdata, true);
1247}
1248
1249void ieee80211_beacon_loss(struct ieee80211_vif *vif)
1250{
1251 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1252
1253 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);
1254}
1255EXPORT_SYMBOL(ieee80211_beacon_loss);
1256
1257static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,
1258 struct ieee80211_mgd_work *wk)
1259{
1260 wk->state = IEEE80211_MGD_STATE_IDLE;
1261 printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
1262}
1263
1264
1265static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1266 struct ieee80211_mgd_work *wk,
1267 struct ieee80211_mgmt *mgmt,
1268 size_t len)
1269{
1270 u8 *pos;
1271 struct ieee802_11_elems elems;
1272
1273 pos = mgmt->u.auth.variable;
1274 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1275 if (!elems.challenge)
1276 return;
1277 ieee80211_send_auth(sdata, 3, wk->auth_alg,
1278 elems.challenge - 2, elems.challenge_len + 2,
1279 wk->bss->cbss.bssid,
1280 wk->key, wk->key_len, wk->key_idx);
1281 wk->auth_transaction = 4;
1282}
1283
1284static enum rx_mgmt_action __must_check
1285ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1286 struct ieee80211_mgd_work *wk,
1287 struct ieee80211_mgmt *mgmt, size_t len)
1288{
1289 u16 auth_alg, auth_transaction, status_code;
1290
1291 if (wk->state != IEEE80211_MGD_STATE_AUTH)
1292 return RX_MGMT_NONE;
1293
1294 if (len < 24 + 6)
1295 return RX_MGMT_NONE;
1296
1297 if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
1298 return RX_MGMT_NONE;
1299
1300 if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
1301 return RX_MGMT_NONE;
1302
1303 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1304 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1305 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1306
1307 if (auth_alg != wk->auth_alg ||
1308 auth_transaction != wk->auth_transaction)
1309 return RX_MGMT_NONE;
1310
1311 if (status_code != WLAN_STATUS_SUCCESS) {
1312 list_del(&wk->list);
1313 kfree(wk);
1314 return RX_MGMT_CFG80211_AUTH;
1315 }
1316
1317 switch (wk->auth_alg) {
1318 case WLAN_AUTH_OPEN:
1319 case WLAN_AUTH_LEAP:
1320 case WLAN_AUTH_FT:
1321 ieee80211_auth_completed(sdata, wk);
1322 return RX_MGMT_CFG80211_AUTH;
1323 case WLAN_AUTH_SHARED_KEY:
1324 if (wk->auth_transaction == 4) {
1325 ieee80211_auth_completed(sdata, wk);
1326 return RX_MGMT_CFG80211_AUTH;
1327 } else
1328 ieee80211_auth_challenge(sdata, wk, mgmt, len);
1329 break;
1330 }
1331
1332 return RX_MGMT_NONE;
1333}
1334
1335
1336static enum rx_mgmt_action __must_check
1337ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
1338 struct ieee80211_mgd_work *wk,
1339 struct ieee80211_mgmt *mgmt, size_t len)
1340{
1341 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1342 const u8 *bssid = NULL;
1343 u16 reason_code;
1344
1345 if (len < 24 + 2)
1346 return RX_MGMT_NONE;
1347
1348 ASSERT_MGD_MTX(ifmgd);
1349
1350 if (wk)
1351 bssid = wk->bss->cbss.bssid;
1352 else
1353 bssid = ifmgd->associated->cbss.bssid;
1354
1355 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1356
1357 printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
1358 sdata->dev->name, bssid, reason_code);
1359
1360 if (!wk) {
1361 ieee80211_set_disassoc(sdata, true);
1362 } else {
1363 list_del(&wk->list);
1364 kfree(wk);
1365 }
1366
1367 return RX_MGMT_CFG80211_DEAUTH;
1368}
1369
1370
1371static enum rx_mgmt_action __must_check
1372ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1373 struct ieee80211_mgmt *mgmt, size_t len)
1374{
1375 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1376 u16 reason_code;
1377
1378 if (len < 24 + 2)
1379 return RX_MGMT_NONE;
1380
1381 ASSERT_MGD_MTX(ifmgd);
1382
1383 if (WARN_ON(!ifmgd->associated))
1384 return RX_MGMT_NONE;
1385
1386 if (WARN_ON(memcmp(ifmgd->associated->cbss.bssid, mgmt->sa, ETH_ALEN)))
1387 return RX_MGMT_NONE;
1388
1389 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1390
1391 printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
1392 sdata->dev->name, mgmt->sa, reason_code);
1393
1394 ieee80211_set_disassoc(sdata, false);
1395 return RX_MGMT_CFG80211_DISASSOC;
1396}
1397
1398
1399static enum rx_mgmt_action __must_check
1400ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1401 struct ieee80211_mgd_work *wk,
1402 struct ieee80211_mgmt *mgmt, size_t len,
1403 bool reassoc)
1404{
1405 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1406 struct ieee80211_local *local = sdata->local;
1407 struct ieee80211_supported_band *sband;
1408 struct sta_info *sta;
1409 u32 rates, basic_rates;
1410 u16 capab_info, status_code, aid;
1411 struct ieee802_11_elems elems;
1412 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
1413 u8 *pos;
1414 u32 changed = 0;
1415 int i, j;
1416 bool have_higher_than_11mbit = false, newsta = false;
1417 u16 ap_ht_cap_flags;
1418
1419
1420
1421
1422
1423
1424 if (len < 24 + 6)
1425 return RX_MGMT_NONE;
1426
1427 if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
1428 return RX_MGMT_NONE;
1429
1430 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
1431 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
1432 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
1433
1434 printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
1435 "status=%d aid=%d)\n",
1436 sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,
1437 capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
1438
1439 pos = mgmt->u.assoc_resp.variable;
1440 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1441
1442 if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
1443 elems.timeout_int && elems.timeout_int_len == 5 &&
1444 elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
1445 u32 tu, ms;
1446 tu = get_unaligned_le32(elems.timeout_int + 1);
1447 ms = tu * 1024 / 1000;
1448 printk(KERN_DEBUG "%s: AP rejected association temporarily; "
1449 "comeback duration %u TU (%u ms)\n",
1450 sdata->dev->name, tu, ms);
1451 wk->timeout = jiffies + msecs_to_jiffies(ms);
1452 if (ms > IEEE80211_ASSOC_TIMEOUT)
1453 run_again(ifmgd, jiffies + msecs_to_jiffies(ms));
1454 return RX_MGMT_NONE;
1455 }
1456
1457 if (status_code != WLAN_STATUS_SUCCESS) {
1458 printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
1459 sdata->dev->name, status_code);
1460 wk->state = IEEE80211_MGD_STATE_IDLE;
1461 return RX_MGMT_CFG80211_ASSOC;
1462 }
1463
1464 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
1465 printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
1466 "set\n", sdata->dev->name, aid);
1467 aid &= ~(BIT(15) | BIT(14));
1468
1469 if (!elems.supp_rates) {
1470 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
1471 sdata->dev->name);
1472 return RX_MGMT_NONE;
1473 }
1474
1475 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
1476 ifmgd->aid = aid;
1477
1478 rcu_read_lock();
1479
1480
1481 sta = sta_info_get(local, wk->bss->cbss.bssid);
1482 if (!sta) {
1483 newsta = true;
1484
1485 rcu_read_unlock();
1486
1487 sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL);
1488 if (!sta) {
1489 printk(KERN_DEBUG "%s: failed to alloc STA entry for"
1490 " the AP\n", sdata->dev->name);
1491 return RX_MGMT_NONE;
1492 }
1493
1494 set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |
1495 WLAN_STA_ASSOC_AP);
1496 if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
1497 set_sta_flags(sta, WLAN_STA_AUTHORIZED);
1498
1499 rcu_read_lock();
1500 }
1501
1502 rates = 0;
1503 basic_rates = 0;
1504 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1505
1506 for (i = 0; i < elems.supp_rates_len; i++) {
1507 int rate = (elems.supp_rates[i] & 0x7f) * 5;
1508 bool is_basic = !!(elems.supp_rates[i] & 0x80);
1509
1510 if (rate > 110)
1511 have_higher_than_11mbit = true;
1512
1513 for (j = 0; j < sband->n_bitrates; j++) {
1514 if (sband->bitrates[j].bitrate == rate) {
1515 rates |= BIT(j);
1516 if (is_basic)
1517 basic_rates |= BIT(j);
1518 break;
1519 }
1520 }
1521 }
1522
1523 for (i = 0; i < elems.ext_supp_rates_len; i++) {
1524 int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;
1525 bool is_basic = !!(elems.ext_supp_rates[i] & 0x80);
1526
1527 if (rate > 110)
1528 have_higher_than_11mbit = true;
1529
1530 for (j = 0; j < sband->n_bitrates; j++) {
1531 if (sband->bitrates[j].bitrate == rate) {
1532 rates |= BIT(j);
1533 if (is_basic)
1534 basic_rates |= BIT(j);
1535 break;
1536 }
1537 }
1538 }
1539
1540 sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
1541 sdata->vif.bss_conf.basic_rates = basic_rates;
1542
1543
1544 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
1545 have_higher_than_11mbit)
1546 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
1547 else
1548 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
1549
1550 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
1551 ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
1552 elems.ht_cap_elem, &sta->sta.ht_cap);
1553
1554 ap_ht_cap_flags = sta->sta.ht_cap.cap;
1555
1556 rate_control_rate_init(sta);
1557
1558 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
1559 set_sta_flags(sta, WLAN_STA_MFP);
1560
1561 if (elems.wmm_param)
1562 set_sta_flags(sta, WLAN_STA_WME);
1563
1564 if (newsta) {
1565 int err = sta_info_insert(sta);
1566 if (err) {
1567 printk(KERN_DEBUG "%s: failed to insert STA entry for"
1568 " the AP (error %d)\n", sdata->dev->name, err);
1569 rcu_read_unlock();
1570 return RX_MGMT_NONE;
1571 }
1572 }
1573
1574 rcu_read_unlock();
1575
1576 if (elems.wmm_param)
1577 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1578 elems.wmm_param_len);
1579 else
1580 ieee80211_set_wmm_default(sdata);
1581
1582 if (elems.ht_info_elem && elems.wmm_param &&
1583 (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
1584 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
1585 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1586 wk->bss->cbss.bssid,
1587 ap_ht_cap_flags);
1588
1589
1590 list_del(&wk->list);
1591
1592
1593
1594 bss_conf->aid = aid;
1595 bss_conf->assoc_capability = capab_info;
1596
1597 ieee80211_set_associated(sdata, wk, changed);
1598
1599
1600
1601
1602
1603 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
1604 mod_beacon_timer(sdata);
1605
1606 return RX_MGMT_CFG80211_ASSOC;
1607}
1608
1609
1610static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1611 struct ieee80211_mgmt *mgmt,
1612 size_t len,
1613 struct ieee80211_rx_status *rx_status,
1614 struct ieee802_11_elems *elems,
1615 bool beacon)
1616{
1617 struct ieee80211_local *local = sdata->local;
1618 int freq;
1619 struct ieee80211_bss *bss;
1620 struct ieee80211_channel *channel;
1621
1622 if (elems->ds_params && elems->ds_params_len == 1)
1623 freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
1624 else
1625 freq = rx_status->freq;
1626
1627 channel = ieee80211_get_channel(local->hw.wiphy, freq);
1628
1629 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
1630 return;
1631
1632 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
1633 channel, beacon);
1634 if (bss)
1635 ieee80211_rx_bss_put(local, bss);
1636
1637 if (!sdata->u.mgd.associated)
1638 return;
1639
1640 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
1641 (memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid,
1642 ETH_ALEN) == 0)) {
1643 struct ieee80211_channel_sw_ie *sw_elem =
1644 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
1645 ieee80211_sta_process_chanswitch(sdata, sw_elem, bss);
1646 }
1647}
1648
1649
1650static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1651 struct ieee80211_mgd_work *wk,
1652 struct ieee80211_mgmt *mgmt, size_t len,
1653 struct ieee80211_rx_status *rx_status)
1654{
1655 struct ieee80211_if_managed *ifmgd;
1656 size_t baselen;
1657 struct ieee802_11_elems elems;
1658
1659 ifmgd = &sdata->u.mgd;
1660
1661 ASSERT_MGD_MTX(ifmgd);
1662
1663 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
1664 return;
1665
1666 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1667 if (baselen > len)
1668 return;
1669
1670 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
1671 &elems);
1672
1673 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
1674
1675
1676 if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) {
1677 printk(KERN_DEBUG "%s: direct probe responded\n",
1678 sdata->dev->name);
1679 wk->tries = 0;
1680 wk->state = IEEE80211_MGD_STATE_AUTH;
1681 WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE);
1682 }
1683
1684 if (ifmgd->associated &&
1685 memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 &&
1686 ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1687 IEEE80211_STA_CONNECTION_POLL)) {
1688 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1689 IEEE80211_STA_BEACON_POLL);
1690 mutex_lock(&sdata->local->iflist_mtx);
1691 ieee80211_recalc_ps(sdata->local, -1);
1692 mutex_unlock(&sdata->local->iflist_mtx);
1693
1694
1695
1696
1697
1698 mod_beacon_timer(sdata);
1699 mod_timer(&ifmgd->conn_mon_timer,
1700 round_jiffies_up(jiffies +
1701 IEEE80211_CONNECTION_IDLE_TIME));
1702 }
1703}
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718static const u64 care_about_ies =
1719 (1ULL << WLAN_EID_COUNTRY) |
1720 (1ULL << WLAN_EID_ERP_INFO) |
1721 (1ULL << WLAN_EID_CHANNEL_SWITCH) |
1722 (1ULL << WLAN_EID_PWR_CONSTRAINT) |
1723 (1ULL << WLAN_EID_HT_CAPABILITY) |
1724 (1ULL << WLAN_EID_HT_INFORMATION);
1725
1726static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1727 struct ieee80211_mgmt *mgmt,
1728 size_t len,
1729 struct ieee80211_rx_status *rx_status)
1730{
1731 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1732 size_t baselen;
1733 struct ieee802_11_elems elems;
1734 struct ieee80211_local *local = sdata->local;
1735 u32 changed = 0;
1736 bool erp_valid, directed_tim = false;
1737 u8 erp_value = 0;
1738 u32 ncrc;
1739 u8 *bssid;
1740
1741 ASSERT_MGD_MTX(ifmgd);
1742
1743
1744 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
1745 if (baselen > len)
1746 return;
1747
1748 if (rx_status->freq != local->hw.conf.channel->center_freq)
1749 return;
1750
1751
1752
1753
1754
1755 if (!ifmgd->associated)
1756 return;
1757
1758 bssid = ifmgd->associated->cbss.bssid;
1759
1760
1761
1762
1763
1764 if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)
1765 return;
1766
1767 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
1768#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1769 if (net_ratelimit()) {
1770 printk(KERN_DEBUG "%s: cancelling probereq poll due "
1771 "to a received beacon\n", sdata->dev->name);
1772 }
1773#endif
1774 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
1775 mutex_lock(&local->iflist_mtx);
1776 ieee80211_recalc_ps(local, -1);
1777 mutex_unlock(&local->iflist_mtx);
1778 }
1779
1780
1781
1782
1783
1784 mod_beacon_timer(sdata);
1785
1786 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
1787 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
1788 len - baselen, &elems,
1789 care_about_ies, ncrc);
1790
1791 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
1792 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
1793 ifmgd->aid);
1794
1795 if (ncrc != ifmgd->beacon_crc) {
1796 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
1797 true);
1798
1799 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1800 elems.wmm_param_len);
1801 }
1802
1803 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
1804 if (directed_tim) {
1805 if (local->hw.conf.dynamic_ps_timeout > 0) {
1806 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1807 ieee80211_hw_config(local,
1808 IEEE80211_CONF_CHANGE_PS);
1809 ieee80211_send_nullfunc(local, sdata, 0);
1810 } else {
1811 local->pspolling = true;
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821 ieee80211_send_pspoll(local, sdata);
1822 }
1823 }
1824 }
1825
1826 if (ncrc == ifmgd->beacon_crc)
1827 return;
1828 ifmgd->beacon_crc = ncrc;
1829
1830 if (elems.erp_info && elems.erp_info_len >= 1) {
1831 erp_valid = true;
1832 erp_value = elems.erp_info[0];
1833 } else {
1834 erp_valid = false;
1835 }
1836 changed |= ieee80211_handle_bss_capability(sdata,
1837 le16_to_cpu(mgmt->u.beacon.capab_info),
1838 erp_valid, erp_value);
1839
1840
1841 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
1842 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {
1843 struct sta_info *sta;
1844 struct ieee80211_supported_band *sband;
1845 u16 ap_ht_cap_flags;
1846
1847 rcu_read_lock();
1848
1849 sta = sta_info_get(local, bssid);
1850 if (WARN_ON(!sta)) {
1851 rcu_read_unlock();
1852 return;
1853 }
1854
1855 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1856
1857 ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
1858 elems.ht_cap_elem, &sta->sta.ht_cap);
1859
1860 ap_ht_cap_flags = sta->sta.ht_cap.cap;
1861
1862 rcu_read_unlock();
1863
1864 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1865 bssid, ap_ht_cap_flags);
1866 }
1867
1868
1869 if (elems.country_elem) {
1870
1871 if (elems.pwr_constr_elem)
1872 ieee80211_handle_pwr_constr(sdata,
1873 le16_to_cpu(mgmt->u.probe_resp.capab_info),
1874 elems.pwr_constr_elem,
1875 elems.pwr_constr_elem_len);
1876 }
1877
1878 ieee80211_bss_info_change_notify(sdata, changed);
1879}
1880
1881ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
1882 struct sk_buff *skb)
1883{
1884 struct ieee80211_local *local = sdata->local;
1885 struct ieee80211_mgmt *mgmt;
1886 u16 fc;
1887
1888 if (skb->len < 24)
1889 return RX_DROP_MONITOR;
1890
1891 mgmt = (struct ieee80211_mgmt *) skb->data;
1892 fc = le16_to_cpu(mgmt->frame_control);
1893
1894 switch (fc & IEEE80211_FCTL_STYPE) {
1895 case IEEE80211_STYPE_PROBE_REQ:
1896 case IEEE80211_STYPE_PROBE_RESP:
1897 case IEEE80211_STYPE_BEACON:
1898 case IEEE80211_STYPE_AUTH:
1899 case IEEE80211_STYPE_ASSOC_RESP:
1900 case IEEE80211_STYPE_REASSOC_RESP:
1901 case IEEE80211_STYPE_DEAUTH:
1902 case IEEE80211_STYPE_DISASSOC:
1903 case IEEE80211_STYPE_ACTION:
1904 skb_queue_tail(&sdata->u.mgd.skb_queue, skb);
1905 ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);
1906 return RX_QUEUED;
1907 }
1908
1909 return RX_DROP_MONITOR;
1910}
1911
1912static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1913 struct sk_buff *skb)
1914{
1915 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1916 struct ieee80211_rx_status *rx_status;
1917 struct ieee80211_mgmt *mgmt;
1918 struct ieee80211_mgd_work *wk;
1919 enum rx_mgmt_action rma = RX_MGMT_NONE;
1920 u16 fc;
1921
1922 rx_status = (struct ieee80211_rx_status *) skb->cb;
1923 mgmt = (struct ieee80211_mgmt *) skb->data;
1924 fc = le16_to_cpu(mgmt->frame_control);
1925
1926 mutex_lock(&ifmgd->mtx);
1927
1928 if (ifmgd->associated &&
1929 memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid,
1930 ETH_ALEN) == 0) {
1931 switch (fc & IEEE80211_FCTL_STYPE) {
1932 case IEEE80211_STYPE_BEACON:
1933 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
1934 rx_status);
1935 break;
1936 case IEEE80211_STYPE_PROBE_RESP:
1937 ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt,
1938 skb->len, rx_status);
1939 break;
1940 case IEEE80211_STYPE_DEAUTH:
1941 rma = ieee80211_rx_mgmt_deauth(sdata, NULL,
1942 mgmt, skb->len);
1943 break;
1944 case IEEE80211_STYPE_DISASSOC:
1945 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
1946 break;
1947 case IEEE80211_STYPE_ACTION:
1948
1949 ieee80211_sta_process_chanswitch(sdata,
1950 &mgmt->u.action.u.chan_switch.sw_elem,
1951 ifmgd->associated);
1952 break;
1953 }
1954 mutex_unlock(&ifmgd->mtx);
1955
1956 switch (rma) {
1957 case RX_MGMT_NONE:
1958
1959 break;
1960 case RX_MGMT_CFG80211_DEAUTH:
1961 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len,
1962 NULL);
1963 break;
1964 case RX_MGMT_CFG80211_DISASSOC:
1965 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len,
1966 NULL);
1967 break;
1968 default:
1969 WARN(1, "unexpected: %d", rma);
1970 }
1971 goto out;
1972 }
1973
1974 list_for_each_entry(wk, &ifmgd->work_list, list) {
1975 if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
1976 continue;
1977
1978 switch (fc & IEEE80211_FCTL_STYPE) {
1979 case IEEE80211_STYPE_PROBE_RESP:
1980 ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len,
1981 rx_status);
1982 break;
1983 case IEEE80211_STYPE_AUTH:
1984 rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len);
1985 break;
1986 case IEEE80211_STYPE_ASSOC_RESP:
1987 rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
1988 skb->len, false);
1989 break;
1990 case IEEE80211_STYPE_REASSOC_RESP:
1991 rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
1992 skb->len, true);
1993 break;
1994 case IEEE80211_STYPE_DEAUTH:
1995 rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt,
1996 skb->len);
1997 break;
1998 }
1999
2000
2001
2002
2003
2004
2005 break;
2006 }
2007
2008 mutex_unlock(&ifmgd->mtx);
2009
2010 switch (rma) {
2011 case RX_MGMT_NONE:
2012
2013 break;
2014 case RX_MGMT_CFG80211_AUTH:
2015 cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len);
2016 break;
2017 case RX_MGMT_CFG80211_ASSOC:
2018 cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len);
2019 break;
2020 case RX_MGMT_CFG80211_DEAUTH:
2021 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, NULL);
2022 break;
2023 default:
2024 WARN(1, "unexpected: %d", rma);
2025 }
2026
2027 out:
2028 kfree_skb(skb);
2029}
2030
2031static void ieee80211_sta_timer(unsigned long data)
2032{
2033 struct ieee80211_sub_if_data *sdata =
2034 (struct ieee80211_sub_if_data *) data;
2035 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2036 struct ieee80211_local *local = sdata->local;
2037
2038 if (local->quiescing) {
2039 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2040 return;
2041 }
2042
2043 ieee80211_queue_work(&local->hw, &ifmgd->work);
2044}
2045
2046static void ieee80211_sta_work(struct work_struct *work)
2047{
2048 struct ieee80211_sub_if_data *sdata =
2049 container_of(work, struct ieee80211_sub_if_data, u.mgd.work);
2050 struct ieee80211_local *local = sdata->local;
2051 struct ieee80211_if_managed *ifmgd;
2052 struct sk_buff *skb;
2053 struct ieee80211_mgd_work *wk, *tmp;
2054 LIST_HEAD(free_work);
2055 enum rx_mgmt_action rma;
2056 bool anybusy = false;
2057
2058 if (!netif_running(sdata->dev))
2059 return;
2060
2061 if (local->scanning)
2062 return;
2063
2064 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2065 return;
2066
2067
2068
2069
2070
2071 if (WARN(local->suspended, "STA MLME work scheduled while "
2072 "going to suspend\n"))
2073 return;
2074
2075 ifmgd = &sdata->u.mgd;
2076
2077
2078 while ((skb = skb_dequeue(&ifmgd->skb_queue)))
2079 ieee80211_sta_rx_queued_mgmt(sdata, skb);
2080
2081
2082 mutex_lock(&ifmgd->mtx);
2083
2084 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
2085 IEEE80211_STA_CONNECTION_POLL) &&
2086 ifmgd->associated) {
2087 u8 bssid[ETH_ALEN];
2088
2089 memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
2090 if (time_is_after_jiffies(ifmgd->probe_timeout))
2091 run_again(ifmgd, ifmgd->probe_timeout);
2092
2093 else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) {
2094#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2095 printk(KERN_DEBUG "No probe response from AP %pM"
2096 " after %dms, try %d\n", bssid,
2097 (1000 * IEEE80211_PROBE_WAIT)/HZ,
2098 ifmgd->probe_send_count);
2099#endif
2100 ieee80211_mgd_probe_ap_send(sdata);
2101 } else {
2102
2103
2104
2105
2106 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
2107 IEEE80211_STA_BEACON_POLL);
2108 printk(KERN_DEBUG "No probe response from AP %pM"
2109 " after %dms, disconnecting.\n",
2110 bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);
2111 ieee80211_set_disassoc(sdata, true);
2112 mutex_unlock(&ifmgd->mtx);
2113
2114
2115
2116
2117 ieee80211_send_deauth_disassoc(sdata, bssid,
2118 IEEE80211_STYPE_DEAUTH,
2119 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
2120 NULL);
2121 mutex_lock(&ifmgd->mtx);
2122 }
2123 }
2124
2125
2126 ieee80211_recalc_idle(local);
2127
2128 list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) {
2129 if (time_is_after_jiffies(wk->timeout)) {
2130
2131
2132
2133
2134
2135 run_again(ifmgd, wk->timeout);
2136 continue;
2137 }
2138
2139 switch (wk->state) {
2140 default:
2141 WARN_ON(1);
2142
2143 case IEEE80211_MGD_STATE_IDLE:
2144
2145 rma = RX_MGMT_NONE;
2146 break;
2147 case IEEE80211_MGD_STATE_PROBE:
2148 rma = ieee80211_direct_probe(sdata, wk);
2149 break;
2150 case IEEE80211_MGD_STATE_AUTH:
2151 rma = ieee80211_authenticate(sdata, wk);
2152 break;
2153 case IEEE80211_MGD_STATE_ASSOC:
2154 rma = ieee80211_associate(sdata, wk);
2155 break;
2156 }
2157
2158 switch (rma) {
2159 case RX_MGMT_NONE:
2160
2161 break;
2162 case RX_MGMT_CFG80211_AUTH_TO:
2163 case RX_MGMT_CFG80211_ASSOC_TO:
2164 list_del(&wk->list);
2165 list_add(&wk->list, &free_work);
2166 wk->tries = rma;
2167 break;
2168 default:
2169 WARN(1, "unexpected: %d", rma);
2170 }
2171 }
2172
2173 list_for_each_entry(wk, &ifmgd->work_list, list) {
2174 if (wk->state != IEEE80211_MGD_STATE_IDLE) {
2175 anybusy = true;
2176 break;
2177 }
2178 }
2179 if (!anybusy &&
2180 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request))
2181 ieee80211_queue_delayed_work(&local->hw,
2182 &local->scan_work,
2183 round_jiffies_relative(0));
2184
2185 mutex_unlock(&ifmgd->mtx);
2186
2187 list_for_each_entry_safe(wk, tmp, &free_work, list) {
2188 switch (wk->tries) {
2189 case RX_MGMT_CFG80211_AUTH_TO:
2190 cfg80211_send_auth_timeout(sdata->dev,
2191 wk->bss->cbss.bssid);
2192 break;
2193 case RX_MGMT_CFG80211_ASSOC_TO:
2194 cfg80211_send_assoc_timeout(sdata->dev,
2195 wk->bss->cbss.bssid);
2196 break;
2197 default:
2198 WARN(1, "unexpected: %d", wk->tries);
2199 }
2200
2201 list_del(&wk->list);
2202 kfree(wk);
2203 }
2204
2205 ieee80211_recalc_idle(local);
2206}
2207
2208static void ieee80211_sta_bcn_mon_timer(unsigned long data)
2209{
2210 struct ieee80211_sub_if_data *sdata =
2211 (struct ieee80211_sub_if_data *) data;
2212 struct ieee80211_local *local = sdata->local;
2213
2214 if (local->quiescing)
2215 return;
2216
2217 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);
2218}
2219
2220static void ieee80211_sta_conn_mon_timer(unsigned long data)
2221{
2222 struct ieee80211_sub_if_data *sdata =
2223 (struct ieee80211_sub_if_data *) data;
2224 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2225 struct ieee80211_local *local = sdata->local;
2226
2227 if (local->quiescing)
2228 return;
2229
2230 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
2231}
2232
2233static void ieee80211_sta_monitor_work(struct work_struct *work)
2234{
2235 struct ieee80211_sub_if_data *sdata =
2236 container_of(work, struct ieee80211_sub_if_data,
2237 u.mgd.monitor_work);
2238
2239 ieee80211_mgd_probe_ap(sdata, false);
2240}
2241
2242static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2243{
2244 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
2245 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |
2246 IEEE80211_STA_CONNECTION_POLL);
2247
2248
2249 ieee80211_queue_work(&sdata->local->hw,
2250 &sdata->u.mgd.monitor_work);
2251
2252 ieee80211_queue_work(&sdata->local->hw,
2253 &sdata->u.mgd.work);
2254 }
2255}
2256
2257#ifdef CONFIG_PM
2258void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
2259{
2260 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2261
2262
2263
2264
2265
2266
2267
2268 cancel_work_sync(&ifmgd->work);
2269 cancel_work_sync(&ifmgd->beacon_loss_work);
2270 if (del_timer_sync(&ifmgd->timer))
2271 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2272
2273 cancel_work_sync(&ifmgd->chswitch_work);
2274 if (del_timer_sync(&ifmgd->chswitch_timer))
2275 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
2276
2277 cancel_work_sync(&ifmgd->monitor_work);
2278
2279 del_timer_sync(&ifmgd->conn_mon_timer);
2280 del_timer_sync(&ifmgd->bcn_mon_timer);
2281}
2282
2283void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
2284{
2285 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2286
2287 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
2288 add_timer(&ifmgd->timer);
2289 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
2290 add_timer(&ifmgd->chswitch_timer);
2291}
2292#endif
2293
2294
2295void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2296{
2297 struct ieee80211_if_managed *ifmgd;
2298
2299 ifmgd = &sdata->u.mgd;
2300 INIT_WORK(&ifmgd->work, ieee80211_sta_work);
2301 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
2302 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
2303 INIT_WORK(&ifmgd->beacon_loss_work, ieee80211_beacon_loss_work);
2304 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
2305 (unsigned long) sdata);
2306 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
2307 (unsigned long) sdata);
2308 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
2309 (unsigned long) sdata);
2310 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
2311 (unsigned long) sdata);
2312 skb_queue_head_init(&ifmgd->skb_queue);
2313
2314 INIT_LIST_HEAD(&ifmgd->work_list);
2315
2316 ifmgd->capab = WLAN_CAPABILITY_ESS;
2317 ifmgd->flags = 0;
2318 if (sdata->local->hw.queues >= 4)
2319 ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
2320
2321 mutex_init(&ifmgd->mtx);
2322}
2323
2324
2325void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
2326{
2327 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
2328
2329
2330 rcu_read_lock();
2331 list_for_each_entry_rcu(sdata, &local->interfaces, list)
2332 ieee80211_restart_sta_timer(sdata);
2333 rcu_read_unlock();
2334}
2335
2336int ieee80211_max_network_latency(struct notifier_block *nb,
2337 unsigned long data, void *dummy)
2338{
2339 s32 latency_usec = (s32) data;
2340 struct ieee80211_local *local =
2341 container_of(nb, struct ieee80211_local,
2342 network_latency_notifier);
2343
2344 mutex_lock(&local->iflist_mtx);
2345 ieee80211_recalc_ps(local, latency_usec);
2346 mutex_unlock(&local->iflist_mtx);
2347
2348 return 0;
2349}
2350
2351
2352int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
2353 struct cfg80211_auth_request *req)
2354{
2355 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2356 const u8 *ssid;
2357 struct ieee80211_mgd_work *wk;
2358 u16 auth_alg;
2359
2360 switch (req->auth_type) {
2361 case NL80211_AUTHTYPE_OPEN_SYSTEM:
2362 auth_alg = WLAN_AUTH_OPEN;
2363 break;
2364 case NL80211_AUTHTYPE_SHARED_KEY:
2365 auth_alg = WLAN_AUTH_SHARED_KEY;
2366 break;
2367 case NL80211_AUTHTYPE_FT:
2368 auth_alg = WLAN_AUTH_FT;
2369 break;
2370 case NL80211_AUTHTYPE_NETWORK_EAP:
2371 auth_alg = WLAN_AUTH_LEAP;
2372 break;
2373 default:
2374 return -EOPNOTSUPP;
2375 }
2376
2377 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
2378 if (!wk)
2379 return -ENOMEM;
2380
2381 wk->bss = (void *)req->bss;
2382
2383 if (req->ie && req->ie_len) {
2384 memcpy(wk->ie, req->ie, req->ie_len);
2385 wk->ie_len = req->ie_len;
2386 }
2387
2388 if (req->key && req->key_len) {
2389 wk->key_len = req->key_len;
2390 wk->key_idx = req->key_idx;
2391 memcpy(wk->key, req->key, req->key_len);
2392 }
2393
2394 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
2395 memcpy(wk->ssid, ssid + 2, ssid[1]);
2396 wk->ssid_len = ssid[1];
2397
2398 wk->state = IEEE80211_MGD_STATE_PROBE;
2399 wk->auth_alg = auth_alg;
2400 wk->timeout = jiffies;
2401
2402
2403
2404
2405
2406 sdata->local->oper_channel = req->bss->channel;
2407 ieee80211_hw_config(sdata->local, 0);
2408
2409 mutex_lock(&ifmgd->mtx);
2410 list_add(&wk->list, &sdata->u.mgd.work_list);
2411 mutex_unlock(&ifmgd->mtx);
2412
2413 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
2414 return 0;
2415}
2416
2417int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
2418 struct cfg80211_assoc_request *req)
2419{
2420 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2421 struct ieee80211_mgd_work *wk, *found = NULL;
2422 int i, err;
2423
2424 mutex_lock(&ifmgd->mtx);
2425
2426 list_for_each_entry(wk, &ifmgd->work_list, list) {
2427 if (&wk->bss->cbss == req->bss &&
2428 wk->state == IEEE80211_MGD_STATE_IDLE) {
2429 found = wk;
2430 break;
2431 }
2432 }
2433
2434 if (!found) {
2435 err = -ENOLINK;
2436 goto out;
2437 }
2438
2439 list_del(&found->list);
2440
2441 wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL);
2442 if (!wk) {
2443 list_add(&found->list, &ifmgd->work_list);
2444 err = -ENOMEM;
2445 goto out;
2446 }
2447
2448 list_add(&wk->list, &ifmgd->work_list);
2449
2450 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
2451
2452 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)
2453 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
2454 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
2455 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
2456 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
2457
2458 sdata->local->oper_channel = req->bss->channel;
2459 ieee80211_hw_config(sdata->local, 0);
2460
2461 if (req->ie && req->ie_len) {
2462 memcpy(wk->ie, req->ie, req->ie_len);
2463 wk->ie_len = req->ie_len;
2464 } else
2465 wk->ie_len = 0;
2466
2467 if (req->prev_bssid)
2468 memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN);
2469
2470 wk->state = IEEE80211_MGD_STATE_ASSOC;
2471 wk->tries = 0;
2472 wk->timeout = jiffies;
2473
2474 if (req->use_mfp) {
2475 ifmgd->mfp = IEEE80211_MFP_REQUIRED;
2476 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
2477 } else {
2478 ifmgd->mfp = IEEE80211_MFP_DISABLED;
2479 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
2480 }
2481
2482 if (req->crypto.control_port)
2483 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
2484 else
2485 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
2486
2487 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
2488
2489 err = 0;
2490
2491 out:
2492 mutex_unlock(&ifmgd->mtx);
2493 return err;
2494}
2495
2496int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
2497 struct cfg80211_deauth_request *req,
2498 void *cookie)
2499{
2500 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2501 struct ieee80211_mgd_work *wk;
2502 const u8 *bssid = NULL;
2503
2504 mutex_lock(&ifmgd->mtx);
2505
2506 if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) {
2507 bssid = req->bss->bssid;
2508 ieee80211_set_disassoc(sdata, true);
2509 } else list_for_each_entry(wk, &ifmgd->work_list, list) {
2510 if (&wk->bss->cbss == req->bss) {
2511 bssid = req->bss->bssid;
2512 list_del(&wk->list);
2513 kfree(wk);
2514 break;
2515 }
2516 }
2517
2518
2519
2520
2521
2522
2523
2524 if (!bssid) {
2525 mutex_unlock(&ifmgd->mtx);
2526 return -ENOLINK;
2527 }
2528
2529 mutex_unlock(&ifmgd->mtx);
2530
2531 printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",
2532 sdata->dev->name, bssid, req->reason_code);
2533
2534 ieee80211_send_deauth_disassoc(sdata, bssid,
2535 IEEE80211_STYPE_DEAUTH, req->reason_code,
2536 cookie);
2537
2538 return 0;
2539}
2540
2541int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
2542 struct cfg80211_disassoc_request *req,
2543 void *cookie)
2544{
2545 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2546
2547 mutex_lock(&ifmgd->mtx);
2548
2549
2550
2551
2552
2553
2554
2555 if (&ifmgd->associated->cbss != req->bss) {
2556 mutex_unlock(&ifmgd->mtx);
2557 return -ENOLINK;
2558 }
2559
2560 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
2561 sdata->dev->name, req->bss->bssid, req->reason_code);
2562
2563 ieee80211_set_disassoc(sdata, false);
2564
2565 mutex_unlock(&ifmgd->mtx);
2566
2567 ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,
2568 IEEE80211_STYPE_DISASSOC, req->reason_code,
2569 cookie);
2570 return 0;
2571}
2572