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