mlme.c 60.2 KB
Newer Older
1 2
/*
 * BSS client mode implementation
3
 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
4 5 6 7 8 9 10 11 12 13
 * Copyright 2004, Instant802 Networks, Inc.
 * Copyright 2005, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

14
#include <linux/delay.h>
15 16 17 18
#include <linux/if_ether.h>
#include <linux/skbuff.h>
#include <linux/if_arp.h>
#include <linux/etherdevice.h>
19
#include <linux/rtnetlink.h>
20
#include <net/mac80211.h>
21
#include <asm/unaligned.h>
Johannes Berg's avatar
Johannes Berg committed
22

23
#include "ieee80211_i.h"
Johannes Berg's avatar
Johannes Berg committed
24 25
#include "rate.h"
#include "led.h"
26

27
#define IEEE80211_ASSOC_SCANS_MAX_TRIES 2
28 29 30 31 32
#define IEEE80211_AUTH_TIMEOUT (HZ / 5)
#define IEEE80211_AUTH_MAX_TRIES 3
#define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
#define IEEE80211_ASSOC_MAX_TRIES 3
#define IEEE80211_MONITORING_INTERVAL (2 * HZ)
33
#define IEEE80211_PROBE_IDLE_TIME (60 * HZ)
34 35
#define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)

36 37
/* utils */
static int ecw2cw(int ecw)
Johannes Berg's avatar
Johannes Berg committed
38
{
39
	return (1 << ecw) - 1;
Johannes Berg's avatar
Johannes Berg committed
40 41
}

42
static u8 *ieee80211_bss_get_ie(struct ieee80211_bss *bss, u8 ie)
43 44 45
{
	u8 *end, *pos;

46
	pos = bss->cbss.information_elements;
47 48
	if (pos == NULL)
		return NULL;
49
	end = pos + bss->cbss.len_information_elements;
50 51 52 53 54 55 56 57 58 59 60 61

	while (pos + 1 < end) {
		if (pos + 2 + pos[1] > end)
			break;
		if (pos[0] == ie)
			return pos;
		pos += 2 + pos[1];
	}

	return NULL;
}

62
static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
63
				      struct ieee80211_supported_band *sband,
64
				      u32 *rates)
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
{
	int i, j, count;
	*rates = 0;
	count = 0;
	for (i = 0; i < bss->supp_rates_len; i++) {
		int rate = (bss->supp_rates[i] & 0x7F) * 5;

		for (j = 0; j < sband->n_bitrates; j++)
			if (sband->bitrates[j].bitrate == rate) {
				*rates |= BIT(j);
				count++;
				break;
			}
	}

	return count;
}

83 84
/* frame sending functions */

85
static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
86
{
87
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
88 89 90
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt;
91
	u8 *pos, *ies, *ht_ie;
92 93
	int i, len, count, rates_len, supp_rates_len;
	u16 capab;
94
	struct ieee80211_bss *bss;
95 96
	int wmm = 0;
	struct ieee80211_supported_band *sband;
97
	u32 rates = 0;
98 99

	skb = dev_alloc_skb(local->hw.extra_tx_headroom +
100
			    sizeof(*mgmt) + 200 + ifmgd->extra_ie_len +
101
			    ifmgd->ssid_len);
102 103 104 105 106 107 108 109 110
	if (!skb) {
		printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
		       "frame\n", sdata->dev->name);
		return;
	}
	skb_reserve(skb, local->hw.extra_tx_headroom);

	sband = local->hw.wiphy->bands[local->hw.conf.channel->band];

111
	capab = ifmgd->capab;
112 113 114 115 116 117 118 119

	if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
		if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
			capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
		if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
			capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
	}

120
	bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
121
				   local->hw.conf.channel->center_freq,
122
				   ifmgd->ssid, ifmgd->ssid_len);
123
	if (bss) {
124
		if (bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
125 126 127 128 129 130 131 132 133 134
			capab |= WLAN_CAPABILITY_PRIVACY;
		if (bss->wmm_used)
			wmm = 1;

		/* get all rates supported by the device and the AP as
		 * some APs don't like getting a superset of their rates
		 * in the association request (e.g. D-Link DAP 1353 in
		 * b-only mode) */
		rates_len = ieee80211_compatible_rates(bss, sband, &rates);

135
		if ((bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
136 137 138 139 140 141 142 143 144 145 146
		    (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
			capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;

		ieee80211_rx_bss_put(local, bss);
	} else {
		rates = ~0;
		rates_len = sband->n_bitrates;
	}

	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
	memset(mgmt, 0, 24);
147
	memcpy(mgmt->da, ifmgd->bssid, ETH_ALEN);
148
	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
149
	memcpy(mgmt->bssid, ifmgd->bssid, ETH_ALEN);
150

151
	if (ifmgd->flags & IEEE80211_STA_PREV_BSSID_SET) {
152 153 154 155 156 157
		skb_put(skb, 10);
		mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
						  IEEE80211_STYPE_REASSOC_REQ);
		mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
		mgmt->u.reassoc_req.listen_interval =
				cpu_to_le16(local->hw.conf.listen_interval);
158
		memcpy(mgmt->u.reassoc_req.current_ap, ifmgd->prev_bssid,
159 160 161 162 163 164
		       ETH_ALEN);
	} else {
		skb_put(skb, 4);
		mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
						  IEEE80211_STYPE_ASSOC_REQ);
		mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
165
		mgmt->u.assoc_req.listen_interval =
166 167 168 169
				cpu_to_le16(local->hw.conf.listen_interval);
	}

	/* SSID */
170
	ies = pos = skb_put(skb, 2 + ifmgd->ssid_len);
171
	*pos++ = WLAN_EID_SSID;
172 173
	*pos++ = ifmgd->ssid_len;
	memcpy(pos, ifmgd->ssid, ifmgd->ssid_len);
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227

	/* add all rates which were marked to be used above */
	supp_rates_len = rates_len;
	if (supp_rates_len > 8)
		supp_rates_len = 8;

	len = sband->n_bitrates;
	pos = skb_put(skb, supp_rates_len + 2);
	*pos++ = WLAN_EID_SUPP_RATES;
	*pos++ = supp_rates_len;

	count = 0;
	for (i = 0; i < sband->n_bitrates; i++) {
		if (BIT(i) & rates) {
			int rate = sband->bitrates[i].bitrate;
			*pos++ = (u8) (rate / 5);
			if (++count == 8)
				break;
		}
	}

	if (rates_len > count) {
		pos = skb_put(skb, rates_len - count + 2);
		*pos++ = WLAN_EID_EXT_SUPP_RATES;
		*pos++ = rates_len - count;

		for (i++; i < sband->n_bitrates; i++) {
			if (BIT(i) & rates) {
				int rate = sband->bitrates[i].bitrate;
				*pos++ = (u8) (rate / 5);
			}
		}
	}

	if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
		/* 1. power capabilities */
		pos = skb_put(skb, 4);
		*pos++ = WLAN_EID_PWR_CAPABILITY;
		*pos++ = 2;
		*pos++ = 0; /* min tx power */
		*pos++ = local->hw.conf.channel->max_power; /* max tx power */

		/* 2. supported channels */
		/* TODO: get this in reg domain format */
		pos = skb_put(skb, 2 * sband->n_channels + 2);
		*pos++ = WLAN_EID_SUPPORTED_CHANNELS;
		*pos++ = 2 * sband->n_channels;
		for (i = 0; i < sband->n_channels; i++) {
			*pos++ = ieee80211_frequency_to_channel(
					sband->channels[i].center_freq);
			*pos++ = 1; /* one channel in the subband*/
		}
	}

228 229 230
	if (ifmgd->extra_ie) {
		pos = skb_put(skb, ifmgd->extra_ie_len);
		memcpy(pos, ifmgd->extra_ie, ifmgd->extra_ie_len);
231 232
	}

233
	if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
234 235 236 237 238 239 240 241 242 243 244 245 246
		pos = skb_put(skb, 9);
		*pos++ = WLAN_EID_VENDOR_SPECIFIC;
		*pos++ = 7; /* len */
		*pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
		*pos++ = 0x50;
		*pos++ = 0xf2;
		*pos++ = 2; /* WME */
		*pos++ = 0; /* WME info */
		*pos++ = 1; /* WME ver */
		*pos++ = 0;
	}

	/* wmm support is a must to HT */
247 248 249 250 251 252
	/*
	 * IEEE802.11n does not allow TKIP/WEP as pairwise
	 * ciphers in HT mode. We still associate in non-ht
	 * mode (11a/b/g) if any one of these ciphers is
	 * configured as pairwise.
	 */
253
	if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
254 255
	    sband->ht_cap.ht_supported &&
	    (ht_ie = ieee80211_bss_get_ie(bss, WLAN_EID_HT_INFORMATION)) &&
256
	    ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
257
	    (!(ifmgd->flags & IEEE80211_STA_TKIP_WEP_USED))) {
258 259 260
		struct ieee80211_ht_info *ht_info =
			(struct ieee80211_ht_info *)(ht_ie + 2);
		u16 cap = sband->ht_cap.cap;
261 262 263
		__le16 tmp;
		u32 flags = local->hw.conf.channel->flags;

264 265
		switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
		case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
266
			if (flags & IEEE80211_CHAN_NO_FAT_ABOVE) {
267
				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
268 269 270
				cap &= ~IEEE80211_HT_CAP_SGI_40;
			}
			break;
271
		case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
272
			if (flags & IEEE80211_CHAN_NO_FAT_BELOW) {
273
				cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
274 275 276 277 278 279 280 281 282 283 284 285 286
				cap &= ~IEEE80211_HT_CAP_SGI_40;
			}
			break;
		}

		tmp = cpu_to_le16(cap);
		pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
		*pos++ = WLAN_EID_HT_CAPABILITY;
		*pos++ = sizeof(struct ieee80211_ht_cap);
		memset(pos, 0, sizeof(struct ieee80211_ht_cap));
		memcpy(pos, &tmp, sizeof(u16));
		pos += sizeof(u16);
		/* TODO: needs a define here for << 2 */
287 288 289
		*pos++ = sband->ht_cap.ampdu_factor |
			 (sband->ht_cap.ampdu_density << 2);
		memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
290 291
	}

292 293 294 295 296
	kfree(ifmgd->assocreq_ies);
	ifmgd->assocreq_ies_len = (skb->data + skb->len) - ies;
	ifmgd->assocreq_ies = kmalloc(ifmgd->assocreq_ies_len, GFP_KERNEL);
	if (ifmgd->assocreq_ies)
		memcpy(ifmgd->assocreq_ies, ies, ifmgd->assocreq_ies_len);
297

298
	ieee80211_tx_skb(sdata, skb, 0);
299 300 301
}


302 303
static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
					   u16 stype, u16 reason)
304 305
{
	struct ieee80211_local *local = sdata->local;
306
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
307 308
	struct sk_buff *skb;
	struct ieee80211_mgmt *mgmt;
309

310
	skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
311
	if (!skb) {
312 313
		printk(KERN_DEBUG "%s: failed to allocate buffer for "
		       "deauth/disassoc frame\n", sdata->dev->name);
314 315 316 317 318 319
		return;
	}
	skb_reserve(skb, local->hw.extra_tx_headroom);

	mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
	memset(mgmt, 0, 24);
320
	memcpy(mgmt->da, ifmgd->bssid, ETH_ALEN);
321
	memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
322
	memcpy(mgmt->bssid, ifmgd->bssid, ETH_ALEN);
323
	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
324
	skb_put(skb, 2);
325
	/* u.deauth.reason_code == u.disassoc.reason_code */
326 327
	mgmt->u.deauth.reason_code = cpu_to_le16(reason);

328
	ieee80211_tx_skb(sdata, skb, ifmgd->flags & IEEE80211_STA_MFP_ENABLED);
329 330
}

331 332 333
void ieee80211_send_pspoll(struct ieee80211_local *local,
			   struct ieee80211_sub_if_data *sdata)
{
334
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
	struct ieee80211_pspoll *pspoll;
	struct sk_buff *skb;
	u16 fc;

	skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
	if (!skb) {
		printk(KERN_DEBUG "%s: failed to allocate buffer for "
		       "pspoll frame\n", sdata->dev->name);
		return;
	}
	skb_reserve(skb, local->hw.extra_tx_headroom);

	pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
	memset(pspoll, 0, sizeof(*pspoll));
	fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
	pspoll->frame_control = cpu_to_le16(fc);
351
	pspoll->aid = cpu_to_le16(ifmgd->aid);
352 353 354 355

	/* aid in PS-Poll has its two MSBs each set to 1 */
	pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);

356
	memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
357 358 359 360 361
	memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);

	ieee80211_tx_skb(sdata, skb, 0);
}

Johannes Berg's avatar
Johannes Berg committed
362
/* MLME */
363
static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
364
				     struct ieee80211_if_managed *ifmgd,
365 366 367 368 369 370 371
				     u8 *wmm_param, size_t wmm_param_len)
{
	struct ieee80211_tx_queue_params params;
	size_t left;
	int count;
	u8 *pos;

372
	if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
373 374 375 376 377
		return;

	if (!wmm_param)
		return;

378 379 380
	if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
		return;
	count = wmm_param[6] & 0x0f;
381
	if (count == ifmgd->wmm_last_param_set)
382
		return;
383
	ifmgd->wmm_last_param_set = count;
384 385 386 387 388 389 390 391 392 393 394 395 396

	pos = wmm_param + 8;
	left = wmm_param_len - 8;

	memset(&params, 0, sizeof(params));

	local->wmm_acm = 0;
	for (; left >= 4; left -= 4, pos += 4) {
		int aci = (pos[0] >> 5) & 0x03;
		int acm = (pos[0] >> 4) & 0x01;
		int queue;

		switch (aci) {
397
		case 1: /* AC_BK */
Johannes Berg's avatar
Johannes Berg committed
398
			queue = 3;
Johannes Berg's avatar
Johannes Berg committed
399
			if (acm)
400
				local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
401
			break;
402
		case 2: /* AC_VI */
Johannes Berg's avatar
Johannes Berg committed
403
			queue = 1;
Johannes Berg's avatar
Johannes Berg committed
404
			if (acm)
405
				local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
406
			break;
407
		case 3: /* AC_VO */
Johannes Berg's avatar
Johannes Berg committed
408
			queue = 0;
Johannes Berg's avatar
Johannes Berg committed
409
			if (acm)
410
				local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
411
			break;
412
		case 0: /* AC_BE */
413
		default:
Johannes Berg's avatar
Johannes Berg committed
414
			queue = 2;
Johannes Berg's avatar
Johannes Berg committed
415
			if (acm)
416
				local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
417 418 419 420 421 422
			break;
		}

		params.aifs = pos[0] & 0x0f;
		params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
		params.cw_min = ecw2cw(pos[1] & 0x0f);
423
		params.txop = get_unaligned_le16(pos + 2);
424
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
425
		printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
426
		       "cWmin=%d cWmax=%d txop=%d\n",
427
		       local->mdev->name, queue, aci, acm, params.aifs, params.cw_min,
428 429
		       params.cw_max, params.txop);
#endif
430 431
		if (local->ops->conf_tx &&
		    local->ops->conf_tx(local_to_hw(local), queue, &params)) {
432
			printk(KERN_DEBUG "%s: failed to set TX queue "
433
			       "parameters for queue %d\n", local->mdev->name, queue);
434 435 436 437
		}
	}
}

438
static bool ieee80211_check_tim(struct ieee802_11_elems *elems, u16 aid)
439 440 441 442 443
{
	u8 mask;
	u8 index, indexn1, indexn2;
	struct ieee80211_tim_ie *tim = (struct ieee80211_tim_ie *) elems->tim;

444 445 446
	if (unlikely(!tim || elems->tim_len < 4))
		return false;

447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
	aid &= 0x3fff;
	index = aid / 8;
	mask  = 1 << (aid & 7);

	indexn1 = tim->bitmap_ctrl & 0xfe;
	indexn2 = elems->tim_len + indexn1 - 4;

	if (index < indexn1 || index > indexn2)
		return false;

	index -= indexn1;

	return !!(tim->virtual_map[index] & mask);
}

462 463
static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
					   u16 capab, bool erp_valid, u8 erp)
464
{
465
	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
466
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
467
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
468
#endif
469
	u32 changed = 0;
470 471 472 473 474 475 476 477 478 479 480 481 482
	bool use_protection;
	bool use_short_preamble;
	bool use_short_slot;

	if (erp_valid) {
		use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
		use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
	} else {
		use_protection = false;
		use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
	}

	use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
483

484
	if (use_protection != bss_conf->use_cts_prot) {
485
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
486
		if (net_ratelimit()) {
487
			printk(KERN_DEBUG "%s: CTS protection %s (BSSID=%pM)\n",
488
			       sdata->dev->name,
489
			       use_protection ? "enabled" : "disabled",
490
			       ifmgd->bssid);
491
		}
492
#endif
493 494
		bss_conf->use_cts_prot = use_protection;
		changed |= BSS_CHANGED_ERP_CTS_PROT;
495
	}
496

497
	if (use_short_preamble != bss_conf->use_short_preamble) {
498
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
499 500
		if (net_ratelimit()) {
			printk(KERN_DEBUG "%s: switched to %s barker preamble"
501
			       " (BSSID=%pM)\n",
502
			       sdata->dev->name,
503
			       use_short_preamble ? "short" : "long",
504
			       ifmgd->bssid);
505
		}
506
#endif
507
		bss_conf->use_short_preamble = use_short_preamble;
508
		changed |= BSS_CHANGED_ERP_PREAMBLE;
509
	}
510

511 512 513
	if (use_short_slot != bss_conf->use_short_slot) {
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
		if (net_ratelimit()) {
514 515
			printk(KERN_DEBUG "%s: switched to %s slot time"
			       " (BSSID=%pM)\n",
516 517
			       sdata->dev->name,
			       use_short_slot ? "short" : "long",
518
			       ifmgd->bssid);
519 520 521 522
		}
#endif
		bss_conf->use_short_slot = use_short_slot;
		changed |= BSS_CHANGED_ERP_SLOT;
523 524 525 526 527
	}

	return changed;
}

528
static void ieee80211_sta_send_apinfo(struct ieee80211_sub_if_data *sdata)
529 530
{
	union iwreq_data wrqu;
531

532
	memset(&wrqu, 0, sizeof(wrqu));
533 534
	if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED)
		memcpy(wrqu.ap_addr.sa_data, sdata->u.mgd.bssid, ETH_ALEN);
535 536 537 538
	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
	wireless_send_event(sdata->dev, SIOCGIWAP, &wrqu, NULL);
}

539
static void ieee80211_sta_send_associnfo(struct ieee80211_sub_if_data *sdata)
540
{
541
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
542 543 544
	char *buf;
	size_t len;
	int i;
545 546
	union iwreq_data wrqu;

547
	if (!ifmgd->assocreq_ies && !ifmgd->assocresp_ies)
548 549
		return;

550 551
	buf = kmalloc(50 + 2 * (ifmgd->assocreq_ies_len +
				ifmgd->assocresp_ies_len), GFP_KERNEL);
552 553 554 555
	if (!buf)
		return;

	len = sprintf(buf, "ASSOCINFO(");
556
	if (ifmgd->assocreq_ies) {
557
		len += sprintf(buf + len, "ReqIEs=");
558
		for (i = 0; i < ifmgd->assocreq_ies_len; i++) {
559
			len += sprintf(buf + len, "%02x",
560
				       ifmgd->assocreq_ies[i]);
561
		}
562
	}
563 564
	if (ifmgd->assocresp_ies) {
		if (ifmgd->assocreq_ies)
565 566
			len += sprintf(buf + len, " ");
		len += sprintf(buf + len, "RespIEs=");
567
		for (i = 0; i < ifmgd->assocresp_ies_len; i++) {
568
			len += sprintf(buf + len, "%02x",
569
				       ifmgd->assocresp_ies[i]);
570
		}
571
	}
572 573 574 575
	len += sprintf(buf + len, ")");

	if (len > IW_CUSTOM_MAX) {
		len = sprintf(buf, "ASSOCRESPIE=");
576
		for (i = 0; i < ifmgd->assocresp_ies_len; i++) {
577
			len += sprintf(buf + len, "%02x",
578
				       ifmgd->assocresp_ies[i]);
579 580 581
		}
	}

582 583 584 585 586
	if (len <= IW_CUSTOM_MAX) {
		memset(&wrqu, 0, sizeof(wrqu));
		wrqu.data.length = len;
		wireless_send_event(sdata->dev, IWEVCUSTOM, &wrqu, buf);
	}
587 588

	kfree(buf);
589 590 591
}


592
static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
Johannes Berg's avatar
Johannes Berg committed
593
				     u32 bss_info_changed)
594
{
595
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
596
	struct ieee80211_local *local = sdata->local;
Tomas Winkler's avatar
Tomas Winkler committed
597
	struct ieee80211_conf *conf = &local_to_hw(local)->conf;
598

599
	struct ieee80211_bss *bss;
600

Johannes Berg's avatar
Johannes Berg committed
601
	bss_info_changed |= BSS_CHANGED_ASSOC;
602
	ifmgd->flags |= IEEE80211_STA_ASSOCIATED;
603

604
	bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
605
				   conf->channel->center_freq,
606
				   ifmgd->ssid, ifmgd->ssid_len);
607 608
	if (bss) {
		/* set timing information */
609 610
		sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
		sdata->vif.bss_conf.timestamp = bss->cbss.tsf;
611
		sdata->vif.bss_conf.dtim_period = bss->dtim_period;
612

Johannes Berg's avatar
Johannes Berg committed
613
		bss_info_changed |= ieee80211_handle_bss_capability(sdata,
614
			bss->cbss.capability, bss->has_erp_value, bss->erp_value);
615

616 617
		cfg80211_hold_bss(&bss->cbss);

618
		ieee80211_rx_bss_put(local, bss);
619 620
	}

621 622 623
	ifmgd->flags |= IEEE80211_STA_PREV_BSSID_SET;
	memcpy(ifmgd->prev_bssid, sdata->u.mgd.bssid, ETH_ALEN);
	ieee80211_sta_send_associnfo(sdata);
624

625
	ifmgd->last_probe = jiffies;
626
	ieee80211_led_assoc(local, 1);
627

628
	sdata->vif.bss_conf.assoc = 1;
629 630 631 632 633
	/*
	 * For now just always ask the driver to update the basic rateset
	 * when we have associated, we aren't checking whether it actually
	 * changed or not.
	 */
Johannes Berg's avatar
Johannes Berg committed
634 635
	bss_info_changed |= BSS_CHANGED_BASIC_RATES;
	ieee80211_bss_info_change_notify(sdata, bss_info_changed);
636

637 638 639
	if (local->powersave) {
		if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS) &&
		    local->hw.conf.dynamic_ps_timeout > 0) {
640
			mod_timer(&local->dynamic_ps_timer, jiffies +
641 642
				  msecs_to_jiffies(
					local->hw.conf.dynamic_ps_timeout));
643 644 645
		} else {
			if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
				ieee80211_send_nullfunc(local, sdata, 1);
646
			conf->flags |= IEEE80211_CONF_PS;
647
			ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
648
		}
649 650
	}

651 652
	netif_tx_start_all_queues(sdata->dev);
	netif_carrier_on(sdata->dev);
653

654
	ieee80211_sta_send_apinfo(sdata);
655 656
}

657
static void ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata)
658
{
659
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
660
	struct ieee80211_local *local = sdata->local;
661 662 663

	ifmgd->direct_probe_tries++;
	if (ifmgd->direct_probe_tries > IEEE80211_AUTH_MAX_TRIES) {
664
		printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
665 666 667
		       sdata->dev->name, ifmgd->bssid);
		ifmgd->state = IEEE80211_STA_MLME_DISABLED;
		ieee80211_sta_send_apinfo(sdata);
668 669 670 671 672

		/*
		 * Most likely AP is not in the range so remove the
		 * bss information associated to the AP
		 */
673
		ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
674
				sdata->local->hw.conf.channel->center_freq,
675
				ifmgd->ssid, ifmgd->ssid_len);
676 677 678 679 680 681 682

		/*
		 * We might have a pending scan which had no chance to run yet
		 * due to state == IEEE80211_STA_MLME_DIRECT_PROBE.
		 * Hence, queue the STAs work again
		 */
		queue_work(local->hw.workqueue, &ifmgd->work);
683 684 685
		return;
	}

686
	printk(KERN_DEBUG "%s: direct probe to AP %pM try %d\n",
687 688
			sdata->dev->name, ifmgd->bssid,
			ifmgd->direct_probe_tries);
689

690
	ifmgd->state = IEEE80211_STA_MLME_DIRECT_PROBE;
691

692
	set_bit(IEEE80211_STA_REQ_DIRECT_PROBE, &ifmgd->request);
693 694 695 696 697

	/* Direct probe is sent to broadcast address as some APs
	 * will not answer to direct packet in unassociated state.
	 */
	ieee80211_send_probe_req(sdata, NULL,
698
				 ifmgd->ssid, ifmgd->ssid_len, NULL, 0);
699

700
	mod_timer(&ifmgd->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
Johannes Berg's avatar
Johannes Berg committed
701
}
702

703

704
static void ieee80211_authenticate(struct ieee80211_sub_if_data *sdata)
705
{
706
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
707
	struct ieee80211_local *local = sdata->local;
708 709
	u8 *ies;
	size_t ies_len;
710 711 712

	ifmgd->auth_tries++;
	if (ifmgd->auth_tries > IEEE80211_AUTH_MAX_TRIES) {
713
		printk(KERN_DEBUG "%s: authentication with AP %pM"
714
		       " timed out\n",
715 716 717 718
		       sdata->dev->name, ifmgd->bssid);
		ifmgd->state = IEEE80211_STA_MLME_DISABLED;
		ieee80211_sta_send_apinfo(sdata);
		ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
719
				sdata->local->hw.conf.channel->center_freq,
720
				ifmgd->ssid, ifmgd->ssid_len);
721 722 723 724 725 726 727

		/*
		 * We might have a pending scan which had no chance to run yet
		 * due to state == IEEE80211_STA_MLME_AUTHENTICATE.
		 * Hence, queue the STAs work again
		 */
		queue_work(local->hw.workqueue, &ifmgd->work);
728 729 730
		return;
	}

731
	ifmgd->state = IEEE80211_STA_MLME_AUTHENTICATE;
732
	printk(KERN_DEBUG "%s: authenticate with AP %pM\n",
733
	       sdata->dev->name, ifmgd->bssid);
734

735 736 737 738 739 740 741 742
	if (ifmgd->flags & IEEE80211_STA_EXT_SME) {
		ies = ifmgd->sme_auth_ie;
		ies_len = ifmgd->sme_auth_ie_len;
	} else {
		ies = NULL;
		ies_len = 0;
	}
	ieee80211_send_auth(sdata, 1, ifmgd->auth_alg, ies, ies_len,
743 744
			    ifmgd->bssid, 0);
	ifmgd->auth_transaction = 2;
745

746
	mod_timer(&ifmgd->timer, jiffies + IEEE80211_AUTH_TIMEOUT);
747 748
}

749 750 751 752
/*
 * The disassoc 'reason' argument can be either our own reason
 * if self disconnected or a reason code from the AP.
 */
753
static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
754 755
				   bool deauth, bool self_disconnected,
				   u16 reason)
756
{
757
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
758
	struct ieee80211_local *local = sdata->local;
759 760
	struct ieee80211_conf *conf = &local_to_hw(local)->conf;
	struct ieee80211_bss *bss;
761
	struct sta_info *sta;
762
	u32 changed = 0, config_changed = 0;
763 764 765

	rcu_read_lock();

766
	sta = sta_info_get(local, ifmgd->bssid);
767 768 769 770 771 772
	if (!sta) {
		rcu_read_unlock();
		return;
	}

	if (deauth) {
773 774
		ifmgd->direct_probe_tries = 0;
		ifmgd->auth_tries = 0;
775
	}
776 777
	ifmgd->assoc_scan_tries = 0;
	ifmgd->assoc_tries = 0;
778

779
	netif_tx_stop_all_queues(sdata->dev);
780 781
	netif_carrier_off(sdata->dev);

782
	ieee80211_sta_tear_down_BA_sessions(sta);
783

784 785 786 787 788 789 790 791 792
	bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
				   conf->channel->center_freq,
				   ifmgd->ssid, ifmgd->ssid_len);

	if (bss) {
		cfg80211_unhold_bss(&bss->cbss);
		ieee80211_rx_bss_put(local, bss);
	}

793 794
	if (self_disconnected) {
		if (deauth)
795 796
			ieee80211_send_deauth_disassoc(sdata,
				IEEE80211_STYPE_DEAUTH, reason);
797
		else
798 799
			ieee80211_send_deauth_disassoc(sdata,
				IEEE80211_STYPE_DISASSOC, reason);
800 801
	}

802
	ifmgd->flags &= ~IEEE80211_STA_ASSOCIATED;
803 804 805
	changed |= ieee80211_reset_erp_info(sdata);

	ieee80211_led_assoc(local, 0);
Johannes Berg's avatar
Johannes Berg committed
806 807
	changed |= BSS_CHANGED_ASSOC;
	sdata->vif.bss_conf.assoc = false;
808

809
	ieee80211_sta_send_apinfo(sdata);
810

811
	if (self_disconnected || reason == WLAN_REASON_DISASSOC_STA_HAS_LEFT) {
812 813
		ifmgd->state = IEEE80211_STA_MLME_DISABLED;
		ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
814
				sdata->local->hw.conf.channel->center_freq,
815
				ifmgd->ssid, ifmgd->ssid_len);
816
	}
817 818 819

	rcu_read_unlock();

820
	/* channel(_type) changes are handled by ieee80211_hw_config */
Sujith's avatar
Sujith committed
821
	local->oper_channel_type = NL80211_CHAN_NO_HT;
822

823 824
	local->power_constr_level = 0;

825 826 827
	del_timer_sync(&local->dynamic_ps_timer);
	cancel_work_sync(&local->dynamic_ps_enable_work);

828 829 830 831
	if (local->hw.conf.flags & IEEE80211_CONF_PS) {
		local->hw.conf.flags &= ~IEEE80211_CONF_PS;
		config_changed |= IEEE80211_CONF_CHANGE_PS;
	}
Johannes Berg's avatar
Johannes Berg committed
832

833
	ieee80211_hw_config(local, config_changed);
Johannes Berg's avatar
Johannes Berg committed
834
	ieee80211_bss_info_change_notify(sdata, changed);
835 836 837

	rcu_read_lock();

838
	sta = sta_info_get(local, ifmgd->bssid);
839 840 841 842 843 844 845 846 847 848
	if (!sta) {
		rcu_read_unlock();
		return;
	}

	sta_info_unlink(&sta);

	rcu_read_unlock();

	sta_info_destroy(sta);
849
}
850

851 852 853 854 855 856 857 858
static int ieee80211_sta_wep_configured(struct ieee80211_sub_if_data *sdata)
{
	if (!sdata || !sdata->default_key ||
	    sdata->default_key->conf.alg != ALG_WEP)
		return 0;
	return 1;
}

859
static int ieee80211_privacy_mismatch(struct ieee80211_sub_if_data *sdata)
860
{
861
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
862
	struct ieee80211_local *local = sdata->local;
863
	struct ieee80211_bss *bss;
864 865 866
	int bss_privacy;
	int wep_privacy;
	int privacy_invoked;
867

868
	if (!ifmgd || (ifmgd->flags & IEEE80211_STA_EXT_SME))
869 870
		return 0;

871
	bss = ieee80211_rx_bss_get(local, ifmgd->bssid,
872
				   local->hw.conf.channel->center_freq,
873
				   ifmgd->ssid, ifmgd->ssid_len);
874 875 876
	if (!bss)
		return 0;

877
	bss_privacy = !!(bss->cbss.capability & WLAN_CAPABILITY_PRIVACY);
878
	wep_privacy = !!ieee80211_sta_wep_configured(sdata);
879
	privacy_invoked = !!(ifmgd->flags & IEEE80211_STA_PRIVACY_INVOKED);
880

881
	ieee80211_rx_bss_put(local, bss);
882

883 884 885 886
	if ((bss_privacy == wep_privacy) || (bss_privacy == privacy_invoked))
		return 0;

	return 1;
887 888
}

889
static void ieee80211_associate(struct ieee80211_sub_if_data *sdata)
890
{
891
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
892
	struct ieee80211_local *local = sdata->local;
893 894 895

	ifmgd->assoc_tries++;
	if (ifmgd->assoc_tries > IEEE80211_ASSOC_MAX_TRIES) {
896
		printk(KERN_DEBUG "%s: association with AP %pM"
897
		       " timed out\n",
898 899 900 901
		       sdata->dev->name, ifmgd->bssid);
		ifmgd->state = IEEE80211_STA_MLME_DISABLED;
		ieee80211_sta_send_apinfo(sdata);
		ieee80211_rx_bss_remove(sdata, ifmgd->bssid,
902
				sdata->local->hw.conf.channel->center_freq,
903
				ifmgd->ssid, ifmgd->ssid_len);
904 905 906 907 908 909
		/*
		 * We might have a pending scan which had no chance to run yet
		 * due to state == IEEE80211_STA_MLME_ASSOCIATE.
		 * Hence, queue the STAs work again
		 */
		queue_work(local->hw.workqueue, &ifmgd->work);
910 911 912
		return;
	}

913
	ifmgd->state = IEEE80211_STA_MLME_ASSOCIATE;
914
	printk(KERN_DEBUG "%s: associate with AP %pM\n",
915 916
	       sdata->dev->name, ifmgd->bssid);
	if (ieee80211_privacy_mismatch(sdata)) {
917
		printk(KERN_DEBUG "%s: mismatch in privacy configuration and "
918
		       "mixed-cell disabled - abort association\n", sdata->dev->name);
919
		ifmgd->state = IEEE80211_STA_MLME_DISABLED;
920 921 922
		return;
	}

923
	ieee80211_send_assoc(sdata);
924

925
	mod_timer(&ifmgd->timer, jiffies + IEEE80211_ASSOC_TIMEOUT);
926 927
}

928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
			     struct ieee80211_hdr *hdr)
{
	/*
	 * We can postpone the mgd.timer whenever receiving unicast frames
	 * from AP because we know that the connection is working both ways
	 * at that time. But multicast frames (and hence also beacons) must
	 * be ignored here, because we need to trigger the timer during
	 * data idle periods for sending the periodical probe request to
	 * the AP.
	 */
	if (!is_multicast_ether_addr(hdr->addr1))
		mod_timer(&sdata->u.mgd.timer,
			  jiffies + IEEE80211_MONITORING_INTERVAL);
}
943

944 945 946 947 948 949 950
void ieee80211_beacon_loss_work(struct work_struct *work)
{
	struct ieee80211_sub_if_data *sdata =
		container_of(work, struct ieee80211_sub_if_data,
			     u.mgd.beacon_loss_work);
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;

951 952 953 954 955 956 957
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
	if (net_ratelimit()) {
		printk(KERN_DEBUG "%s: driver reports beacon loss from AP %pM "
		       "- sending probe request\n", sdata->dev->name,
		       sdata->u.mgd.bssid);
	}
#endif
958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974

	ifmgd->flags |= IEEE80211_STA_PROBEREQ_POLL;
	ieee80211_send_probe_req(sdata, ifmgd->bssid, ifmgd->ssid,
				 ifmgd->ssid_len, NULL, 0);

	mod_timer(&ifmgd->timer, jiffies + IEEE80211_MONITORING_INTERVAL);
}

void ieee80211_beacon_loss(struct ieee80211_vif *vif)
{
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);

	queue_work(sdata->local->hw.workqueue,
		   &sdata->u.mgd.beacon_loss_work);
}
EXPORT_SYMBOL(ieee80211_beacon_loss);

975
static void ieee80211_associated(struct ieee80211_sub_if_data *sdata)
976
{
977
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
978
	struct ieee80211_local *local = sdata->local;
979
	struct sta_info *sta;
980
	bool disassoc = false;
981 982 983 984 985 986

	/* TODO: start monitoring current AP signal quality and number of
	 * missed beacons. Scan other channels every now and then and search
	 * for better APs. */
	/* TODO: remove expired BSSes */

987
	ifmgd->state = IEEE80211_STA_MLME_ASSOCIATED;
988

989 990
	rcu_read_lock();

991
	sta = sta_info_get(local, ifmgd->bssid);
992
	if (!sta) {
993
		printk(KERN_DEBUG "%s: No STA entry for own AP %pM\n",
994
		       sdata->dev->name, ifmgd->bssid);
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
		disassoc = true;
		goto unlock;
	}

	if ((ifmgd->flags & IEEE80211_STA_PROBEREQ_POLL) &&
	    time_after(jiffies, sta->last_rx + IEEE80211_MONITORING_INTERVAL)) {
		printk(KERN_DEBUG "%s: no probe response from AP %pM "
		       "- disassociating\n",
		       sdata->dev->name, ifmgd->bssid);
		disassoc = true;
		ifmgd->flags &= ~IEEE80211_STA_PROBEREQ_POLL;
		goto unlock;
	}

1009 1010 1011 1012 1013 1014 1015
	/*
	 * Beacon filtering is only enabled with power save and then the
	 * stack should not check for beacon loss.
	 */
	if (!((local->hw.flags & IEEE80211_HW_BEACON_FILTER) &&
	      (local->hw.conf.flags & IEEE80211_CONF_PS)) &&
	    time_after(jiffies,
1016
		       ifmgd->last_beacon + IEEE80211_MONITORING_INTERVAL)) {
1017 1018 1019 1020 1021 1022 1023
#i