cfg.c 34 KB
Newer Older
1 2 3
/*
 * mac80211 configuration hooks for cfg80211
 *
4
 * Copyright 2006, 2007	Johannes Berg <johannes@sipsolutions.net>
5 6 7 8
 *
 * This file is GPLv2 as found in COPYING.
 */

9
#include <linux/ieee80211.h>
10 11
#include <linux/nl80211.h>
#include <linux/rtnetlink.h>
12
#include <net/net_namespace.h>
13
#include <linux/rcupdate.h>
14 15
#include <net/cfg80211.h>
#include "ieee80211_i.h"
16
#include "driver-ops.h"
17
#include "cfg.h"
Johannes Berg's avatar
Johannes Berg committed
18
#include "rate.h"
19 20
#include "mesh.h"

21
static bool nl80211_type_check(enum nl80211_iftype type)
22 23 24 25 26
{
	switch (type) {
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_MONITOR:
27 28 29
#ifdef CONFIG_MAC80211_MESH
	case NL80211_IFTYPE_MESH_POINT:
#endif
30 31
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
Johannes Berg's avatar
Johannes Berg committed
32
	case NL80211_IFTYPE_WDS:
33
		return true;
34
	default:
35
		return false;
36 37 38
	}
}

39
static int ieee80211_add_iface(struct wiphy *wiphy, char *name,
40 41
			       enum nl80211_iftype type, u32 *flags,
			       struct vif_params *params)
42 43
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
44 45 46
	struct net_device *dev;
	struct ieee80211_sub_if_data *sdata;
	int err;
47

48
	if (!nl80211_type_check(type))
49 50
		return -EINVAL;

51 52
	err = ieee80211_if_add(local, name, &dev, type, params);
	if (err || type != NL80211_IFTYPE_MONITOR || !flags)
53 54 55 56 57
		return err;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	sdata->u.mntr_flags = *flags;
	return 0;
58 59
}

60
static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev)
61
{
62
	ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev));
63

64
	return 0;
65 66
}

67 68
static int ieee80211_change_iface(struct wiphy *wiphy,
				  struct net_device *dev,
69 70
				  enum nl80211_iftype type, u32 *flags,
				  struct vif_params *params)
71 72
{
	struct ieee80211_sub_if_data *sdata;
73
	int ret;
74

75
	if (!nl80211_type_check(type))
76 77 78 79
		return -EINVAL;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

80
	ret = ieee80211_if_change_type(sdata, type);
81 82
	if (ret)
		return ret;
83

84 85 86
	if (netif_running(sdata->dev))
		return -EBUSY;

Johannes Berg's avatar
Johannes Berg committed
87
	if (ieee80211_vif_is_mesh(&sdata->vif) && params->mesh_id_len)
88 89 90
		ieee80211_sdata_set_mesh_id(sdata,
					    params->mesh_id_len,
					    params->mesh_id);
91

92
	if (sdata->vif.type != NL80211_IFTYPE_MONITOR || !flags)
93 94 95
		return 0;

	sdata->u.mntr_flags = *flags;
96 97 98
	return 0;
}

99
static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
100
			     u8 key_idx, const u8 *mac_addr,
101 102 103 104 105
			     struct key_params *params)
{
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta = NULL;
	enum ieee80211_key_alg alg;
106
	struct ieee80211_key *key;
107
	int err;
108 109 110 111 112 113 114 115 116 117 118 119 120 121

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	switch (params->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
		alg = ALG_WEP;
		break;
	case WLAN_CIPHER_SUITE_TKIP:
		alg = ALG_TKIP;
		break;
	case WLAN_CIPHER_SUITE_CCMP:
		alg = ALG_CCMP;
		break;
122 123 124
	case WLAN_CIPHER_SUITE_AES_CMAC:
		alg = ALG_AES_CMAC;
		break;
125 126 127 128
	default:
		return -EINVAL;
	}

129 130
	key = ieee80211_key_alloc(alg, key_idx, params->key_len, params->key,
				  params->seq_len, params->seq);
131 132 133
	if (!key)
		return -ENOMEM;

134 135
	rcu_read_lock();

136 137
	if (mac_addr) {
		sta = sta_info_get(sdata->local, mac_addr);
138 139
		if (!sta) {
			ieee80211_key_free(key);
140 141
			err = -ENOENT;
			goto out_unlock;
142
		}
143 144
	}

145 146
	ieee80211_key_link(key, sdata, sta);

147 148 149 150 151
	err = 0;
 out_unlock:
	rcu_read_unlock();

	return err;
152 153 154
}

static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
155
			     u8 key_idx, const u8 *mac_addr)
156 157 158 159 160 161 162
{
	struct ieee80211_sub_if_data *sdata;
	struct sta_info *sta;
	int ret;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

163 164
	rcu_read_lock();

165
	if (mac_addr) {
166 167
		ret = -ENOENT;

168 169
		sta = sta_info_get(sdata->local, mac_addr);
		if (!sta)
170
			goto out_unlock;
171

172
		if (sta->key) {
173
			ieee80211_key_free(sta->key);
174
			WARN_ON(sta->key);
175 176
			ret = 0;
		}
177

178
		goto out_unlock;
179 180
	}

181 182 183 184
	if (!sdata->keys[key_idx]) {
		ret = -ENOENT;
		goto out_unlock;
	}
185

186
	ieee80211_key_free(sdata->keys[key_idx]);
187
	WARN_ON(sdata->keys[key_idx]);
188

189 190 191 192 193
	ret = 0;
 out_unlock:
	rcu_read_unlock();

	return ret;
194 195
}

196
static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
197
			     u8 key_idx, const u8 *mac_addr, void *cookie,
198 199 200
			     void (*callback)(void *cookie,
					      struct key_params *params))
{
201
	struct ieee80211_sub_if_data *sdata;
202 203 204 205 206 207 208 209
	struct sta_info *sta = NULL;
	u8 seq[6] = {0};
	struct key_params params;
	struct ieee80211_key *key;
	u32 iv32;
	u16 iv16;
	int err = -ENOENT;

210 211
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

212 213
	rcu_read_lock();

214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	if (mac_addr) {
		sta = sta_info_get(sdata->local, mac_addr);
		if (!sta)
			goto out;

		key = sta->key;
	} else
		key = sdata->keys[key_idx];

	if (!key)
		goto out;

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

	switch (key->conf.alg) {
	case ALG_TKIP:
		params.cipher = WLAN_CIPHER_SUITE_TKIP;

232 233
		iv32 = key->u.tkip.tx.iv32;
		iv16 = key->u.tkip.tx.iv16;
234

235 236 237 238
		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
			drv_get_tkip_seq(sdata->local,
					 key->conf.hw_key_idx,
					 &iv32, &iv16);
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265

		seq[0] = iv16 & 0xff;
		seq[1] = (iv16 >> 8) & 0xff;
		seq[2] = iv32 & 0xff;
		seq[3] = (iv32 >> 8) & 0xff;
		seq[4] = (iv32 >> 16) & 0xff;
		seq[5] = (iv32 >> 24) & 0xff;
		params.seq = seq;
		params.seq_len = 6;
		break;
	case ALG_CCMP:
		params.cipher = WLAN_CIPHER_SUITE_CCMP;
		seq[0] = key->u.ccmp.tx_pn[5];
		seq[1] = key->u.ccmp.tx_pn[4];
		seq[2] = key->u.ccmp.tx_pn[3];
		seq[3] = key->u.ccmp.tx_pn[2];
		seq[4] = key->u.ccmp.tx_pn[1];
		seq[5] = key->u.ccmp.tx_pn[0];
		params.seq = seq;
		params.seq_len = 6;
		break;
	case ALG_WEP:
		if (key->conf.keylen == 5)
			params.cipher = WLAN_CIPHER_SUITE_WEP40;
		else
			params.cipher = WLAN_CIPHER_SUITE_WEP104;
		break;
266 267 268 269 270 271 272 273 274 275 276
	case ALG_AES_CMAC:
		params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
		seq[0] = key->u.aes_cmac.tx_pn[5];
		seq[1] = key->u.aes_cmac.tx_pn[4];
		seq[2] = key->u.aes_cmac.tx_pn[3];
		seq[3] = key->u.aes_cmac.tx_pn[2];
		seq[4] = key->u.aes_cmac.tx_pn[1];
		seq[5] = key->u.aes_cmac.tx_pn[0];
		params.seq = seq;
		params.seq_len = 6;
		break;
277 278 279 280 281 282 283 284 285
	}

	params.key = key->conf.key;
	params.key_len = key->conf.keylen;

	callback(cookie, &params);
	err = 0;

 out:
286
	rcu_read_unlock();
287 288 289
	return err;
}

290 291 292 293 294 295
static int ieee80211_config_default_key(struct wiphy *wiphy,
					struct net_device *dev,
					u8 key_idx)
{
	struct ieee80211_sub_if_data *sdata;

296 297
	rcu_read_lock();

298 299 300
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	ieee80211_set_default_key(sdata, key_idx);

301 302
	rcu_read_unlock();

303 304 305
	return 0;
}

306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
					     struct net_device *dev,
					     u8 key_idx)
{
	struct ieee80211_sub_if_data *sdata;

	rcu_read_lock();

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	ieee80211_set_default_mgmt_key(sdata, key_idx);

	rcu_read_unlock();

	return 0;
}

322 323
static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
{
324
	struct ieee80211_sub_if_data *sdata = sta->sdata;
325 326 327

	sinfo->filled = STATION_INFO_INACTIVE_TIME |
			STATION_INFO_RX_BYTES |
328
			STATION_INFO_TX_BYTES |
329 330
			STATION_INFO_RX_PACKETS |
			STATION_INFO_TX_PACKETS |
331
			STATION_INFO_TX_BITRATE;
332 333 334 335

	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
	sinfo->rx_bytes = sta->rx_bytes;
	sinfo->tx_bytes = sta->tx_bytes;
336 337
	sinfo->rx_packets = sta->rx_packets;
	sinfo->tx_packets = sta->tx_packets;
338

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
	if (sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) {
		sinfo->filled |= STATION_INFO_SIGNAL;
		sinfo->signal = (s8)sta->last_signal;
	}

	sinfo->txrate.flags = 0;
	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)
		sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI)
		sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;

	if (!(sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)) {
		struct ieee80211_supported_band *sband;
		sband = sta->local->hw.wiphy->bands[
				sta->local->hw.conf.channel->band];
		sinfo->txrate.legacy =
			sband->bitrates[sta->last_tx_rate.idx].bitrate;
	} else
		sinfo->txrate.mcs = sta->last_tx_rate.idx;

Johannes Berg's avatar
Johannes Berg committed
361
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
362 363 364 365 366 367 368 369 370
#ifdef CONFIG_MAC80211_MESH
		sinfo->filled |= STATION_INFO_LLID |
				 STATION_INFO_PLID |
				 STATION_INFO_PLINK_STATE;

		sinfo->llid = le16_to_cpu(sta->llid);
		sinfo->plid = le16_to_cpu(sta->plid);
		sinfo->plink_state = sta->plink_state;
#endif
Johannes Berg's avatar
Johannes Berg committed
371
	}
372 373 374 375 376 377 378 379
}


static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
				 int idx, u8 *mac, struct station_info *sinfo)
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct sta_info *sta;
380 381 382
	int ret = -ENOENT;

	rcu_read_lock();
383 384

	sta = sta_info_get_by_idx(local, idx, dev);
385 386
	if (sta) {
		ret = 0;
387
		memcpy(mac, sta->sta.addr, ETH_ALEN);
388 389
		sta_set_sinfo(sta, sinfo);
	}
390

391
	rcu_read_unlock();
392

393
	return ret;
394 395
}

396
static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
397
				 u8 *mac, struct station_info *sinfo)
398 399 400
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
	struct sta_info *sta;
401
	int ret = -ENOENT;
402

403
	rcu_read_lock();
404 405 406

	/* XXX: verify sta->dev == dev */

407 408 409 410 411 412 413 414 415
	sta = sta_info_get(local, mac);
	if (sta) {
		ret = 0;
		sta_set_sinfo(sta, sinfo);
	}

	rcu_read_unlock();

	return ret;
416 417
}

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
/*
 * This handles both adding a beacon and setting new beacon info
 */
static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
				   struct beacon_parameters *params)
{
	struct beacon_data *new, *old;
	int new_head_len, new_tail_len;
	int size;
	int err = -EINVAL;

	old = sdata->u.ap.beacon;

	/* head must not be zero-length */
	if (params->head && !params->head_len)
		return -EINVAL;

	/*
	 * This is a kludge. beacon interval should really be part
	 * of the beacon information.
	 */
439 440 441 442 443
	if (params->interval &&
	    (sdata->vif.bss_conf.beacon_int != params->interval)) {
		sdata->vif.bss_conf.beacon_int = params->interval;
		ieee80211_bss_info_change_notify(sdata,
						 BSS_CHANGED_BEACON_INT);
444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
	}

	/* Need to have a beacon head if we don't have one yet */
	if (!params->head && !old)
		return err;

	/* sorry, no way to start beaconing without dtim period */
	if (!params->dtim_period && !old)
		return err;

	/* new or old head? */
	if (params->head)
		new_head_len = params->head_len;
	else
		new_head_len = old->head_len;

	/* new or old tail? */
	if (params->tail || !old)
		/* params->tail_len will be zero for !params->tail */
		new_tail_len = params->tail_len;
	else
		new_tail_len = old->tail_len;

	size = sizeof(*new) + new_head_len + new_tail_len;

	new = kzalloc(size, GFP_KERNEL);
	if (!new)
		return -ENOMEM;

	/* start filling the new info now */

	/* new or old dtim period? */
	if (params->dtim_period)
		new->dtim_period = params->dtim_period;
	else
		new->dtim_period = old->dtim_period;

	/*
	 * pointers go into the block we allocated,
	 * memory is | beacon_data | head | tail |
	 */
	new->head = ((u8 *) new) + sizeof(*new);
	new->tail = new->head + new_head_len;
	new->head_len = new_head_len;
	new->tail_len = new_tail_len;

	/* copy in head */
	if (params->head)
		memcpy(new->head, params->head, new_head_len);
	else
		memcpy(new->head, old->head, new_head_len);

	/* copy in optional tail */
	if (params->tail)
		memcpy(new->tail, params->tail, new_tail_len);
	else
		if (old)
			memcpy(new->tail, old->tail, new_tail_len);

	rcu_assign_pointer(sdata->u.ap.beacon, new);

	synchronize_rcu();

	kfree(old);

509 510 511
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
						BSS_CHANGED_BEACON);
	return 0;
512 513 514 515 516
}

static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev,
				struct beacon_parameters *params)
{
517
	struct ieee80211_sub_if_data *sdata;
518 519
	struct beacon_data *old;

520 521
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

522 523 524 525 526 527 528 529 530 531 532
	old = sdata->u.ap.beacon;

	if (old)
		return -EALREADY;

	return ieee80211_config_beacon(sdata, params);
}

static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev,
				struct beacon_parameters *params)
{
533
	struct ieee80211_sub_if_data *sdata;
534 535
	struct beacon_data *old;

536 537
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

538 539 540 541 542 543 544 545 546 547
	old = sdata->u.ap.beacon;

	if (!old)
		return -ENOENT;

	return ieee80211_config_beacon(sdata, params);
}

static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev)
{
548
	struct ieee80211_sub_if_data *sdata;
549 550
	struct beacon_data *old;

551 552
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

553 554 555 556 557 558 559 560 561
	old = sdata->u.ap.beacon;

	if (!old)
		return -ENOENT;

	rcu_assign_pointer(sdata->u.ap.beacon, NULL);
	synchronize_rcu();
	kfree(old);

562 563
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
	return 0;
564 565
}

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
struct iapp_layer2_update {
	u8 da[ETH_ALEN];	/* broadcast */
	u8 sa[ETH_ALEN];	/* STA addr */
	__be16 len;		/* 6 */
	u8 dsap;		/* 0 */
	u8 ssap;		/* 0 */
	u8 control;
	u8 xid_info[3];
} __attribute__ ((packed));

static void ieee80211_send_layer2_update(struct sta_info *sta)
{
	struct iapp_layer2_update *msg;
	struct sk_buff *skb;

	/* Send Level 2 Update Frame to update forwarding tables in layer 2
	 * bridge devices */

	skb = dev_alloc_skb(sizeof(*msg));
	if (!skb)
		return;
	msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));

	/* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
	 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */

	memset(msg->da, 0xff, ETH_ALEN);
594
	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
595 596 597 598 599 600 601 602 603
	msg->len = htons(6);
	msg->dsap = 0;
	msg->ssap = 0x01;	/* NULL LSAP, CR Bit: Response */
	msg->control = 0xaf;	/* XID response lsb.1111F101.
				 * F=0 (no poll command; unsolicited frame) */
	msg->xid_info[0] = 0x81;	/* XID format identifier */
	msg->xid_info[1] = 1;	/* LLC types/classes: Type 1 LLC */
	msg->xid_info[2] = 0;	/* XID sender's receive window size (RW) */

604 605
	skb->dev = sta->sdata->dev;
	skb->protocol = eth_type_trans(skb, sta->sdata->dev);
606 607 608 609 610 611 612 613 614 615
	memset(skb->cb, 0, sizeof(skb->cb));
	netif_rx(skb);
}

static void sta_apply_parameters(struct ieee80211_local *local,
				 struct sta_info *sta,
				 struct station_parameters *params)
{
	u32 rates;
	int i, j;
616
	struct ieee80211_supported_band *sband;
617
	struct ieee80211_sub_if_data *sdata = sta->sdata;
618
	u32 mask, set;
619

Johannes Berg's avatar
Johannes Berg committed
620 621
	sband = local->hw.wiphy->bands[local->oper_channel->band];

622 623 624
	spin_lock_bh(&sta->lock);
	mask = params->sta_flags_mask;
	set = params->sta_flags_set;
Johannes Berg's avatar
Johannes Berg committed
625

626
	if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
627
		sta->flags &= ~WLAN_STA_AUTHORIZED;
628
		if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
629
			sta->flags |= WLAN_STA_AUTHORIZED;
630
	}
631

632
	if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
633
		sta->flags &= ~WLAN_STA_SHORT_PREAMBLE;
634
		if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
635
			sta->flags |= WLAN_STA_SHORT_PREAMBLE;
636
	}
637

638
	if (mask & BIT(NL80211_STA_FLAG_WME)) {
639
		sta->flags &= ~WLAN_STA_WME;
640
		if (set & BIT(NL80211_STA_FLAG_WME))
641
			sta->flags |= WLAN_STA_WME;
642
	}
643

644
	if (mask & BIT(NL80211_STA_FLAG_MFP)) {
645
		sta->flags &= ~WLAN_STA_MFP;
646
		if (set & BIT(NL80211_STA_FLAG_MFP))
647
			sta->flags |= WLAN_STA_MFP;
648
	}
649
	spin_unlock_bh(&sta->lock);
650

651 652 653 654 655 656 657
	/*
	 * cfg80211 validates this (1-2007) and allows setting the AID
	 * only when creating a new station entry
	 */
	if (params->aid)
		sta->sta.aid = params->aid;

Johannes Berg's avatar
Johannes Berg committed
658 659 660 661 662 663 664
	/*
	 * FIXME: updating the following information is racy when this
	 *	  function is called from ieee80211_change_station().
	 *	  However, all this information should be static so
	 *	  maybe we should just reject attemps to change it.
	 */

665 666 667 668 669
	if (params->listen_interval >= 0)
		sta->listen_interval = params->listen_interval;

	if (params->supported_rates) {
		rates = 0;
670

671 672
		for (i = 0; i < params->supported_rates_len; i++) {
			int rate = (params->supported_rates[i] & 0x7f) * 5;
673 674
			for (j = 0; j < sband->n_bitrates; j++) {
				if (sband->bitrates[j].bitrate == rate)
675 676 677
					rates |= BIT(j);
			}
		}
678
		sta->sta.supp_rates[local->oper_channel->band] = rates;
679
	}
680

681
	if (params->ht_capa)
Johannes Berg's avatar
Johannes Berg committed
682 683
		ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
						  params->ht_capa,
684
						  &sta->sta.ht_cap);
685

Johannes Berg's avatar
Johannes Berg committed
686
	if (ieee80211_vif_is_mesh(&sdata->vif) && params->plink_action) {
687 688 689 690 691 692 693 694
		switch (params->plink_action) {
		case PLINK_ACTION_OPEN:
			mesh_plink_open(sta);
			break;
		case PLINK_ACTION_BLOCK:
			mesh_plink_block(sta);
			break;
		}
Johannes Berg's avatar
Johannes Berg committed
695
	}
696 697 698 699 700
}

static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac, struct station_parameters *params)
{
701
	struct ieee80211_local *local = wiphy_priv(wiphy);
702 703
	struct sta_info *sta;
	struct ieee80211_sub_if_data *sdata;
Johannes Berg's avatar
Johannes Berg committed
704
	int err;
705
	int layer2_update;
706 707 708 709

	if (params->vlan) {
		sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

710 711
		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    sdata->vif.type != NL80211_IFTYPE_AP)
712 713 714 715
			return -EINVAL;
	} else
		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

716 717 718 719 720 721 722
	if (compare_ether_addr(mac, dev->dev_addr) == 0)
		return -EINVAL;

	if (is_multicast_ether_addr(mac))
		return -EINVAL;

	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
Johannes Berg's avatar
Johannes Berg committed
723 724
	if (!sta)
		return -ENOMEM;
725 726 727 728 729

	sta->flags = WLAN_STA_AUTH | WLAN_STA_ASSOC;

	sta_apply_parameters(local, sta, params);

730
	rate_control_rate_init(sta);
731

732 733 734
	layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
		sdata->vif.type == NL80211_IFTYPE_AP;

Johannes Berg's avatar
Johannes Berg committed
735 736 737 738
	rcu_read_lock();

	err = sta_info_insert(sta);
	if (err) {
739
		/* STA has been freed */
740 741 742 743 744 745
		if (err == -EEXIST && layer2_update) {
			/* Need to update layer 2 devices on reassociation */
			sta = sta_info_get(local, mac);
			if (sta)
				ieee80211_send_layer2_update(sta);
		}
Johannes Berg's avatar
Johannes Berg committed
746 747 748 749
		rcu_read_unlock();
		return err;
	}

750
	if (layer2_update)
Johannes Berg's avatar
Johannes Berg committed
751 752 753 754
		ieee80211_send_layer2_update(sta);

	rcu_read_unlock();

755 756 757 758 759 760
	return 0;
}

static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac)
{
761 762
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata;
763 764
	struct sta_info *sta;

765 766
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

767
	if (mac) {
Johannes Berg's avatar
Johannes Berg committed
768 769
		rcu_read_lock();

770 771
		/* XXX: get sta belonging to dev */
		sta = sta_info_get(local, mac);
Johannes Berg's avatar
Johannes Berg committed
772 773
		if (!sta) {
			rcu_read_unlock();
774
			return -ENOENT;
Johannes Berg's avatar
Johannes Berg committed
775
		}
776

777
		sta_info_unlink(&sta);
Johannes Berg's avatar
Johannes Berg committed
778 779
		rcu_read_unlock();

780
		sta_info_destroy(sta);
781
	} else
782
		sta_info_flush(local, sdata);
783 784 785 786 787 788 789 790 791

	return 0;
}

static int ieee80211_change_station(struct wiphy *wiphy,
				    struct net_device *dev,
				    u8 *mac,
				    struct station_parameters *params)
{
792
	struct ieee80211_local *local = wiphy_priv(wiphy);
793 794 795
	struct sta_info *sta;
	struct ieee80211_sub_if_data *vlansdata;

Johannes Berg's avatar
Johannes Berg committed
796 797
	rcu_read_lock();

798 799
	/* XXX: get sta belonging to dev */
	sta = sta_info_get(local, mac);
Johannes Berg's avatar
Johannes Berg committed
800 801
	if (!sta) {
		rcu_read_unlock();
802
		return -ENOENT;
Johannes Berg's avatar
Johannes Berg committed
803
	}
804

805
	if (params->vlan && params->vlan != sta->sdata->dev) {
806 807
		vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

808 809
		if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    vlansdata->vif.type != NL80211_IFTYPE_AP) {
Johannes Berg's avatar
Johannes Berg committed
810
			rcu_read_unlock();
811
			return -EINVAL;
Johannes Berg's avatar
Johannes Berg committed
812
		}
813

814
		sta->sdata = vlansdata;
815 816 817 818 819
		ieee80211_send_layer2_update(sta);
	}

	sta_apply_parameters(local, sta, params);

Johannes Berg's avatar
Johannes Berg committed
820 821
	rcu_read_unlock();

822 823 824
	return 0;
}

825 826 827 828
#ifdef CONFIG_MAC80211_MESH
static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
				 u8 *dst, u8 *next_hop)
{
829 830
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata;
831 832 833 834
	struct mesh_path *mpath;
	struct sta_info *sta;
	int err;

835 836
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

837
	rcu_read_lock();
838
	sta = sta_info_get(local, next_hop);
839 840
	if (!sta) {
		rcu_read_unlock();
841
		return -ENOENT;
842
	}
843

844
	err = mesh_path_add(dst, sdata);
845 846
	if (err) {
		rcu_read_unlock();
847
		return err;
848
	}
849

850
	mpath = mesh_path_lookup(dst, sdata);
851 852 853 854 855
	if (!mpath) {
		rcu_read_unlock();
		return -ENXIO;
	}
	mesh_path_fix_nexthop(mpath, sta);
856

857 858 859 860 861 862 863
	rcu_read_unlock();
	return 0;
}

static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
				 u8 *dst)
{
864 865
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

866
	if (dst)
867
		return mesh_path_del(dst, sdata);
868

869
	mesh_path_flush(sdata);
870 871 872 873 874 875 876
	return 0;
}

static int ieee80211_change_mpath(struct wiphy *wiphy,
				    struct net_device *dev,
				    u8 *dst, u8 *next_hop)
{
877 878
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata;
879 880 881
	struct mesh_path *mpath;
	struct sta_info *sta;

882 883
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

884 885
	rcu_read_lock();

886
	sta = sta_info_get(local, next_hop);
887 888
	if (!sta) {
		rcu_read_unlock();
889
		return -ENOENT;
890
	}
891

892
	mpath = mesh_path_lookup(dst, sdata);
893 894 895 896 897 898
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}

	mesh_path_fix_nexthop(mpath, sta);
899

900 901 902 903 904 905 906 907
	rcu_read_unlock();
	return 0;
}

static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
			    struct mpath_info *pinfo)
{
	if (mpath->next_hop)
908
		memcpy(next_hop, mpath->next_hop->sta.addr, ETH_ALEN);
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
	else
		memset(next_hop, 0, ETH_ALEN);

	pinfo->filled = MPATH_INFO_FRAME_QLEN |
			MPATH_INFO_DSN |
			MPATH_INFO_METRIC |
			MPATH_INFO_EXPTIME |
			MPATH_INFO_DISCOVERY_TIMEOUT |
			MPATH_INFO_DISCOVERY_RETRIES |
			MPATH_INFO_FLAGS;

	pinfo->frame_qlen = mpath->frame_queue.qlen;
	pinfo->dsn = mpath->dsn;
	pinfo->metric = mpath->metric;
	if (time_before(jiffies, mpath->exp_time))
		pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
	pinfo->discovery_timeout =
			jiffies_to_msecs(mpath->discovery_timeout);
	pinfo->discovery_retries = mpath->discovery_retries;
	pinfo->flags = 0;
	if (mpath->flags & MESH_PATH_ACTIVE)
		pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
	if (mpath->flags & MESH_PATH_RESOLVING)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
	if (mpath->flags & MESH_PATH_DSN_VALID)
		pinfo->flags |= NL80211_MPATH_FLAG_DSN_VALID;
	if (mpath->flags & MESH_PATH_FIXED)
		pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
	if (mpath->flags & MESH_PATH_RESOLVING)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;

	pinfo->flags = mpath->flags;
}

static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
			       u8 *dst, u8 *next_hop, struct mpath_info *pinfo)

{
947
	struct ieee80211_sub_if_data *sdata;
948 949
	struct mesh_path *mpath;

950 951
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

952
	rcu_read_lock();
953
	mpath = mesh_path_lookup(dst, sdata);
954 955 956 957 958 959 960 961 962 963 964 965 966 967
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}
	memcpy(dst, mpath->dst, ETH_ALEN);
	mpath_set_pinfo(mpath, next_hop, pinfo);
	rcu_read_unlock();
	return 0;
}

static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
				 int idx, u8 *dst, u8 *next_hop,
				 struct mpath_info *pinfo)
{
968
	struct ieee80211_sub_if_data *sdata;
969 970
	struct mesh_path *mpath;

971 972
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

973
	rcu_read_lock();
974
	mpath = mesh_path_lookup_by_idx(idx, sdata);
975 976 977 978 979 980 981 982 983
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}
	memcpy(dst, mpath->dst, ETH_ALEN);
	mpath_set_pinfo(mpath, next_hop, pinfo);
	rcu_read_unlock();
	return 0;
}
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044

static int ieee80211_get_mesh_params(struct wiphy *wiphy,
				struct net_device *dev,
				struct mesh_config *conf)
{
	struct ieee80211_sub_if_data *sdata;
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
	return 0;
}

static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
{
	return (mask >> (parm-1)) & 0x1;
}

static int ieee80211_set_mesh_params(struct wiphy *wiphy,
				struct net_device *dev,
				const struct mesh_config *nconf, u32 mask)
{
	struct mesh_config *conf;
	struct ieee80211_sub_if_data *sdata;
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	/* Set the config options which we are interested in setting */
	conf = &(sdata->u.mesh.mshcfg);
	if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
		conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
		conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
		conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
		conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
		conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
	if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
		conf->dot11MeshTTL = nconf->dot11MeshTTL;
	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
		conf->auto_open_plinks = nconf->auto_open_plinks;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
		conf->dot11MeshHWMPmaxPREQretries =
			nconf->dot11MeshHWMPmaxPREQretries;
	if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
		conf->path_refresh_time = nconf->path_refresh_time;
	if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
		conf->min_discovery_timeout = nconf->min_discovery_timeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
		conf->dot11MeshHWMPactivePathTimeout =
			nconf->dot11MeshHWMPactivePathTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
		conf->dot11MeshHWMPpreqMinInterval =
			nconf->dot11MeshHWMPpreqMinInterval;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
			   mask))
		conf->dot11MeshHWMPnetDiameterTraversalTime =
			nconf->dot11MeshHWMPnetDiameterTraversalTime;
	return 0;
}