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