net/mac80211/mlme.c

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