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 from %pM (Reason: %u)\n", 1392 sdata->dev->name, mgmt->sa, reason_code); 1393 1394 ieee80211_set_disassoc(sdata, false); 1395 return RX_MGMT_CFG80211_DISASSOC; 1396 } 1397 1398 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 wk->state = IEEE80211_MGD_STATE_IDLE; 1461 return RX_MGMT_CFG80211_ASSOC; 1462 } 1463 1464 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14))) 1465 printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not " 1466 "set\n", sdata->dev->name, aid); 1467 aid &= ~(BIT(15) | BIT(14)); 1468 1469 if (!elems.supp_rates) { 1470 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n", 1471 sdata->dev->name); 1472 return RX_MGMT_NONE; 1473 } 1474 1475 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name); 1476 ifmgd->aid = aid; 1477 1478 rcu_read_lock(); 1479 1480 /* Add STA entry for the AP */ 1481 sta = sta_info_get(local, wk->bss->cbss.bssid); 1482 if (!sta) { 1483 newsta = true; 1484 1485 rcu_read_unlock(); 1486 1487 sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL); 1488 if (!sta) { 1489 printk(KERN_DEBUG "%s: failed to alloc STA entry for" 1490 " the AP\n", sdata->dev->name); 1491 return RX_MGMT_NONE; 1492 } 1493 1494 set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC | 1495 WLAN_STA_ASSOC_AP); 1496 if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT)) 1497 set_sta_flags(sta, WLAN_STA_AUTHORIZED); 1498 1499 rcu_read_lock(); 1500 } 1501 1502 rates = 0; 1503 basic_rates = 0; 1504 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1505 1506 for (i = 0; i < elems.supp_rates_len; i++) { 1507 int rate = (elems.supp_rates[i] & 0x7f) * 5; 1508 bool is_basic = !!(elems.supp_rates[i] & 0x80); 1509 1510 if (rate > 110) 1511 have_higher_than_11mbit = true; 1512 1513 for (j = 0; j < sband->n_bitrates; j++) { 1514 if (sband->bitrates[j].bitrate == rate) { 1515 rates |= BIT(j); 1516 if (is_basic) 1517 basic_rates |= BIT(j); 1518 break; 1519 } 1520 } 1521 } 1522 1523 for (i = 0; i < elems.ext_supp_rates_len; i++) { 1524 int rate = (elems.ext_supp_rates[i] & 0x7f) * 5; 1525 bool is_basic = !!(elems.ext_supp_rates[i] & 0x80); 1526 1527 if (rate > 110) 1528 have_higher_than_11mbit = true; 1529 1530 for (j = 0; j < sband->n_bitrates; j++) { 1531 if (sband->bitrates[j].bitrate == rate) { 1532 rates |= BIT(j); 1533 if (is_basic) 1534 basic_rates |= BIT(j); 1535 break; 1536 } 1537 } 1538 } 1539 1540 sta->sta.supp_rates[local->hw.conf.channel->band] = rates; 1541 sdata->vif.bss_conf.basic_rates = basic_rates; 1542 1543 /* cf. IEEE 802.11 9.2.12 */ 1544 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ && 1545 have_higher_than_11mbit) 1546 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE; 1547 else 1548 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE; 1549 1550 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) 1551 ieee80211_ht_cap_ie_to_sta_ht_cap(sband, 1552 elems.ht_cap_elem, &sta->sta.ht_cap); 1553 1554 ap_ht_cap_flags = sta->sta.ht_cap.cap; 1555 1556 rate_control_rate_init(sta); 1557 1558 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED) 1559 set_sta_flags(sta, WLAN_STA_MFP); 1560 1561 if (elems.wmm_param) 1562 set_sta_flags(sta, WLAN_STA_WME); 1563 1564 if (newsta) { 1565 int err = sta_info_insert(sta); 1566 if (err) { 1567 printk(KERN_DEBUG "%s: failed to insert STA entry for" 1568 " the AP (error %d)\n", sdata->dev->name, err); 1569 rcu_read_unlock(); 1570 return RX_MGMT_NONE; 1571 } 1572 } 1573 1574 rcu_read_unlock(); 1575 1576 if (elems.wmm_param) 1577 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param, 1578 elems.wmm_param_len); 1579 else 1580 ieee80211_set_wmm_default(sdata); 1581 1582 if (elems.ht_info_elem && elems.wmm_param && 1583 (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) && 1584 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) 1585 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem, 1586 wk->bss->cbss.bssid, 1587 ap_ht_cap_flags); 1588 1589 /* delete work item -- must be before set_associated for PS */ 1590 list_del(&wk->list); 1591 1592 /* set AID and assoc capability, 1593 * ieee80211_set_associated() will tell the driver */ 1594 bss_conf->aid = aid; 1595 bss_conf->assoc_capability = capab_info; 1596 /* this will take ownership of wk */ 1597 ieee80211_set_associated(sdata, wk, changed); 1598 1599 /* 1600 * Start timer to probe the connection to the AP now. 1601 * Also start the timer that will detect beacon loss. 1602 */ 1603 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt); 1604 mod_beacon_timer(sdata); 1605 1606 return RX_MGMT_CFG80211_ASSOC; 1607 } 1608 1609 1610 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata, 1611 struct ieee80211_mgmt *mgmt, 1612 size_t len, 1613 struct ieee80211_rx_status *rx_status, 1614 struct ieee802_11_elems *elems, 1615 bool beacon) 1616 { 1617 struct ieee80211_local *local = sdata->local; 1618 int freq; 1619 struct ieee80211_bss *bss; 1620 struct ieee80211_channel *channel; 1621 1622 if (elems->ds_params && elems->ds_params_len == 1) 1623 freq = ieee80211_channel_to_frequency(elems->ds_params[0]); 1624 else 1625 freq = rx_status->freq; 1626 1627 channel = ieee80211_get_channel(local->hw.wiphy, freq); 1628 1629 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 1630 return; 1631 1632 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems, 1633 channel, beacon); 1634 if (bss) 1635 ieee80211_rx_bss_put(local, bss); 1636 1637 if (!sdata->u.mgd.associated) 1638 return; 1639 1640 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) && 1641 (memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid, 1642 ETH_ALEN) == 0)) { 1643 struct ieee80211_channel_sw_ie *sw_elem = 1644 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem; 1645 ieee80211_sta_process_chanswitch(sdata, sw_elem, bss); 1646 } 1647 } 1648 1649 1650 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata, 1651 struct ieee80211_mgd_work *wk, 1652 struct ieee80211_mgmt *mgmt, size_t len, 1653 struct ieee80211_rx_status *rx_status) 1654 { 1655 struct ieee80211_if_managed *ifmgd; 1656 size_t baselen; 1657 struct ieee802_11_elems elems; 1658 1659 ifmgd = &sdata->u.mgd; 1660 1661 ASSERT_MGD_MTX(ifmgd); 1662 1663 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN)) 1664 return; /* ignore ProbeResp to foreign address */ 1665 1666 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 1667 if (baselen > len) 1668 return; 1669 1670 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 1671 &elems); 1672 1673 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false); 1674 1675 /* direct probe may be part of the association flow */ 1676 if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) { 1677 printk(KERN_DEBUG "%s: direct probe responded\n", 1678 sdata->dev->name); 1679 wk->tries = 0; 1680 wk->state = IEEE80211_MGD_STATE_AUTH; 1681 WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE); 1682 } 1683 1684 if (ifmgd->associated && 1685 memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 && 1686 ifmgd->flags & (IEEE80211_STA_BEACON_POLL | 1687 IEEE80211_STA_CONNECTION_POLL)) { 1688 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL | 1689 IEEE80211_STA_BEACON_POLL); 1690 mutex_lock(&sdata->local->iflist_mtx); 1691 ieee80211_recalc_ps(sdata->local, -1); 1692 mutex_unlock(&sdata->local->iflist_mtx); 1693 /* 1694 * We've received a probe response, but are not sure whether 1695 * we have or will be receiving any beacons or data, so let's 1696 * schedule the timers again, just in case. 1697 */ 1698 mod_beacon_timer(sdata); 1699 mod_timer(&ifmgd->conn_mon_timer, 1700 round_jiffies_up(jiffies + 1701 IEEE80211_CONNECTION_IDLE_TIME)); 1702 } 1703 } 1704 1705 /* 1706 * This is the canonical list of information elements we care about, 1707 * the filter code also gives us all changes to the Microsoft OUI 1708 * (00:50:F2) vendor IE which is used for WMM which we need to track. 1709 * 1710 * We implement beacon filtering in software since that means we can 1711 * avoid processing the frame here and in cfg80211, and userspace 1712 * will not be able to tell whether the hardware supports it or not. 1713 * 1714 * XXX: This list needs to be dynamic -- userspace needs to be able to 1715 * add items it requires. It also needs to be able to tell us to 1716 * look out for other vendor IEs. 1717 */ 1718 static const u64 care_about_ies = 1719 (1ULL << WLAN_EID_COUNTRY) | 1720 (1ULL << WLAN_EID_ERP_INFO) | 1721 (1ULL << WLAN_EID_CHANNEL_SWITCH) | 1722 (1ULL << WLAN_EID_PWR_CONSTRAINT) | 1723 (1ULL << WLAN_EID_HT_CAPABILITY) | 1724 (1ULL << WLAN_EID_HT_INFORMATION); 1725 1726 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata, 1727 struct ieee80211_mgmt *mgmt, 1728 size_t len, 1729 struct ieee80211_rx_status *rx_status) 1730 { 1731 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1732 size_t baselen; 1733 struct ieee802_11_elems elems; 1734 struct ieee80211_local *local = sdata->local; 1735 u32 changed = 0; 1736 bool erp_valid, directed_tim = false; 1737 u8 erp_value = 0; 1738 u32 ncrc; 1739 u8 *bssid; 1740 1741 ASSERT_MGD_MTX(ifmgd); 1742 1743 /* Process beacon from the current BSS */ 1744 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt; 1745 if (baselen > len) 1746 return; 1747 1748 if (rx_status->freq != local->hw.conf.channel->center_freq) 1749 return; 1750 1751 /* 1752 * We might have received a number of frames, among them a 1753 * disassoc frame and a beacon... 1754 */ 1755 if (!ifmgd->associated) 1756 return; 1757 1758 bssid = ifmgd->associated->cbss.bssid; 1759 1760 /* 1761 * And in theory even frames from a different AP we were just 1762 * associated to a split-second ago! 1763 */ 1764 if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0) 1765 return; 1766 1767 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) { 1768 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 1769 if (net_ratelimit()) { 1770 printk(KERN_DEBUG "%s: cancelling probereq poll due " 1771 "to a received beacon\n", sdata->dev->name); 1772 } 1773 #endif 1774 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL; 1775 mutex_lock(&local->iflist_mtx); 1776 ieee80211_recalc_ps(local, -1); 1777 mutex_unlock(&local->iflist_mtx); 1778 } 1779 1780 /* 1781 * Push the beacon loss detection into the future since 1782 * we are processing a beacon from the AP just now. 1783 */ 1784 mod_beacon_timer(sdata); 1785 1786 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4); 1787 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable, 1788 len - baselen, &elems, 1789 care_about_ies, ncrc); 1790 1791 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) 1792 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len, 1793 ifmgd->aid); 1794 1795 if (ncrc != ifmgd->beacon_crc) { 1796 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, 1797 true); 1798 1799 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param, 1800 elems.wmm_param_len); 1801 } 1802 1803 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) { 1804 if (directed_tim) { 1805 if (local->hw.conf.dynamic_ps_timeout > 0) { 1806 local->hw.conf.flags &= ~IEEE80211_CONF_PS; 1807 ieee80211_hw_config(local, 1808 IEEE80211_CONF_CHANGE_PS); 1809 ieee80211_send_nullfunc(local, sdata, 0); 1810 } else { 1811 local->pspolling = true; 1812 1813 /* 1814 * Here is assumed that the driver will be 1815 * able to send ps-poll frame and receive a 1816 * response even though power save mode is 1817 * enabled, but some drivers might require 1818 * to disable power save here. This needs 1819 * to be investigated. 1820 */ 1821 ieee80211_send_pspoll(local, sdata); 1822 } 1823 } 1824 } 1825 1826 if (ncrc == ifmgd->beacon_crc) 1827 return; 1828 ifmgd->beacon_crc = ncrc; 1829 1830 if (elems.erp_info && elems.erp_info_len >= 1) { 1831 erp_valid = true; 1832 erp_value = elems.erp_info[0]; 1833 } else { 1834 erp_valid = false; 1835 } 1836 changed |= ieee80211_handle_bss_capability(sdata, 1837 le16_to_cpu(mgmt->u.beacon.capab_info), 1838 erp_valid, erp_value); 1839 1840 1841 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param && 1842 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) { 1843 struct sta_info *sta; 1844 struct ieee80211_supported_band *sband; 1845 u16 ap_ht_cap_flags; 1846 1847 rcu_read_lock(); 1848 1849 sta = sta_info_get(local, bssid); 1850 if (WARN_ON(!sta)) { 1851 rcu_read_unlock(); 1852 return; 1853 } 1854 1855 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 1856 1857 ieee80211_ht_cap_ie_to_sta_ht_cap(sband, 1858 elems.ht_cap_elem, &sta->sta.ht_cap); 1859 1860 ap_ht_cap_flags = sta->sta.ht_cap.cap; 1861 1862 rcu_read_unlock(); 1863 1864 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem, 1865 bssid, ap_ht_cap_flags); 1866 } 1867 1868 /* Note: country IE parsing is done for us by cfg80211 */ 1869 if (elems.country_elem) { 1870 /* TODO: IBSS also needs this */ 1871 if (elems.pwr_constr_elem) 1872 ieee80211_handle_pwr_constr(sdata, 1873 le16_to_cpu(mgmt->u.probe_resp.capab_info), 1874 elems.pwr_constr_elem, 1875 elems.pwr_constr_elem_len); 1876 } 1877 1878 ieee80211_bss_info_change_notify(sdata, changed); 1879 } 1880 1881 ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata, 1882 struct sk_buff *skb) 1883 { 1884 struct ieee80211_local *local = sdata->local; 1885 struct ieee80211_mgmt *mgmt; 1886 u16 fc; 1887 1888 if (skb->len < 24) 1889 return RX_DROP_MONITOR; 1890 1891 mgmt = (struct ieee80211_mgmt *) skb->data; 1892 fc = le16_to_cpu(mgmt->frame_control); 1893 1894 switch (fc & IEEE80211_FCTL_STYPE) { 1895 case IEEE80211_STYPE_PROBE_REQ: 1896 case IEEE80211_STYPE_PROBE_RESP: 1897 case IEEE80211_STYPE_BEACON: 1898 case IEEE80211_STYPE_AUTH: 1899 case IEEE80211_STYPE_ASSOC_RESP: 1900 case IEEE80211_STYPE_REASSOC_RESP: 1901 case IEEE80211_STYPE_DEAUTH: 1902 case IEEE80211_STYPE_DISASSOC: 1903 case IEEE80211_STYPE_ACTION: 1904 skb_queue_tail(&sdata->u.mgd.skb_queue, skb); 1905 ieee80211_queue_work(&local->hw, &sdata->u.mgd.work); 1906 return RX_QUEUED; 1907 } 1908 1909 return RX_DROP_MONITOR; 1910 } 1911 1912 static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 1913 struct sk_buff *skb) 1914 { 1915 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 1916 struct ieee80211_rx_status *rx_status; 1917 struct ieee80211_mgmt *mgmt; 1918 struct ieee80211_mgd_work *wk; 1919 enum rx_mgmt_action rma = RX_MGMT_NONE; 1920 u16 fc; 1921 1922 rx_status = (struct ieee80211_rx_status *) skb->cb; 1923 mgmt = (struct ieee80211_mgmt *) skb->data; 1924 fc = le16_to_cpu(mgmt->frame_control); 1925 1926 mutex_lock(&ifmgd->mtx); 1927 1928 if (ifmgd->associated && 1929 memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid, 1930 ETH_ALEN) == 0) { 1931 switch (fc & IEEE80211_FCTL_STYPE) { 1932 case IEEE80211_STYPE_BEACON: 1933 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, 1934 rx_status); 1935 break; 1936 case IEEE80211_STYPE_PROBE_RESP: 1937 ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt, 1938 skb->len, rx_status); 1939 break; 1940 case IEEE80211_STYPE_DEAUTH: 1941 rma = ieee80211_rx_mgmt_deauth(sdata, NULL, 1942 mgmt, skb->len); 1943 break; 1944 case IEEE80211_STYPE_DISASSOC: 1945 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len); 1946 break; 1947 case IEEE80211_STYPE_ACTION: 1948 /* XXX: differentiate, can only happen for CSA now! */ 1949 ieee80211_sta_process_chanswitch(sdata, 1950 &mgmt->u.action.u.chan_switch.sw_elem, 1951 ifmgd->associated); 1952 break; 1953 } 1954 mutex_unlock(&ifmgd->mtx); 1955 1956 switch (rma) { 1957 case RX_MGMT_NONE: 1958 /* no action */ 1959 break; 1960 case RX_MGMT_CFG80211_DEAUTH: 1961 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, 1962 NULL); 1963 break; 1964 case RX_MGMT_CFG80211_DISASSOC: 1965 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len, 1966 NULL); 1967 break; 1968 default: 1969 WARN(1, "unexpected: %d", rma); 1970 } 1971 goto out; 1972 } 1973 1974 list_for_each_entry(wk, &ifmgd->work_list, list) { 1975 if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0) 1976 continue; 1977 1978 switch (fc & IEEE80211_FCTL_STYPE) { 1979 case IEEE80211_STYPE_PROBE_RESP: 1980 ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len, 1981 rx_status); 1982 break; 1983 case IEEE80211_STYPE_AUTH: 1984 rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len); 1985 break; 1986 case IEEE80211_STYPE_ASSOC_RESP: 1987 rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt, 1988 skb->len, false); 1989 break; 1990 case IEEE80211_STYPE_REASSOC_RESP: 1991 rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt, 1992 skb->len, true); 1993 break; 1994 case IEEE80211_STYPE_DEAUTH: 1995 rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt, 1996 skb->len); 1997 break; 1998 } 1999 /* 2000 * We've processed this frame for that work, so it can't 2001 * belong to another work struct. 2002 * NB: this is also required for correctness because the 2003 * called functions can free 'wk', and for 'rma'! 2004 */ 2005 break; 2006 } 2007 2008 mutex_unlock(&ifmgd->mtx); 2009 2010 switch (rma) { 2011 case RX_MGMT_NONE: 2012 /* no action */ 2013 break; 2014 case RX_MGMT_CFG80211_AUTH: 2015 cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len); 2016 break; 2017 case RX_MGMT_CFG80211_ASSOC: 2018 cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len); 2019 break; 2020 case RX_MGMT_CFG80211_DEAUTH: 2021 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len, NULL); 2022 break; 2023 default: 2024 WARN(1, "unexpected: %d", rma); 2025 } 2026 2027 out: 2028 kfree_skb(skb); 2029 } 2030 2031 static void ieee80211_sta_timer(unsigned long data) 2032 { 2033 struct ieee80211_sub_if_data *sdata = 2034 (struct ieee80211_sub_if_data *) data; 2035 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2036 struct ieee80211_local *local = sdata->local; 2037 2038 if (local->quiescing) { 2039 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running); 2040 return; 2041 } 2042 2043 ieee80211_queue_work(&local->hw, &ifmgd->work); 2044 } 2045 2046 static void ieee80211_sta_work(struct work_struct *work) 2047 { 2048 struct ieee80211_sub_if_data *sdata = 2049 container_of(work, struct ieee80211_sub_if_data, u.mgd.work); 2050 struct ieee80211_local *local = sdata->local; 2051 struct ieee80211_if_managed *ifmgd; 2052 struct sk_buff *skb; 2053 struct ieee80211_mgd_work *wk, *tmp; 2054 LIST_HEAD(free_work); 2055 enum rx_mgmt_action rma; 2056 bool anybusy = false; 2057 2058 if (!netif_running(sdata->dev)) 2059 return; 2060 2061 if (local->scanning) 2062 return; 2063 2064 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION)) 2065 return; 2066 2067 /* 2068 * ieee80211_queue_work() should have picked up most cases, 2069 * here we'll pick the the rest. 2070 */ 2071 if (WARN(local->suspended, "STA MLME work scheduled while " 2072 "going to suspend\n")) 2073 return; 2074 2075 ifmgd = &sdata->u.mgd; 2076 2077 /* first process frames to avoid timing out while a frame is pending */ 2078 while ((skb = skb_dequeue(&ifmgd->skb_queue))) 2079 ieee80211_sta_rx_queued_mgmt(sdata, skb); 2080 2081 /* then process the rest of the work */ 2082 mutex_lock(&ifmgd->mtx); 2083 2084 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL | 2085 IEEE80211_STA_CONNECTION_POLL) && 2086 ifmgd->associated) { 2087 u8 bssid[ETH_ALEN]; 2088 2089 memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN); 2090 if (time_is_after_jiffies(ifmgd->probe_timeout)) 2091 run_again(ifmgd, ifmgd->probe_timeout); 2092 2093 else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) { 2094 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 2095 printk(KERN_DEBUG "No probe response from AP %pM" 2096 " after %dms, try %d\n", bssid, 2097 (1000 * IEEE80211_PROBE_WAIT)/HZ, 2098 ifmgd->probe_send_count); 2099 #endif 2100 ieee80211_mgd_probe_ap_send(sdata); 2101 } else { 2102 /* 2103 * We actually lost the connection ... or did we? 2104 * Let's make sure! 2105 */ 2106 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL | 2107 IEEE80211_STA_BEACON_POLL); 2108 printk(KERN_DEBUG "No probe response from AP %pM" 2109 " after %dms, disconnecting.\n", 2110 bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ); 2111 ieee80211_set_disassoc(sdata, true); 2112 mutex_unlock(&ifmgd->mtx); 2113 /* 2114 * must be outside lock due to cfg80211, 2115 * but that's not a problem. 2116 */ 2117 ieee80211_send_deauth_disassoc(sdata, bssid, 2118 IEEE80211_STYPE_DEAUTH, 2119 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY, 2120 NULL); 2121 mutex_lock(&ifmgd->mtx); 2122 } 2123 } 2124 2125 2126 ieee80211_recalc_idle(local); 2127 2128 list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) { 2129 if (time_is_after_jiffies(wk->timeout)) { 2130 /* 2131 * This work item isn't supposed to be worked on 2132 * right now, but take care to adjust the timer 2133 * properly. 2134 */ 2135 run_again(ifmgd, wk->timeout); 2136 continue; 2137 } 2138 2139 switch (wk->state) { 2140 default: 2141 WARN_ON(1); 2142 /* fall through */ 2143 case IEEE80211_MGD_STATE_IDLE: 2144 /* nothing */ 2145 rma = RX_MGMT_NONE; 2146 break; 2147 case IEEE80211_MGD_STATE_PROBE: 2148 rma = ieee80211_direct_probe(sdata, wk); 2149 break; 2150 case IEEE80211_MGD_STATE_AUTH: 2151 rma = ieee80211_authenticate(sdata, wk); 2152 break; 2153 case IEEE80211_MGD_STATE_ASSOC: 2154 rma = ieee80211_associate(sdata, wk); 2155 break; 2156 } 2157 2158 switch (rma) { 2159 case RX_MGMT_NONE: 2160 /* no action required */ 2161 break; 2162 case RX_MGMT_CFG80211_AUTH_TO: 2163 case RX_MGMT_CFG80211_ASSOC_TO: 2164 list_del(&wk->list); 2165 list_add(&wk->list, &free_work); 2166 wk->tries = rma; /* small abuse but only local */ 2167 break; 2168 default: 2169 WARN(1, "unexpected: %d", rma); 2170 } 2171 } 2172 2173 list_for_each_entry(wk, &ifmgd->work_list, list) { 2174 if (wk->state != IEEE80211_MGD_STATE_IDLE) { 2175 anybusy = true; 2176 break; 2177 } 2178 } 2179 if (!anybusy && 2180 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request)) 2181 ieee80211_queue_delayed_work(&local->hw, 2182 &local->scan_work, 2183 round_jiffies_relative(0)); 2184 2185 mutex_unlock(&ifmgd->mtx); 2186 2187 list_for_each_entry_safe(wk, tmp, &free_work, list) { 2188 switch (wk->tries) { 2189 case RX_MGMT_CFG80211_AUTH_TO: 2190 cfg80211_send_auth_timeout(sdata->dev, 2191 wk->bss->cbss.bssid); 2192 break; 2193 case RX_MGMT_CFG80211_ASSOC_TO: 2194 cfg80211_send_assoc_timeout(sdata->dev, 2195 wk->bss->cbss.bssid); 2196 break; 2197 default: 2198 WARN(1, "unexpected: %d", wk->tries); 2199 } 2200 2201 list_del(&wk->list); 2202 kfree(wk); 2203 } 2204 2205 ieee80211_recalc_idle(local); 2206 } 2207 2208 static void ieee80211_sta_bcn_mon_timer(unsigned long data) 2209 { 2210 struct ieee80211_sub_if_data *sdata = 2211 (struct ieee80211_sub_if_data *) data; 2212 struct ieee80211_local *local = sdata->local; 2213 2214 if (local->quiescing) 2215 return; 2216 2217 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work); 2218 } 2219 2220 static void ieee80211_sta_conn_mon_timer(unsigned long data) 2221 { 2222 struct ieee80211_sub_if_data *sdata = 2223 (struct ieee80211_sub_if_data *) data; 2224 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2225 struct ieee80211_local *local = sdata->local; 2226 2227 if (local->quiescing) 2228 return; 2229 2230 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work); 2231 } 2232 2233 static void ieee80211_sta_monitor_work(struct work_struct *work) 2234 { 2235 struct ieee80211_sub_if_data *sdata = 2236 container_of(work, struct ieee80211_sub_if_data, 2237 u.mgd.monitor_work); 2238 2239 ieee80211_mgd_probe_ap(sdata, false); 2240 } 2241 2242 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata) 2243 { 2244 if (sdata->vif.type == NL80211_IFTYPE_STATION) { 2245 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL | 2246 IEEE80211_STA_CONNECTION_POLL); 2247 2248 /* let's probe the connection once */ 2249 ieee80211_queue_work(&sdata->local->hw, 2250 &sdata->u.mgd.monitor_work); 2251 /* and do all the other regular work too */ 2252 ieee80211_queue_work(&sdata->local->hw, 2253 &sdata->u.mgd.work); 2254 } 2255 } 2256 2257 #ifdef CONFIG_PM 2258 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata) 2259 { 2260 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2261 2262 /* 2263 * we need to use atomic bitops for the running bits 2264 * only because both timers might fire at the same 2265 * time -- the code here is properly synchronised. 2266 */ 2267 2268 cancel_work_sync(&ifmgd->work); 2269 cancel_work_sync(&ifmgd->beacon_loss_work); 2270 if (del_timer_sync(&ifmgd->timer)) 2271 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running); 2272 2273 cancel_work_sync(&ifmgd->chswitch_work); 2274 if (del_timer_sync(&ifmgd->chswitch_timer)) 2275 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running); 2276 2277 cancel_work_sync(&ifmgd->monitor_work); 2278 /* these will just be re-established on connection */ 2279 del_timer_sync(&ifmgd->conn_mon_timer); 2280 del_timer_sync(&ifmgd->bcn_mon_timer); 2281 } 2282 2283 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata) 2284 { 2285 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2286 2287 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running)) 2288 add_timer(&ifmgd->timer); 2289 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running)) 2290 add_timer(&ifmgd->chswitch_timer); 2291 } 2292 #endif 2293 2294 /* interface setup */ 2295 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata) 2296 { 2297 struct ieee80211_if_managed *ifmgd; 2298 2299 ifmgd = &sdata->u.mgd; 2300 INIT_WORK(&ifmgd->work, ieee80211_sta_work); 2301 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work); 2302 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work); 2303 INIT_WORK(&ifmgd->beacon_loss_work, ieee80211_beacon_loss_work); 2304 setup_timer(&ifmgd->timer, ieee80211_sta_timer, 2305 (unsigned long) sdata); 2306 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer, 2307 (unsigned long) sdata); 2308 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer, 2309 (unsigned long) sdata); 2310 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer, 2311 (unsigned long) sdata); 2312 skb_queue_head_init(&ifmgd->skb_queue); 2313 2314 INIT_LIST_HEAD(&ifmgd->work_list); 2315 2316 ifmgd->capab = WLAN_CAPABILITY_ESS; 2317 ifmgd->flags = 0; 2318 if (sdata->local->hw.queues >= 4) 2319 ifmgd->flags |= IEEE80211_STA_WMM_ENABLED; 2320 2321 mutex_init(&ifmgd->mtx); 2322 } 2323 2324 /* scan finished notification */ 2325 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local) 2326 { 2327 struct ieee80211_sub_if_data *sdata = local->scan_sdata; 2328 2329 /* Restart STA timers */ 2330 rcu_read_lock(); 2331 list_for_each_entry_rcu(sdata, &local->interfaces, list) 2332 ieee80211_restart_sta_timer(sdata); 2333 rcu_read_unlock(); 2334 } 2335 2336 int ieee80211_max_network_latency(struct notifier_block *nb, 2337 unsigned long data, void *dummy) 2338 { 2339 s32 latency_usec = (s32) data; 2340 struct ieee80211_local *local = 2341 container_of(nb, struct ieee80211_local, 2342 network_latency_notifier); 2343 2344 mutex_lock(&local->iflist_mtx); 2345 ieee80211_recalc_ps(local, latency_usec); 2346 mutex_unlock(&local->iflist_mtx); 2347 2348 return 0; 2349 } 2350 2351 /* config hooks */ 2352 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata, 2353 struct cfg80211_auth_request *req) 2354 { 2355 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2356 const u8 *ssid; 2357 struct ieee80211_mgd_work *wk; 2358 u16 auth_alg; 2359 2360 switch (req->auth_type) { 2361 case NL80211_AUTHTYPE_OPEN_SYSTEM: 2362 auth_alg = WLAN_AUTH_OPEN; 2363 break; 2364 case NL80211_AUTHTYPE_SHARED_KEY: 2365 auth_alg = WLAN_AUTH_SHARED_KEY; 2366 break; 2367 case NL80211_AUTHTYPE_FT: 2368 auth_alg = WLAN_AUTH_FT; 2369 break; 2370 case NL80211_AUTHTYPE_NETWORK_EAP: 2371 auth_alg = WLAN_AUTH_LEAP; 2372 break; 2373 default: 2374 return -EOPNOTSUPP; 2375 } 2376 2377 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL); 2378 if (!wk) 2379 return -ENOMEM; 2380 2381 wk->bss = (void *)req->bss; 2382 2383 if (req->ie && req->ie_len) { 2384 memcpy(wk->ie, req->ie, req->ie_len); 2385 wk->ie_len = req->ie_len; 2386 } 2387 2388 if (req->key && req->key_len) { 2389 wk->key_len = req->key_len; 2390 wk->key_idx = req->key_idx; 2391 memcpy(wk->key, req->key, req->key_len); 2392 } 2393 2394 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID); 2395 memcpy(wk->ssid, ssid + 2, ssid[1]); 2396 wk->ssid_len = ssid[1]; 2397 2398 wk->state = IEEE80211_MGD_STATE_PROBE; 2399 wk->auth_alg = auth_alg; 2400 wk->timeout = jiffies; /* run right away */ 2401 2402 /* 2403 * XXX: if still associated need to tell AP that we're going 2404 * to sleep and then change channel etc. 2405 */ 2406 sdata->local->oper_channel = req->bss->channel; 2407 ieee80211_hw_config(sdata->local, 0); 2408 2409 mutex_lock(&ifmgd->mtx); 2410 list_add(&wk->list, &sdata->u.mgd.work_list); 2411 mutex_unlock(&ifmgd->mtx); 2412 2413 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work); 2414 return 0; 2415 } 2416 2417 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata, 2418 struct cfg80211_assoc_request *req) 2419 { 2420 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2421 struct ieee80211_mgd_work *wk, *found = NULL; 2422 int i, err; 2423 2424 mutex_lock(&ifmgd->mtx); 2425 2426 list_for_each_entry(wk, &ifmgd->work_list, list) { 2427 if (&wk->bss->cbss == req->bss && 2428 wk->state == IEEE80211_MGD_STATE_IDLE) { 2429 found = wk; 2430 break; 2431 } 2432 } 2433 2434 if (!found) { 2435 err = -ENOLINK; 2436 goto out; 2437 } 2438 2439 list_del(&found->list); 2440 2441 wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL); 2442 if (!wk) { 2443 list_add(&found->list, &ifmgd->work_list); 2444 err = -ENOMEM; 2445 goto out; 2446 } 2447 2448 list_add(&wk->list, &ifmgd->work_list); 2449 2450 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N; 2451 2452 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++) 2453 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 || 2454 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP || 2455 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104) 2456 ifmgd->flags |= IEEE80211_STA_DISABLE_11N; 2457 2458 sdata->local->oper_channel = req->bss->channel; 2459 ieee80211_hw_config(sdata->local, 0); 2460 2461 if (req->ie && req->ie_len) { 2462 memcpy(wk->ie, req->ie, req->ie_len); 2463 wk->ie_len = req->ie_len; 2464 } else 2465 wk->ie_len = 0; 2466 2467 if (req->prev_bssid) 2468 memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN); 2469 2470 wk->state = IEEE80211_MGD_STATE_ASSOC; 2471 wk->tries = 0; 2472 wk->timeout = jiffies; /* run right away */ 2473 2474 if (req->use_mfp) { 2475 ifmgd->mfp = IEEE80211_MFP_REQUIRED; 2476 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED; 2477 } else { 2478 ifmgd->mfp = IEEE80211_MFP_DISABLED; 2479 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED; 2480 } 2481 2482 if (req->crypto.control_port) 2483 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT; 2484 else 2485 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT; 2486 2487 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work); 2488 2489 err = 0; 2490 2491 out: 2492 mutex_unlock(&ifmgd->mtx); 2493 return err; 2494 } 2495 2496 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata, 2497 struct cfg80211_deauth_request *req, 2498 void *cookie) 2499 { 2500 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2501 struct ieee80211_mgd_work *wk; 2502 const u8 *bssid = NULL; 2503 2504 mutex_lock(&ifmgd->mtx); 2505 2506 if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) { 2507 bssid = req->bss->bssid; 2508 ieee80211_set_disassoc(sdata, true); 2509 } else list_for_each_entry(wk, &ifmgd->work_list, list) { 2510 if (&wk->bss->cbss == req->bss) { 2511 bssid = req->bss->bssid; 2512 list_del(&wk->list); 2513 kfree(wk); 2514 break; 2515 } 2516 } 2517 2518 /* 2519 * cfg80211 should catch this ... but it's racy since 2520 * we can receive a deauth frame, process it, hand it 2521 * to cfg80211 while that's in a locked section already 2522 * trying to tell us that the user wants to disconnect. 2523 */ 2524 if (!bssid) { 2525 mutex_unlock(&ifmgd->mtx); 2526 return -ENOLINK; 2527 } 2528 2529 mutex_unlock(&ifmgd->mtx); 2530 2531 printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n", 2532 sdata->dev->name, bssid, req->reason_code); 2533 2534 ieee80211_send_deauth_disassoc(sdata, bssid, 2535 IEEE80211_STYPE_DEAUTH, req->reason_code, 2536 cookie); 2537 2538 return 0; 2539 } 2540 2541 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata, 2542 struct cfg80211_disassoc_request *req, 2543 void *cookie) 2544 { 2545 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 2546 2547 mutex_lock(&ifmgd->mtx); 2548 2549 /* 2550 * cfg80211 should catch this ... but it's racy since 2551 * we can receive a disassoc frame, process it, hand it 2552 * to cfg80211 while that's in a locked section already 2553 * trying to tell us that the user wants to disconnect. 2554 */ 2555 if (&ifmgd->associated->cbss != req->bss) { 2556 mutex_unlock(&ifmgd->mtx); 2557 return -ENOLINK; 2558 } 2559 2560 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n", 2561 sdata->dev->name, req->bss->bssid, req->reason_code); 2562 2563 ieee80211_set_disassoc(sdata, false); 2564 2565 mutex_unlock(&ifmgd->mtx); 2566 2567 ieee80211_send_deauth_disassoc(sdata, req->bss->bssid, 2568 IEEE80211_STYPE_DISASSOC, req->reason_code, 2569 cookie); 2570 return 0; 2571 } 2572