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