projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mac80211: Support ht-cap over-rides.
[deliverable/linux.git] / net / mac80211 / work.c
1 /*
2 * mac80211 work implementation
3 *
4 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
5 * Copyright 2004, Instant802 Networks, Inc.
6 * Copyright 2005, Devicescape Software, Inc.
7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16 #include <linux/delay.h>
17 #include <linux/if_ether.h>
18 #include <linux/skbuff.h>
19 #include <linux/if_arp.h>
20 #include <linux/etherdevice.h>
21 #include <linux/crc32.h>
22 #include <linux/slab.h>
23 #include <net/mac80211.h>
24 #include <asm/unaligned.h>
25
26 #include "ieee80211_i.h"
27 #include "rate.h"
28 #include "driver-ops.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
35 enum work_action {
36 WORK_ACT_MISMATCH,
37 WORK_ACT_NONE,
38 WORK_ACT_TIMEOUT,
39 WORK_ACT_DONE,
40 };
41
42
43 /* utils */
44 static inline void ASSERT_WORK_MTX(struct ieee80211_local *local)
45 {
46 lockdep_assert_held(&local->mtx);
47 }
48
49 /*
50 * We can have multiple work items (and connection probing)
51 * scheduling this timer, but we need to take care to only
52 * reschedule it when it should fire _earlier_ than it was
53 * asked for before, or if it's not pending right now. This
54 * function ensures that. Note that it then is required to
55 * run this function for all timeouts after the first one
56 * has happened -- the work that runs from this timer will
57 * do that.
58 */
59 static void run_again(struct ieee80211_local *local,
60 unsigned long timeout)
61 {
62 ASSERT_WORK_MTX(local);
63
64 if (!timer_pending(&local->work_timer) ||
65 time_before(timeout, local->work_timer.expires))
66 mod_timer(&local->work_timer, timeout);
67 }
68
69 void free_work(struct ieee80211_work *wk)
70 {
71 kfree_rcu(wk, rcu_head);
72 }
73
74 static int ieee80211_compatible_rates(const u8 *supp_rates, int supp_rates_len,
75 struct ieee80211_supported_band *sband,
76 u32 *rates)
77 {
78 int i, j, count;
79 *rates = 0;
80 count = 0;
81 for (i = 0; i < supp_rates_len; i++) {
82 int rate = (supp_rates[i] & 0x7F) * 5;
83
84 for (j = 0; j < sband->n_bitrates; j++)
85 if (sband->bitrates[j].bitrate == rate) {
86 *rates |= BIT(j);
87 count++;
88 break;
89 }
90 }
91
92 return count;
93 }
94
95 /* frame sending functions */
96
97 static void ieee80211_add_ht_ie(struct ieee80211_sub_if_data *sdata,
98 struct sk_buff *skb, const u8 *ht_info_ie,
99 struct ieee80211_supported_band *sband,
100 struct ieee80211_channel *channel,
101 enum ieee80211_smps_mode smps)
102 {
103 struct ieee80211_ht_info *ht_info;
104 u8 *pos;
105 u32 flags = channel->flags;
106 u16 cap;
107 struct ieee80211_sta_ht_cap ht_cap;
108
109 BUILD_BUG_ON(sizeof(ht_cap) != sizeof(sband->ht_cap));
110
111 if (!sband->ht_cap.ht_supported)
112 return;
113
114 if (!ht_info_ie)
115 return;
116
117 if (ht_info_ie[1] < sizeof(struct ieee80211_ht_info))
118 return;
119
120 memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
121 ieee80211_apply_htcap_overrides(sdata, &ht_cap);
122
123 ht_info = (struct ieee80211_ht_info *)(ht_info_ie + 2);
124
125 /* determine capability flags */
126 cap = ht_cap.cap;
127
128 switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
129 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
130 if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
131 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
132 cap &= ~IEEE80211_HT_CAP_SGI_40;
133 }
134 break;
135 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
136 if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
137 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
138 cap &= ~IEEE80211_HT_CAP_SGI_40;
139 }
140 break;
141 }
142
143 /* set SM PS mode properly */
144 cap &= ~IEEE80211_HT_CAP_SM_PS;
145 switch (smps) {
146 case IEEE80211_SMPS_AUTOMATIC:
147 case IEEE80211_SMPS_NUM_MODES:
148 WARN_ON(1);
149 case IEEE80211_SMPS_OFF:
150 cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
151 IEEE80211_HT_CAP_SM_PS_SHIFT;
152 break;
153 case IEEE80211_SMPS_STATIC:
154 cap |= WLAN_HT_CAP_SM_PS_STATIC <<
155 IEEE80211_HT_CAP_SM_PS_SHIFT;
156 break;
157 case IEEE80211_SMPS_DYNAMIC:
158 cap |= WLAN_HT_CAP_SM_PS_DYNAMIC <<
159 IEEE80211_HT_CAP_SM_PS_SHIFT;
160 break;
161 }
162
163 /* reserve and fill IE */
164 pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2);
165 ieee80211_ie_build_ht_cap(pos, &ht_cap, cap);
166 }
167
168 static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
169 struct ieee80211_work *wk)
170 {
171 struct ieee80211_local *local = sdata->local;
172 struct sk_buff *skb;
173 struct ieee80211_mgmt *mgmt;
174 u8 *pos, qos_info;
175 size_t offset = 0, noffset;
176 int i, count, rates_len, supp_rates_len;
177 u16 capab;
178 struct ieee80211_supported_band *sband;
179 u32 rates = 0;
180
181 sband = local->hw.wiphy->bands[wk->chan->band];
182
183 if (wk->assoc.supp_rates_len) {
184 /*
185 * Get all rates supported by the device and the AP as
186 * some APs don't like getting a superset of their rates
187 * in the association request (e.g. D-Link DAP 1353 in
188 * b-only mode)...
189 */
190 rates_len = ieee80211_compatible_rates(wk->assoc.supp_rates,
191 wk->assoc.supp_rates_len,
192 sband, &rates);
193 } else {
194 /*
195 * In case AP not provide any supported rates information
196 * before association, we send information element(s) with
197 * all rates that we support.
198 */
199 rates = ~0;
200 rates_len = sband->n_bitrates;
201 }
202
203 skb = alloc_skb(local->hw.extra_tx_headroom +
204 sizeof(*mgmt) + /* bit too much but doesn't matter */
205 2 + wk->assoc.ssid_len + /* SSID */
206 4 + rates_len + /* (extended) rates */
207 4 + /* power capability */
208 2 + 2 * sband->n_channels + /* supported channels */
209 2 + sizeof(struct ieee80211_ht_cap) + /* HT */
210 wk->ie_len + /* extra IEs */
211 9, /* WMM */
212 GFP_KERNEL);
213 if (!skb)
214 return;
215
216 skb_reserve(skb, local->hw.extra_tx_headroom);
217
218 capab = WLAN_CAPABILITY_ESS;
219
220 if (sband->band == IEEE80211_BAND_2GHZ) {
221 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
222 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
223 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
224 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
225 }
226
227 if (wk->assoc.capability & WLAN_CAPABILITY_PRIVACY)
228 capab |= WLAN_CAPABILITY_PRIVACY;
229
230 if ((wk->assoc.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
231 (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
232 capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
233
234 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
235 memset(mgmt, 0, 24);
236 memcpy(mgmt->da, wk->filter_ta, ETH_ALEN);
237 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
238 memcpy(mgmt->bssid, wk->filter_ta, ETH_ALEN);
239
240 if (!is_zero_ether_addr(wk->assoc.prev_bssid)) {
241 skb_put(skb, 10);
242 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
243 IEEE80211_STYPE_REASSOC_REQ);
244 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
245 mgmt->u.reassoc_req.listen_interval =
246 cpu_to_le16(local->hw.conf.listen_interval);
247 memcpy(mgmt->u.reassoc_req.current_ap, wk->assoc.prev_bssid,
248 ETH_ALEN);
249 } else {
250 skb_put(skb, 4);
251 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
252 IEEE80211_STYPE_ASSOC_REQ);
253 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
254 mgmt->u.assoc_req.listen_interval =
255 cpu_to_le16(local->hw.conf.listen_interval);
256 }
257
258 /* SSID */
259 pos = skb_put(skb, 2 + wk->assoc.ssid_len);
260 *pos++ = WLAN_EID_SSID;
261 *pos++ = wk->assoc.ssid_len;
262 memcpy(pos, wk->assoc.ssid, wk->assoc.ssid_len);
263
264 /* add all rates which were marked to be used above */
265 supp_rates_len = rates_len;
266 if (supp_rates_len > 8)
267 supp_rates_len = 8;
268
269 pos = skb_put(skb, supp_rates_len + 2);
270 *pos++ = WLAN_EID_SUPP_RATES;
271 *pos++ = supp_rates_len;
272
273 count = 0;
274 for (i = 0; i < sband->n_bitrates; i++) {
275 if (BIT(i) & rates) {
276 int rate = sband->bitrates[i].bitrate;
277 *pos++ = (u8) (rate / 5);
278 if (++count == 8)
279 break;
280 }
281 }
282
283 if (rates_len > count) {
284 pos = skb_put(skb, rates_len - count + 2);
285 *pos++ = WLAN_EID_EXT_SUPP_RATES;
286 *pos++ = rates_len - count;
287
288 for (i++; i < sband->n_bitrates; i++) {
289 if (BIT(i) & rates) {
290 int rate = sband->bitrates[i].bitrate;
291 *pos++ = (u8) (rate / 5);
292 }
293 }
294 }
295
296 if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
297 /* 1. power capabilities */
298 pos = skb_put(skb, 4);
299 *pos++ = WLAN_EID_PWR_CAPABILITY;
300 *pos++ = 2;
301 *pos++ = 0; /* min tx power */
302 *pos++ = wk->chan->max_power; /* max tx power */
303
304 /* 2. supported channels */
305 /* TODO: get this in reg domain format */
306 pos = skb_put(skb, 2 * sband->n_channels + 2);
307 *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
308 *pos++ = 2 * sband->n_channels;
309 for (i = 0; i < sband->n_channels; i++) {
310 *pos++ = ieee80211_frequency_to_channel(
311 sband->channels[i].center_freq);
312 *pos++ = 1; /* one channel in the subband*/
313 }
314 }
315
316 /* if present, add any custom IEs that go before HT */
317 if (wk->ie_len && wk->ie) {
318 static const u8 before_ht[] = {
319 WLAN_EID_SSID,
320 WLAN_EID_SUPP_RATES,
321 WLAN_EID_EXT_SUPP_RATES,
322 WLAN_EID_PWR_CAPABILITY,
323 WLAN_EID_SUPPORTED_CHANNELS,
324 WLAN_EID_RSN,
325 WLAN_EID_QOS_CAPA,
326 WLAN_EID_RRM_ENABLED_CAPABILITIES,
327 WLAN_EID_MOBILITY_DOMAIN,
328 WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
329 };
330 noffset = ieee80211_ie_split(wk->ie, wk->ie_len,
331 before_ht, ARRAY_SIZE(before_ht),
332 offset);
333 pos = skb_put(skb, noffset - offset);
334 memcpy(pos, wk->ie + offset, noffset - offset);
335 offset = noffset;
336 }
337
338 if (wk->assoc.use_11n && wk->assoc.wmm_used &&
339 local->hw.queues >= 4)
340 ieee80211_add_ht_ie(sdata, skb, wk->assoc.ht_information_ie,
341 sband, wk->chan, wk->assoc.smps);
342
343 /* if present, add any custom non-vendor IEs that go after HT */
344 if (wk->ie_len && wk->ie) {
345 noffset = ieee80211_ie_split_vendor(wk->ie, wk->ie_len,
346 offset);
347 pos = skb_put(skb, noffset - offset);
348 memcpy(pos, wk->ie + offset, noffset - offset);
349 offset = noffset;
350 }
351
352 if (wk->assoc.wmm_used && local->hw.queues >= 4) {
353 if (wk->assoc.uapsd_used) {
354 qos_info = local->uapsd_queues;
355 qos_info |= (local->uapsd_max_sp_len <<
356 IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT);
357 } else {
358 qos_info = 0;
359 }
360
361 pos = skb_put(skb, 9);
362 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
363 *pos++ = 7; /* len */
364 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
365 *pos++ = 0x50;
366 *pos++ = 0xf2;
367 *pos++ = 2; /* WME */
368 *pos++ = 0; /* WME info */
369 *pos++ = 1; /* WME ver */
370 *pos++ = qos_info;
371 }
372
373 /* add any remaining custom (i.e. vendor specific here) IEs */
374 if (wk->ie_len && wk->ie) {
375 noffset = wk->ie_len;
376 pos = skb_put(skb, noffset - offset);
377 memcpy(pos, wk->ie + offset, noffset - offset);
378 }
379
380 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
381 ieee80211_tx_skb(sdata, skb);
382 }
383
384 static void ieee80211_remove_auth_bss(struct ieee80211_local *local,
385 struct ieee80211_work *wk)
386 {
387 struct cfg80211_bss *cbss;
388 u16 capa_val = WLAN_CAPABILITY_ESS;
389
390 if (wk->probe_auth.privacy)
391 capa_val |= WLAN_CAPABILITY_PRIVACY;
392
393 cbss = cfg80211_get_bss(local->hw.wiphy, wk->chan, wk->filter_ta,
394 wk->probe_auth.ssid, wk->probe_auth.ssid_len,
395 WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_PRIVACY,
396 capa_val);
397 if (!cbss)
398 return;
399
400 cfg80211_unlink_bss(local->hw.wiphy, cbss);
401 cfg80211_put_bss(cbss);
402 }
403
404 static enum work_action __must_check
405 ieee80211_direct_probe(struct ieee80211_work *wk)
406 {
407 struct ieee80211_sub_if_data *sdata = wk->sdata;
408 struct ieee80211_local *local = sdata->local;
409
410 if (!wk->probe_auth.synced) {
411 int ret = drv_tx_sync(local, sdata, wk->filter_ta,
412 IEEE80211_TX_SYNC_AUTH);
413 if (ret)
414 return WORK_ACT_TIMEOUT;
415 }
416 wk->probe_auth.synced = true;
417
418 wk->probe_auth.tries++;
419 if (wk->probe_auth.tries > IEEE80211_AUTH_MAX_TRIES) {
420 printk(KERN_DEBUG "%s: direct probe to %pM timed out\n",
421 sdata->name, wk->filter_ta);
422
423 /*
424 * Most likely AP is not in the range so remove the
425 * bss struct for that AP.
426 */
427 ieee80211_remove_auth_bss(local, wk);
428
429 return WORK_ACT_TIMEOUT;
430 }
431
432 printk(KERN_DEBUG "%s: direct probe to %pM (try %d/%i)\n",
433 sdata->name, wk->filter_ta, wk->probe_auth.tries,
434 IEEE80211_AUTH_MAX_TRIES);
435
436 /*
437 * Direct probe is sent to broadcast address as some APs
438 * will not answer to direct packet in unassociated state.
439 */
440 ieee80211_send_probe_req(sdata, NULL, wk->probe_auth.ssid,
441 wk->probe_auth.ssid_len, NULL, 0,
442 (u32) -1, true, false);
443
444 wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
445 run_again(local, wk->timeout);
446
447 return WORK_ACT_NONE;
448 }
449
450
451 static enum work_action __must_check
452 ieee80211_authenticate(struct ieee80211_work *wk)
453 {
454 struct ieee80211_sub_if_data *sdata = wk->sdata;
455 struct ieee80211_local *local = sdata->local;
456
457 if (!wk->probe_auth.synced) {
458 int ret = drv_tx_sync(local, sdata, wk->filter_ta,
459 IEEE80211_TX_SYNC_AUTH);
460 if (ret)
461 return WORK_ACT_TIMEOUT;
462 }
463 wk->probe_auth.synced = true;
464
465 wk->probe_auth.tries++;
466 if (wk->probe_auth.tries > IEEE80211_AUTH_MAX_TRIES) {
467 printk(KERN_DEBUG "%s: authentication with %pM"
468 " timed out\n", sdata->name, wk->filter_ta);
469
470 /*
471 * Most likely AP is not in the range so remove the
472 * bss struct for that AP.
473 */
474 ieee80211_remove_auth_bss(local, wk);
475
476 return WORK_ACT_TIMEOUT;
477 }
478
479 printk(KERN_DEBUG "%s: authenticate with %pM (try %d)\n",
480 sdata->name, wk->filter_ta, wk->probe_auth.tries);
481
482 ieee80211_send_auth(sdata, 1, wk->probe_auth.algorithm, wk->ie,
483 wk->ie_len, wk->filter_ta, NULL, 0, 0);
484 wk->probe_auth.transaction = 2;
485
486 wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
487 run_again(local, wk->timeout);
488
489 return WORK_ACT_NONE;
490 }
491
492 static enum work_action __must_check
493 ieee80211_associate(struct ieee80211_work *wk)
494 {
495 struct ieee80211_sub_if_data *sdata = wk->sdata;
496 struct ieee80211_local *local = sdata->local;
497
498 if (!wk->assoc.synced) {
499 int ret = drv_tx_sync(local, sdata, wk->filter_ta,
500 IEEE80211_TX_SYNC_ASSOC);
501 if (ret)
502 return WORK_ACT_TIMEOUT;
503 }
504 wk->assoc.synced = true;
505
506 wk->assoc.tries++;
507 if (wk->assoc.tries > IEEE80211_ASSOC_MAX_TRIES) {
508 printk(KERN_DEBUG "%s: association with %pM"
509 " timed out\n",
510 sdata->name, wk->filter_ta);
511
512 /*
513 * Most likely AP is not in the range so remove the
514 * bss struct for that AP.
515 */
516 if (wk->assoc.bss)
517 cfg80211_unlink_bss(local->hw.wiphy, wk->assoc.bss);
518
519 return WORK_ACT_TIMEOUT;
520 }
521
522 printk(KERN_DEBUG "%s: associate with %pM (try %d)\n",
523 sdata->name, wk->filter_ta, wk->assoc.tries);
524 ieee80211_send_assoc(sdata, wk);
525
526 wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
527 run_again(local, wk->timeout);
528
529 return WORK_ACT_NONE;
530 }
531
532 static enum work_action __must_check
533 ieee80211_remain_on_channel_timeout(struct ieee80211_work *wk)
534 {
535 /*
536 * First time we run, do nothing -- the generic code will
537 * have switched to the right channel etc.
538 */
539 if (!wk->started) {
540 wk->timeout = jiffies + msecs_to_jiffies(wk->remain.duration);
541
542 cfg80211_ready_on_channel(wk->sdata->dev, (unsigned long) wk,
543 wk->chan, wk->chan_type,
544 wk->remain.duration, GFP_KERNEL);
545
546 return WORK_ACT_NONE;
547 }
548
549 return WORK_ACT_TIMEOUT;
550 }
551
552 static enum work_action __must_check
553 ieee80211_offchannel_tx(struct ieee80211_work *wk)
554 {
555 if (!wk->started) {
556 wk->timeout = jiffies + msecs_to_jiffies(wk->offchan_tx.wait);
557
558 /*
559 * After this, offchan_tx.frame remains but now is no
560 * longer a valid pointer -- we still need it as the
561 * cookie for canceling this work/status matching.
562 */
563 ieee80211_tx_skb(wk->sdata, wk->offchan_tx.frame);
564
565 return WORK_ACT_NONE;
566 }
567
568 return WORK_ACT_TIMEOUT;
569 }
570
571 static enum work_action __must_check
572 ieee80211_assoc_beacon_wait(struct ieee80211_work *wk)
573 {
574 if (wk->started)
575 return WORK_ACT_TIMEOUT;
576
577 /*
578 * Wait up to one beacon interval ...
579 * should this be more if we miss one?
580 */
581 printk(KERN_DEBUG "%s: waiting for beacon from %pM\n",
582 wk->sdata->name, wk->filter_ta);
583 wk->timeout = TU_TO_EXP_TIME(wk->assoc.bss->beacon_interval);
584 return WORK_ACT_NONE;
585 }
586
587 static void ieee80211_auth_challenge(struct ieee80211_work *wk,
588 struct ieee80211_mgmt *mgmt,
589 size_t len)
590 {
591 struct ieee80211_sub_if_data *sdata = wk->sdata;
592 u8 *pos;
593 struct ieee802_11_elems elems;
594
595 pos = mgmt->u.auth.variable;
596 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
597 if (!elems.challenge)
598 return;
599 ieee80211_send_auth(sdata, 3, wk->probe_auth.algorithm,
600 elems.challenge - 2, elems.challenge_len + 2,
601 wk->filter_ta, wk->probe_auth.key,
602 wk->probe_auth.key_len, wk->probe_auth.key_idx);
603 wk->probe_auth.transaction = 4;
604 }
605
606 static enum work_action __must_check
607 ieee80211_rx_mgmt_auth(struct ieee80211_work *wk,
608 struct ieee80211_mgmt *mgmt, size_t len)
609 {
610 u16 auth_alg, auth_transaction, status_code;
611
612 if (wk->type != IEEE80211_WORK_AUTH)
613 return WORK_ACT_MISMATCH;
614
615 if (len < 24 + 6)
616 return WORK_ACT_NONE;
617
618 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
619 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
620 status_code = le16_to_cpu(mgmt->u.auth.status_code);
621
622 if (auth_alg != wk->probe_auth.algorithm ||
623 auth_transaction != wk->probe_auth.transaction)
624 return WORK_ACT_NONE;
625
626 if (status_code != WLAN_STATUS_SUCCESS) {
627 printk(KERN_DEBUG "%s: %pM denied authentication (status %d)\n",
628 wk->sdata->name, mgmt->sa, status_code);
629 return WORK_ACT_DONE;
630 }
631
632 switch (wk->probe_auth.algorithm) {
633 case WLAN_AUTH_OPEN:
634 case WLAN_AUTH_LEAP:
635 case WLAN_AUTH_FT:
636 break;
637 case WLAN_AUTH_SHARED_KEY:
638 if (wk->probe_auth.transaction != 4) {
639 ieee80211_auth_challenge(wk, mgmt, len);
640 /* need another frame */
641 return WORK_ACT_NONE;
642 }
643 break;
644 default:
645 WARN_ON(1);
646 return WORK_ACT_NONE;
647 }
648
649 printk(KERN_DEBUG "%s: authenticated\n", wk->sdata->name);
650 return WORK_ACT_DONE;
651 }
652
653 static enum work_action __must_check
654 ieee80211_rx_mgmt_assoc_resp(struct ieee80211_work *wk,
655 struct ieee80211_mgmt *mgmt, size_t len,
656 bool reassoc)
657 {
658 struct ieee80211_sub_if_data *sdata = wk->sdata;
659 struct ieee80211_local *local = sdata->local;
660 u16 capab_info, status_code, aid;
661 struct ieee802_11_elems elems;
662 u8 *pos;
663
664 if (wk->type != IEEE80211_WORK_ASSOC)
665 return WORK_ACT_MISMATCH;
666
667 /*
668 * AssocResp and ReassocResp have identical structure, so process both
669 * of them in this function.
670 */
671
672 if (len < 24 + 6)
673 return WORK_ACT_NONE;
674
675 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
676 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
677 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
678
679 printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
680 "status=%d aid=%d)\n",
681 sdata->name, reassoc ? "Rea" : "A", mgmt->sa,
682 capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
683
684 pos = mgmt->u.assoc_resp.variable;
685 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
686
687 if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
688 elems.timeout_int && elems.timeout_int_len == 5 &&
689 elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
690 u32 tu, ms;
691 tu = get_unaligned_le32(elems.timeout_int + 1);
692 ms = tu * 1024 / 1000;
693 printk(KERN_DEBUG "%s: %pM rejected association temporarily; "
694 "comeback duration %u TU (%u ms)\n",
695 sdata->name, mgmt->sa, tu, ms);
696 wk->timeout = jiffies + msecs_to_jiffies(ms);
697 if (ms > IEEE80211_ASSOC_TIMEOUT)
698 run_again(local, wk->timeout);
699 return WORK_ACT_NONE;
700 }
701
702 if (status_code != WLAN_STATUS_SUCCESS)
703 printk(KERN_DEBUG "%s: %pM denied association (code=%d)\n",
704 sdata->name, mgmt->sa, status_code);
705 else
706 printk(KERN_DEBUG "%s: associated\n", sdata->name);
707
708 return WORK_ACT_DONE;
709 }
710
711 static enum work_action __must_check
712 ieee80211_rx_mgmt_probe_resp(struct ieee80211_work *wk,
713 struct ieee80211_mgmt *mgmt, size_t len,
714 struct ieee80211_rx_status *rx_status)
715 {
716 struct ieee80211_sub_if_data *sdata = wk->sdata;
717 struct ieee80211_local *local = sdata->local;
718 size_t baselen;
719
720 ASSERT_WORK_MTX(local);
721
722 if (wk->type != IEEE80211_WORK_DIRECT_PROBE)
723 return WORK_ACT_MISMATCH;
724
725 if (len < 24 + 12)
726 return WORK_ACT_NONE;
727
728 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
729 if (baselen > len)
730 return WORK_ACT_NONE;
731
732 printk(KERN_DEBUG "%s: direct probe responded\n", sdata->name);
733 return WORK_ACT_DONE;
734 }
735
736 static enum work_action __must_check
737 ieee80211_rx_mgmt_beacon(struct ieee80211_work *wk,
738 struct ieee80211_mgmt *mgmt, size_t len)
739 {
740 struct ieee80211_sub_if_data *sdata = wk->sdata;
741 struct ieee80211_local *local = sdata->local;
742
743 ASSERT_WORK_MTX(local);
744
745 if (wk->type != IEEE80211_WORK_ASSOC_BEACON_WAIT)
746 return WORK_ACT_MISMATCH;
747
748 if (len < 24 + 12)
749 return WORK_ACT_NONE;
750
751 printk(KERN_DEBUG "%s: beacon received\n", sdata->name);
752 return WORK_ACT_DONE;
753 }
754
755 static void ieee80211_work_rx_queued_mgmt(struct ieee80211_local *local,
756 struct sk_buff *skb)
757 {
758 struct ieee80211_rx_status *rx_status;
759 struct ieee80211_mgmt *mgmt;
760 struct ieee80211_work *wk;
761 enum work_action rma = WORK_ACT_NONE;
762 u16 fc;
763
764 rx_status = (struct ieee80211_rx_status *) skb->cb;
765 mgmt = (struct ieee80211_mgmt *) skb->data;
766 fc = le16_to_cpu(mgmt->frame_control);
767
768 mutex_lock(&local->mtx);
769
770 list_for_each_entry(wk, &local->work_list, list) {
771 const u8 *bssid = NULL;
772
773 switch (wk->type) {
774 case IEEE80211_WORK_DIRECT_PROBE:
775 case IEEE80211_WORK_AUTH:
776 case IEEE80211_WORK_ASSOC:
777 case IEEE80211_WORK_ASSOC_BEACON_WAIT:
778 bssid = wk->filter_ta;
779 break;
780 default:
781 continue;
782 }
783
784 /*
785 * Before queuing, we already verified mgmt->sa,
786 * so this is needed just for matching.
787 */
788 if (compare_ether_addr(bssid, mgmt->bssid))
789 continue;
790
791 switch (fc & IEEE80211_FCTL_STYPE) {
792 case IEEE80211_STYPE_BEACON:
793 rma = ieee80211_rx_mgmt_beacon(wk, mgmt, skb->len);
794 break;
795 case IEEE80211_STYPE_PROBE_RESP:
796 rma = ieee80211_rx_mgmt_probe_resp(wk, mgmt, skb->len,
797 rx_status);
798 break;
799 case IEEE80211_STYPE_AUTH:
800 rma = ieee80211_rx_mgmt_auth(wk, mgmt, skb->len);
801 break;
802 case IEEE80211_STYPE_ASSOC_RESP:
803 rma = ieee80211_rx_mgmt_assoc_resp(wk, mgmt,
804 skb->len, false);
805 break;
806 case IEEE80211_STYPE_REASSOC_RESP:
807 rma = ieee80211_rx_mgmt_assoc_resp(wk, mgmt,
808 skb->len, true);
809 break;
810 default:
811 WARN_ON(1);
812 rma = WORK_ACT_NONE;
813 }
814
815 /*
816 * We've either received an unexpected frame, or we have
817 * multiple work items and need to match the frame to the
818 * right one.
819 */
820 if (rma == WORK_ACT_MISMATCH)
821 continue;
822
823 /*
824 * We've processed this frame for that work, so it can't
825 * belong to another work struct.
826 * NB: this is also required for correctness for 'rma'!
827 */
828 break;
829 }
830
831 switch (rma) {
832 case WORK_ACT_MISMATCH:
833 /* ignore this unmatched frame */
834 break;
835 case WORK_ACT_NONE:
836 break;
837 case WORK_ACT_DONE:
838 list_del_rcu(&wk->list);
839 break;
840 default:
841 WARN(1, "unexpected: %d", rma);
842 }
843
844 mutex_unlock(&local->mtx);
845
846 if (rma != WORK_ACT_DONE)
847 goto out;
848
849 switch (wk->done(wk, skb)) {
850 case WORK_DONE_DESTROY:
851 free_work(wk);
852 break;
853 case WORK_DONE_REQUEUE:
854 synchronize_rcu();
855 wk->started = false; /* restart */
856 mutex_lock(&local->mtx);
857 list_add_tail(&wk->list, &local->work_list);
858 mutex_unlock(&local->mtx);
859 }
860
861 out:
862 kfree_skb(skb);
863 }
864
865 static bool ieee80211_work_ct_coexists(enum nl80211_channel_type wk_ct,
866 enum nl80211_channel_type oper_ct)
867 {
868 switch (wk_ct) {
869 case NL80211_CHAN_NO_HT:
870 return true;
871 case NL80211_CHAN_HT20:
872 if (oper_ct != NL80211_CHAN_NO_HT)
873 return true;
874 return false;
875 case NL80211_CHAN_HT40MINUS:
876 case NL80211_CHAN_HT40PLUS:
877 return (wk_ct == oper_ct);
878 }
879 WARN_ON(1); /* shouldn't get here */
880 return false;
881 }
882
883 static enum nl80211_channel_type
884 ieee80211_calc_ct(enum nl80211_channel_type wk_ct,
885 enum nl80211_channel_type oper_ct)
886 {
887 switch (wk_ct) {
888 case NL80211_CHAN_NO_HT:
889 return oper_ct;
890 case NL80211_CHAN_HT20:
891 if (oper_ct != NL80211_CHAN_NO_HT)
892 return oper_ct;
893 return wk_ct;
894 case NL80211_CHAN_HT40MINUS:
895 case NL80211_CHAN_HT40PLUS:
896 return wk_ct;
897 }
898 WARN_ON(1); /* shouldn't get here */
899 return wk_ct;
900 }
901
902
903 static void ieee80211_work_timer(unsigned long data)
904 {
905 struct ieee80211_local *local = (void *) data;
906
907 if (local->quiescing)
908 return;
909
910 ieee80211_queue_work(&local->hw, &local->work_work);
911 }
912
913 static void ieee80211_work_work(struct work_struct *work)
914 {
915 struct ieee80211_local *local =
916 container_of(work, struct ieee80211_local, work_work);
917 struct sk_buff *skb;
918 struct ieee80211_work *wk, *tmp;
919 LIST_HEAD(free_work);
920 enum work_action rma;
921 bool remain_off_channel = false;
922
923 if (local->scanning)
924 return;
925
926 /*
927 * ieee80211_queue_work() should have picked up most cases,
928 * here we'll pick the rest.
929 */
930 if (WARN(local->suspended, "work scheduled while going to suspend\n"))
931 return;
932
933 /* first process frames to avoid timing out while a frame is pending */
934 while ((skb = skb_dequeue(&local->work_skb_queue)))
935 ieee80211_work_rx_queued_mgmt(local, skb);
936
937 mutex_lock(&local->mtx);
938
939 ieee80211_recalc_idle(local);
940
941 list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
942 bool started = wk->started;
943
944 /* mark work as started if it's on the current off-channel */
945 if (!started && local->tmp_channel &&
946 wk->chan == local->tmp_channel &&
947 wk->chan_type == local->tmp_channel_type) {
948 started = true;
949 wk->timeout = jiffies;
950 }
951
952 if (!started && !local->tmp_channel) {
953 bool on_oper_chan, on_oper_chan2;
954 enum nl80211_channel_type wk_ct;
955
956 on_oper_chan = ieee80211_cfg_on_oper_channel(local);
957
958 /* Work with existing channel type if possible. */
959 wk_ct = wk->chan_type;
960 if (wk->chan == local->hw.conf.channel)
961 wk_ct = ieee80211_calc_ct(wk->chan_type,
962 local->hw.conf.channel_type);
963
964 local->tmp_channel = wk->chan;
965 local->tmp_channel_type = wk_ct;
966 /*
967 * Leave the station vifs in awake mode if they
968 * happen to be on the same channel as
969 * the requested channel.
970 */
971 on_oper_chan2 = ieee80211_cfg_on_oper_channel(local);
972 if (on_oper_chan != on_oper_chan2) {
973 if (on_oper_chan2) {
974 /* going off oper channel, PS too */
975 ieee80211_offchannel_stop_vifs(local,
976 true);
977 ieee80211_hw_config(local, 0);
978 } else {
979 /* going on channel, but leave PS
980 * off-channel. */
981 ieee80211_hw_config(local, 0);
982 ieee80211_offchannel_return(local,
983 true,
984 false);
985 }
986 }
987
988 started = true;
989 wk->timeout = jiffies;
990 }
991
992 /* don't try to work with items that aren't started */
993 if (!started)
994 continue;
995
996 if (time_is_after_jiffies(wk->timeout)) {
997 /*
998 * This work item isn't supposed to be worked on
999 * right now, but take care to adjust the timer
1000 * properly.
1001 */
1002 run_again(local, wk->timeout);
1003 continue;
1004 }
1005
1006 switch (wk->type) {
1007 default:
1008 WARN_ON(1);
1009 /* nothing */
1010 rma = WORK_ACT_NONE;
1011 break;
1012 case IEEE80211_WORK_ABORT:
1013 rma = WORK_ACT_TIMEOUT;
1014 break;
1015 case IEEE80211_WORK_DIRECT_PROBE:
1016 rma = ieee80211_direct_probe(wk);
1017 break;
1018 case IEEE80211_WORK_AUTH:
1019 rma = ieee80211_authenticate(wk);
1020 break;
1021 case IEEE80211_WORK_ASSOC:
1022 rma = ieee80211_associate(wk);
1023 break;
1024 case IEEE80211_WORK_REMAIN_ON_CHANNEL:
1025 rma = ieee80211_remain_on_channel_timeout(wk);
1026 break;
1027 case IEEE80211_WORK_OFFCHANNEL_TX:
1028 rma = ieee80211_offchannel_tx(wk);
1029 break;
1030 case IEEE80211_WORK_ASSOC_BEACON_WAIT:
1031 rma = ieee80211_assoc_beacon_wait(wk);
1032 break;
1033 }
1034
1035 wk->started = started;
1036
1037 switch (rma) {
1038 case WORK_ACT_NONE:
1039 /* might have changed the timeout */
1040 run_again(local, wk->timeout);
1041 break;
1042 case WORK_ACT_TIMEOUT:
1043 list_del_rcu(&wk->list);
1044 synchronize_rcu();
1045 list_add(&wk->list, &free_work);
1046 break;
1047 default:
1048 WARN(1, "unexpected: %d", rma);
1049 }
1050 }
1051
1052 list_for_each_entry(wk, &local->work_list, list) {
1053 if (!wk->started)
1054 continue;
1055 if (wk->chan != local->tmp_channel)
1056 continue;
1057 if (!ieee80211_work_ct_coexists(wk->chan_type,
1058 local->tmp_channel_type))
1059 continue;
1060 remain_off_channel = true;
1061 }
1062
1063 if (!remain_off_channel && local->tmp_channel) {
1064 local->tmp_channel = NULL;
1065 /* If tmp_channel wasn't operating channel, then
1066 * we need to go back on-channel.
1067 * NOTE: If we can ever be here while scannning,
1068 * or if the hw_config() channel config logic changes,
1069 * then we may need to do a more thorough check to see if
1070 * we still need to do a hardware config. Currently,
1071 * we cannot be here while scanning, however.
1072 */
1073 if (!ieee80211_cfg_on_oper_channel(local))
1074 ieee80211_hw_config(local, 0);
1075
1076 /* At the least, we need to disable offchannel_ps,
1077 * so just go ahead and run the entire offchannel
1078 * return logic here. We *could* skip enabling
1079 * beaconing if we were already on-oper-channel
1080 * as a future optimization.
1081 */
1082 ieee80211_offchannel_return(local, true, true);
1083
1084 /* give connection some time to breathe */
1085 run_again(local, jiffies + HZ/2);
1086 }
1087
1088 if (list_empty(&local->work_list) && local->scan_req &&
1089 !local->scanning)
1090 ieee80211_queue_delayed_work(&local->hw,
1091 &local->scan_work,
1092 round_jiffies_relative(0));
1093
1094 ieee80211_recalc_idle(local);
1095
1096 mutex_unlock(&local->mtx);
1097
1098 list_for_each_entry_safe(wk, tmp, &free_work, list) {
1099 wk->done(wk, NULL);
1100 list_del(&wk->list);
1101 kfree(wk);
1102 }
1103 }
1104
1105 void ieee80211_add_work(struct ieee80211_work *wk)
1106 {
1107 struct ieee80211_local *local;
1108
1109 if (WARN_ON(!wk->chan))
1110 return;
1111
1112 if (WARN_ON(!wk->sdata))
1113 return;
1114
1115 if (WARN_ON(!wk->done))
1116 return;
1117
1118 if (WARN_ON(!ieee80211_sdata_running(wk->sdata)))
1119 return;
1120
1121 wk->started = false;
1122
1123 local = wk->sdata->local;
1124 mutex_lock(&local->mtx);
1125 list_add_tail(&wk->list, &local->work_list);
1126 mutex_unlock(&local->mtx);
1127
1128 ieee80211_queue_work(&local->hw, &local->work_work);
1129 }
1130
1131 void ieee80211_work_init(struct ieee80211_local *local)
1132 {
1133 INIT_LIST_HEAD(&local->work_list);
1134 setup_timer(&local->work_timer, ieee80211_work_timer,
1135 (unsigned long)local);
1136 INIT_WORK(&local->work_work, ieee80211_work_work);
1137 skb_queue_head_init(&local->work_skb_queue);
1138 }
1139
1140 void ieee80211_work_purge(struct ieee80211_sub_if_data *sdata)
1141 {
1142 struct ieee80211_local *local = sdata->local;
1143 struct ieee80211_work *wk;
1144 bool cleanup = false;
1145
1146 mutex_lock(&local->mtx);
1147 list_for_each_entry(wk, &local->work_list, list) {
1148 if (wk->sdata != sdata)
1149 continue;
1150 cleanup = true;
1151 wk->type = IEEE80211_WORK_ABORT;
1152 wk->started = true;
1153 wk->timeout = jiffies;
1154 }
1155 mutex_unlock(&local->mtx);
1156
1157 /* run cleanups etc. */
1158 if (cleanup)
1159 ieee80211_work_work(&local->work_work);
1160
1161 mutex_lock(&local->mtx);
1162 list_for_each_entry(wk, &local->work_list, list) {
1163 if (wk->sdata != sdata)
1164 continue;
1165 WARN_ON(1);
1166 break;
1167 }
1168 mutex_unlock(&local->mtx);
1169 }
1170
1171 ieee80211_rx_result ieee80211_work_rx_mgmt(struct ieee80211_sub_if_data *sdata,
1172 struct sk_buff *skb)
1173 {
1174 struct ieee80211_local *local = sdata->local;
1175 struct ieee80211_mgmt *mgmt;
1176 struct ieee80211_work *wk;
1177 u16 fc;
1178
1179 if (skb->len < 24)
1180 return RX_DROP_MONITOR;
1181
1182 mgmt = (struct ieee80211_mgmt *) skb->data;
1183 fc = le16_to_cpu(mgmt->frame_control);
1184
1185 list_for_each_entry_rcu(wk, &local->work_list, list) {
1186 if (sdata != wk->sdata)
1187 continue;
1188 if (compare_ether_addr(wk->filter_ta, mgmt->sa))
1189 continue;
1190 if (compare_ether_addr(wk->filter_ta, mgmt->bssid))
1191 continue;
1192
1193 switch (fc & IEEE80211_FCTL_STYPE) {
1194 case IEEE80211_STYPE_AUTH:
1195 case IEEE80211_STYPE_PROBE_RESP:
1196 case IEEE80211_STYPE_ASSOC_RESP:
1197 case IEEE80211_STYPE_REASSOC_RESP:
1198 case IEEE80211_STYPE_BEACON:
1199 skb_queue_tail(&local->work_skb_queue, skb);
1200 ieee80211_queue_work(&local->hw, &local->work_work);
1201 return RX_QUEUED;
1202 }
1203 }
1204
1205 return RX_CONTINUE;
1206 }
1207
1208 static enum work_done_result ieee80211_remain_done(struct ieee80211_work *wk,
1209 struct sk_buff *skb)
1210 {
1211 /*
1212 * We are done serving the remain-on-channel command.
1213 */
1214 cfg80211_remain_on_channel_expired(wk->sdata->dev, (unsigned long) wk,
1215 wk->chan, wk->chan_type,
1216 GFP_KERNEL);
1217
1218 return WORK_DONE_DESTROY;
1219 }
1220
1221 int ieee80211_wk_remain_on_channel(struct ieee80211_sub_if_data *sdata,
1222 struct ieee80211_channel *chan,
1223 enum nl80211_channel_type channel_type,
1224 unsigned int duration, u64 *cookie)
1225 {
1226 struct ieee80211_work *wk;
1227
1228 wk = kzalloc(sizeof(*wk), GFP_KERNEL);
1229 if (!wk)
1230 return -ENOMEM;
1231
1232 wk->type = IEEE80211_WORK_REMAIN_ON_CHANNEL;
1233 wk->chan = chan;
1234 wk->chan_type = channel_type;
1235 wk->sdata = sdata;
1236 wk->done = ieee80211_remain_done;
1237
1238 wk->remain.duration = duration;
1239
1240 *cookie = (unsigned long) wk;
1241
1242 ieee80211_add_work(wk);
1243
1244 return 0;
1245 }
1246
1247 int ieee80211_wk_cancel_remain_on_channel(struct ieee80211_sub_if_data *sdata,
1248 u64 cookie)
1249 {
1250 struct ieee80211_local *local = sdata->local;
1251 struct ieee80211_work *wk, *tmp;
1252 bool found = false;
1253
1254 mutex_lock(&local->mtx);
1255 list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
1256 if ((unsigned long) wk == cookie) {
1257 wk->timeout = jiffies;
1258 found = true;
1259 break;
1260 }
1261 }
1262 mutex_unlock(&local->mtx);
1263
1264 if (!found)
1265 return -ENOENT;
1266
1267 ieee80211_queue_work(&local->hw, &local->work_work);
1268
1269 return 0;
1270 }
Linux kernel - Deliverables
This page took 0.057457 seconds and 5 git commands to generate.