PageRenderTime 156ms CodeModel.GetById 17ms app.highlight 124ms RepoModel.GetById 1ms app.codeStats 0ms

/net/wireless/sme.c

http://github.com/mirrors/linux
C | 1350 lines | 1024 code | 197 blank | 129 comment | 184 complexity | fdc4a76d727cdd8d627480f53fd2be61 MD5 | raw file 
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * SME code for cfg80211
   4 * both driver SME event handling and the SME implementation
   5 * (for nl80211's connect() and wext)
   6 *
   7 * Copyright 2009	Johannes Berg <johannes@sipsolutions.net>
   8 * Copyright (C) 2009   Intel Corporation. All rights reserved.
   9 * Copyright 2017	Intel Deutschland GmbH
  10 */
  11
  12#include <linux/etherdevice.h>
  13#include <linux/if_arp.h>
  14#include <linux/slab.h>
  15#include <linux/workqueue.h>
  16#include <linux/wireless.h>
  17#include <linux/export.h>
  18#include <net/iw_handler.h>
  19#include <net/cfg80211.h>
  20#include <net/rtnetlink.h>
  21#include "nl80211.h"
  22#include "reg.h"
  23#include "rdev-ops.h"
  24
  25/*
  26 * Software SME in cfg80211, using auth/assoc/deauth calls to the
  27 * driver. This is is for implementing nl80211's connect/disconnect
  28 * and wireless extensions (if configured.)
  29 */
  30
  31struct cfg80211_conn {
  32	struct cfg80211_connect_params params;
  33	/* these are sub-states of the _CONNECTING sme_state */
  34	enum {
  35		CFG80211_CONN_SCANNING,
  36		CFG80211_CONN_SCAN_AGAIN,
  37		CFG80211_CONN_AUTHENTICATE_NEXT,
  38		CFG80211_CONN_AUTHENTICATING,
  39		CFG80211_CONN_AUTH_FAILED_TIMEOUT,
  40		CFG80211_CONN_ASSOCIATE_NEXT,
  41		CFG80211_CONN_ASSOCIATING,
  42		CFG80211_CONN_ASSOC_FAILED,
  43		CFG80211_CONN_ASSOC_FAILED_TIMEOUT,
  44		CFG80211_CONN_DEAUTH,
  45		CFG80211_CONN_ABANDON,
  46		CFG80211_CONN_CONNECTED,
  47	} state;
  48	u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
  49	const u8 *ie;
  50	size_t ie_len;
  51	bool auto_auth, prev_bssid_valid;
  52};
  53
  54static void cfg80211_sme_free(struct wireless_dev *wdev)
  55{
  56	if (!wdev->conn)
  57		return;
  58
  59	kfree(wdev->conn->ie);
  60	kfree(wdev->conn);
  61	wdev->conn = NULL;
  62}
  63
  64static int cfg80211_conn_scan(struct wireless_dev *wdev)
  65{
  66	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
  67	struct cfg80211_scan_request *request;
  68	int n_channels, err;
  69
  70	ASSERT_RTNL();
  71	ASSERT_WDEV_LOCK(wdev);
  72
  73	if (rdev->scan_req || rdev->scan_msg)
  74		return -EBUSY;
  75
  76	if (wdev->conn->params.channel)
  77		n_channels = 1;
  78	else
  79		n_channels = ieee80211_get_num_supported_channels(wdev->wiphy);
  80
  81	request = kzalloc(sizeof(*request) + sizeof(request->ssids[0]) +
  82			  sizeof(request->channels[0]) * n_channels,
  83			  GFP_KERNEL);
  84	if (!request)
  85		return -ENOMEM;
  86
  87	if (wdev->conn->params.channel) {
  88		enum nl80211_band band = wdev->conn->params.channel->band;
  89		struct ieee80211_supported_band *sband =
  90			wdev->wiphy->bands[band];
  91
  92		if (!sband) {
  93			kfree(request);
  94			return -EINVAL;
  95		}
  96		request->channels[0] = wdev->conn->params.channel;
  97		request->rates[band] = (1 << sband->n_bitrates) - 1;
  98	} else {
  99		int i = 0, j;
 100		enum nl80211_band band;
 101		struct ieee80211_supported_band *bands;
 102		struct ieee80211_channel *channel;
 103
 104		for (band = 0; band < NUM_NL80211_BANDS; band++) {
 105			bands = wdev->wiphy->bands[band];
 106			if (!bands)
 107				continue;
 108			for (j = 0; j < bands->n_channels; j++) {
 109				channel = &bands->channels[j];
 110				if (channel->flags & IEEE80211_CHAN_DISABLED)
 111					continue;
 112				request->channels[i++] = channel;
 113			}
 114			request->rates[band] = (1 << bands->n_bitrates) - 1;
 115		}
 116		n_channels = i;
 117	}
 118	request->n_channels = n_channels;
 119	request->ssids = (void *)&request->channels[n_channels];
 120	request->n_ssids = 1;
 121
 122	memcpy(request->ssids[0].ssid, wdev->conn->params.ssid,
 123		wdev->conn->params.ssid_len);
 124	request->ssids[0].ssid_len = wdev->conn->params.ssid_len;
 125
 126	eth_broadcast_addr(request->bssid);
 127
 128	request->wdev = wdev;
 129	request->wiphy = &rdev->wiphy;
 130	request->scan_start = jiffies;
 131
 132	rdev->scan_req = request;
 133
 134	err = rdev_scan(rdev, request);
 135	if (!err) {
 136		wdev->conn->state = CFG80211_CONN_SCANNING;
 137		nl80211_send_scan_start(rdev, wdev);
 138		dev_hold(wdev->netdev);
 139	} else {
 140		rdev->scan_req = NULL;
 141		kfree(request);
 142	}
 143	return err;
 144}
 145
 146static int cfg80211_conn_do_work(struct wireless_dev *wdev,
 147				 enum nl80211_timeout_reason *treason)
 148{
 149	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 150	struct cfg80211_connect_params *params;
 151	struct cfg80211_assoc_request req = {};
 152	int err;
 153
 154	ASSERT_WDEV_LOCK(wdev);
 155
 156	if (!wdev->conn)
 157		return 0;
 158
 159	params = &wdev->conn->params;
 160
 161	switch (wdev->conn->state) {
 162	case CFG80211_CONN_SCANNING:
 163		/* didn't find it during scan ... */
 164		return -ENOENT;
 165	case CFG80211_CONN_SCAN_AGAIN:
 166		return cfg80211_conn_scan(wdev);
 167	case CFG80211_CONN_AUTHENTICATE_NEXT:
 168		if (WARN_ON(!rdev->ops->auth))
 169			return -EOPNOTSUPP;
 170		wdev->conn->state = CFG80211_CONN_AUTHENTICATING;
 171		return cfg80211_mlme_auth(rdev, wdev->netdev,
 172					  params->channel, params->auth_type,
 173					  params->bssid,
 174					  params->ssid, params->ssid_len,
 175					  NULL, 0,
 176					  params->key, params->key_len,
 177					  params->key_idx, NULL, 0);
 178	case CFG80211_CONN_AUTH_FAILED_TIMEOUT:
 179		*treason = NL80211_TIMEOUT_AUTH;
 180		return -ENOTCONN;
 181	case CFG80211_CONN_ASSOCIATE_NEXT:
 182		if (WARN_ON(!rdev->ops->assoc))
 183			return -EOPNOTSUPP;
 184		wdev->conn->state = CFG80211_CONN_ASSOCIATING;
 185		if (wdev->conn->prev_bssid_valid)
 186			req.prev_bssid = wdev->conn->prev_bssid;
 187		req.ie = params->ie;
 188		req.ie_len = params->ie_len;
 189		req.use_mfp = params->mfp != NL80211_MFP_NO;
 190		req.crypto = params->crypto;
 191		req.flags = params->flags;
 192		req.ht_capa = params->ht_capa;
 193		req.ht_capa_mask = params->ht_capa_mask;
 194		req.vht_capa = params->vht_capa;
 195		req.vht_capa_mask = params->vht_capa_mask;
 196
 197		err = cfg80211_mlme_assoc(rdev, wdev->netdev, params->channel,
 198					  params->bssid, params->ssid,
 199					  params->ssid_len, &req);
 200		if (err)
 201			cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
 202					     NULL, 0,
 203					     WLAN_REASON_DEAUTH_LEAVING,
 204					     false);
 205		return err;
 206	case CFG80211_CONN_ASSOC_FAILED_TIMEOUT:
 207		*treason = NL80211_TIMEOUT_ASSOC;
 208		/* fall through */
 209	case CFG80211_CONN_ASSOC_FAILED:
 210		cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
 211				     NULL, 0,
 212				     WLAN_REASON_DEAUTH_LEAVING, false);
 213		return -ENOTCONN;
 214	case CFG80211_CONN_DEAUTH:
 215		cfg80211_mlme_deauth(rdev, wdev->netdev, params->bssid,
 216				     NULL, 0,
 217				     WLAN_REASON_DEAUTH_LEAVING, false);
 218		/* fall through */
 219	case CFG80211_CONN_ABANDON:
 220		/* free directly, disconnected event already sent */
 221		cfg80211_sme_free(wdev);
 222		return 0;
 223	default:
 224		return 0;
 225	}
 226}
 227
 228void cfg80211_conn_work(struct work_struct *work)
 229{
 230	struct cfg80211_registered_device *rdev =
 231		container_of(work, struct cfg80211_registered_device, conn_work);
 232	struct wireless_dev *wdev;
 233	u8 bssid_buf[ETH_ALEN], *bssid = NULL;
 234	enum nl80211_timeout_reason treason;
 235
 236	rtnl_lock();
 237
 238	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
 239		if (!wdev->netdev)
 240			continue;
 241
 242		wdev_lock(wdev);
 243		if (!netif_running(wdev->netdev)) {
 244			wdev_unlock(wdev);
 245			continue;
 246		}
 247		if (!wdev->conn ||
 248		    wdev->conn->state == CFG80211_CONN_CONNECTED) {
 249			wdev_unlock(wdev);
 250			continue;
 251		}
 252		if (wdev->conn->params.bssid) {
 253			memcpy(bssid_buf, wdev->conn->params.bssid, ETH_ALEN);
 254			bssid = bssid_buf;
 255		}
 256		treason = NL80211_TIMEOUT_UNSPECIFIED;
 257		if (cfg80211_conn_do_work(wdev, &treason)) {
 258			struct cfg80211_connect_resp_params cr;
 259
 260			memset(&cr, 0, sizeof(cr));
 261			cr.status = -1;
 262			cr.bssid = bssid;
 263			cr.timeout_reason = treason;
 264			__cfg80211_connect_result(wdev->netdev, &cr, false);
 265		}
 266		wdev_unlock(wdev);
 267	}
 268
 269	rtnl_unlock();
 270}
 271
 272/* Returned bss is reference counted and must be cleaned up appropriately. */
 273static struct cfg80211_bss *cfg80211_get_conn_bss(struct wireless_dev *wdev)
 274{
 275	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 276	struct cfg80211_bss *bss;
 277
 278	ASSERT_WDEV_LOCK(wdev);
 279
 280	bss = cfg80211_get_bss(wdev->wiphy, wdev->conn->params.channel,
 281			       wdev->conn->params.bssid,
 282			       wdev->conn->params.ssid,
 283			       wdev->conn->params.ssid_len,
 284			       wdev->conn_bss_type,
 285			       IEEE80211_PRIVACY(wdev->conn->params.privacy));
 286	if (!bss)
 287		return NULL;
 288
 289	memcpy(wdev->conn->bssid, bss->bssid, ETH_ALEN);
 290	wdev->conn->params.bssid = wdev->conn->bssid;
 291	wdev->conn->params.channel = bss->channel;
 292	wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
 293	schedule_work(&rdev->conn_work);
 294
 295	return bss;
 296}
 297
 298static void __cfg80211_sme_scan_done(struct net_device *dev)
 299{
 300	struct wireless_dev *wdev = dev->ieee80211_ptr;
 301	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 302	struct cfg80211_bss *bss;
 303
 304	ASSERT_WDEV_LOCK(wdev);
 305
 306	if (!wdev->conn)
 307		return;
 308
 309	if (wdev->conn->state != CFG80211_CONN_SCANNING &&
 310	    wdev->conn->state != CFG80211_CONN_SCAN_AGAIN)
 311		return;
 312
 313	bss = cfg80211_get_conn_bss(wdev);
 314	if (bss)
 315		cfg80211_put_bss(&rdev->wiphy, bss);
 316	else
 317		schedule_work(&rdev->conn_work);
 318}
 319
 320void cfg80211_sme_scan_done(struct net_device *dev)
 321{
 322	struct wireless_dev *wdev = dev->ieee80211_ptr;
 323
 324	wdev_lock(wdev);
 325	__cfg80211_sme_scan_done(dev);
 326	wdev_unlock(wdev);
 327}
 328
 329void cfg80211_sme_rx_auth(struct wireless_dev *wdev, const u8 *buf, size_t len)
 330{
 331	struct wiphy *wiphy = wdev->wiphy;
 332	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 333	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
 334	u16 status_code = le16_to_cpu(mgmt->u.auth.status_code);
 335
 336	ASSERT_WDEV_LOCK(wdev);
 337
 338	if (!wdev->conn || wdev->conn->state == CFG80211_CONN_CONNECTED)
 339		return;
 340
 341	if (status_code == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG &&
 342	    wdev->conn->auto_auth &&
 343	    wdev->conn->params.auth_type != NL80211_AUTHTYPE_NETWORK_EAP) {
 344		/* select automatically between only open, shared, leap */
 345		switch (wdev->conn->params.auth_type) {
 346		case NL80211_AUTHTYPE_OPEN_SYSTEM:
 347			if (wdev->connect_keys)
 348				wdev->conn->params.auth_type =
 349					NL80211_AUTHTYPE_SHARED_KEY;
 350			else
 351				wdev->conn->params.auth_type =
 352					NL80211_AUTHTYPE_NETWORK_EAP;
 353			break;
 354		case NL80211_AUTHTYPE_SHARED_KEY:
 355			wdev->conn->params.auth_type =
 356				NL80211_AUTHTYPE_NETWORK_EAP;
 357			break;
 358		default:
 359			/* huh? */
 360			wdev->conn->params.auth_type =
 361				NL80211_AUTHTYPE_OPEN_SYSTEM;
 362			break;
 363		}
 364		wdev->conn->state = CFG80211_CONN_AUTHENTICATE_NEXT;
 365		schedule_work(&rdev->conn_work);
 366	} else if (status_code != WLAN_STATUS_SUCCESS) {
 367		struct cfg80211_connect_resp_params cr;
 368
 369		memset(&cr, 0, sizeof(cr));
 370		cr.status = status_code;
 371		cr.bssid = mgmt->bssid;
 372		cr.timeout_reason = NL80211_TIMEOUT_UNSPECIFIED;
 373		__cfg80211_connect_result(wdev->netdev, &cr, false);
 374	} else if (wdev->conn->state == CFG80211_CONN_AUTHENTICATING) {
 375		wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
 376		schedule_work(&rdev->conn_work);
 377	}
 378}
 379
 380bool cfg80211_sme_rx_assoc_resp(struct wireless_dev *wdev, u16 status)
 381{
 382	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 383
 384	if (!wdev->conn)
 385		return false;
 386
 387	if (status == WLAN_STATUS_SUCCESS) {
 388		wdev->conn->state = CFG80211_CONN_CONNECTED;
 389		return false;
 390	}
 391
 392	if (wdev->conn->prev_bssid_valid) {
 393		/*
 394		 * Some stupid APs don't accept reassoc, so we
 395		 * need to fall back to trying regular assoc;
 396		 * return true so no event is sent to userspace.
 397		 */
 398		wdev->conn->prev_bssid_valid = false;
 399		wdev->conn->state = CFG80211_CONN_ASSOCIATE_NEXT;
 400		schedule_work(&rdev->conn_work);
 401		return true;
 402	}
 403
 404	wdev->conn->state = CFG80211_CONN_ASSOC_FAILED;
 405	schedule_work(&rdev->conn_work);
 406	return false;
 407}
 408
 409void cfg80211_sme_deauth(struct wireless_dev *wdev)
 410{
 411	cfg80211_sme_free(wdev);
 412}
 413
 414void cfg80211_sme_auth_timeout(struct wireless_dev *wdev)
 415{
 416	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 417
 418	if (!wdev->conn)
 419		return;
 420
 421	wdev->conn->state = CFG80211_CONN_AUTH_FAILED_TIMEOUT;
 422	schedule_work(&rdev->conn_work);
 423}
 424
 425void cfg80211_sme_disassoc(struct wireless_dev *wdev)
 426{
 427	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 428
 429	if (!wdev->conn)
 430		return;
 431
 432	wdev->conn->state = CFG80211_CONN_DEAUTH;
 433	schedule_work(&rdev->conn_work);
 434}
 435
 436void cfg80211_sme_assoc_timeout(struct wireless_dev *wdev)
 437{
 438	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 439
 440	if (!wdev->conn)
 441		return;
 442
 443	wdev->conn->state = CFG80211_CONN_ASSOC_FAILED_TIMEOUT;
 444	schedule_work(&rdev->conn_work);
 445}
 446
 447void cfg80211_sme_abandon_assoc(struct wireless_dev *wdev)
 448{
 449	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 450
 451	if (!wdev->conn)
 452		return;
 453
 454	wdev->conn->state = CFG80211_CONN_ABANDON;
 455	schedule_work(&rdev->conn_work);
 456}
 457
 458static int cfg80211_sme_get_conn_ies(struct wireless_dev *wdev,
 459				     const u8 *ies, size_t ies_len,
 460				     const u8 **out_ies, size_t *out_ies_len)
 461{
 462	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 463	u8 *buf;
 464	size_t offs;
 465
 466	if (!rdev->wiphy.extended_capabilities_len ||
 467	    (ies && cfg80211_find_ie(WLAN_EID_EXT_CAPABILITY, ies, ies_len))) {
 468		*out_ies = kmemdup(ies, ies_len, GFP_KERNEL);
 469		if (!*out_ies)
 470			return -ENOMEM;
 471		*out_ies_len = ies_len;
 472		return 0;
 473	}
 474
 475	buf = kmalloc(ies_len + rdev->wiphy.extended_capabilities_len + 2,
 476		      GFP_KERNEL);
 477	if (!buf)
 478		return -ENOMEM;
 479
 480	if (ies_len) {
 481		static const u8 before_extcapa[] = {
 482			/* not listing IEs expected to be created by driver */
 483			WLAN_EID_RSN,
 484			WLAN_EID_QOS_CAPA,
 485			WLAN_EID_RRM_ENABLED_CAPABILITIES,
 486			WLAN_EID_MOBILITY_DOMAIN,
 487			WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
 488			WLAN_EID_BSS_COEX_2040,
 489		};
 490
 491		offs = ieee80211_ie_split(ies, ies_len, before_extcapa,
 492					  ARRAY_SIZE(before_extcapa), 0);
 493		memcpy(buf, ies, offs);
 494		/* leave a whole for extended capabilities IE */
 495		memcpy(buf + offs + rdev->wiphy.extended_capabilities_len + 2,
 496		       ies + offs, ies_len - offs);
 497	} else {
 498		offs = 0;
 499	}
 500
 501	/* place extended capabilities IE (with only driver capabilities) */
 502	buf[offs] = WLAN_EID_EXT_CAPABILITY;
 503	buf[offs + 1] = rdev->wiphy.extended_capabilities_len;
 504	memcpy(buf + offs + 2,
 505	       rdev->wiphy.extended_capabilities,
 506	       rdev->wiphy.extended_capabilities_len);
 507
 508	*out_ies = buf;
 509	*out_ies_len = ies_len + rdev->wiphy.extended_capabilities_len + 2;
 510
 511	return 0;
 512}
 513
 514static int cfg80211_sme_connect(struct wireless_dev *wdev,
 515				struct cfg80211_connect_params *connect,
 516				const u8 *prev_bssid)
 517{
 518	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 519	struct cfg80211_bss *bss;
 520	int err;
 521
 522	if (!rdev->ops->auth || !rdev->ops->assoc)
 523		return -EOPNOTSUPP;
 524
 525	if (wdev->current_bss) {
 526		cfg80211_unhold_bss(wdev->current_bss);
 527		cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
 528		wdev->current_bss = NULL;
 529
 530		cfg80211_sme_free(wdev);
 531	}
 532
 533	if (WARN_ON(wdev->conn))
 534		return -EINPROGRESS;
 535
 536	wdev->conn = kzalloc(sizeof(*wdev->conn), GFP_KERNEL);
 537	if (!wdev->conn)
 538		return -ENOMEM;
 539
 540	/*
 541	 * Copy all parameters, and treat explicitly IEs, BSSID, SSID.
 542	 */
 543	memcpy(&wdev->conn->params, connect, sizeof(*connect));
 544	if (connect->bssid) {
 545		wdev->conn->params.bssid = wdev->conn->bssid;
 546		memcpy(wdev->conn->bssid, connect->bssid, ETH_ALEN);
 547	}
 548
 549	if (cfg80211_sme_get_conn_ies(wdev, connect->ie, connect->ie_len,
 550				      &wdev->conn->ie,
 551				      &wdev->conn->params.ie_len)) {
 552		kfree(wdev->conn);
 553		wdev->conn = NULL;
 554		return -ENOMEM;
 555	}
 556	wdev->conn->params.ie = wdev->conn->ie;
 557
 558	if (connect->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
 559		wdev->conn->auto_auth = true;
 560		/* start with open system ... should mostly work */
 561		wdev->conn->params.auth_type =
 562			NL80211_AUTHTYPE_OPEN_SYSTEM;
 563	} else {
 564		wdev->conn->auto_auth = false;
 565	}
 566
 567	wdev->conn->params.ssid = wdev->ssid;
 568	wdev->conn->params.ssid_len = wdev->ssid_len;
 569
 570	/* see if we have the bss already */
 571	bss = cfg80211_get_conn_bss(wdev);
 572
 573	if (prev_bssid) {
 574		memcpy(wdev->conn->prev_bssid, prev_bssid, ETH_ALEN);
 575		wdev->conn->prev_bssid_valid = true;
 576	}
 577
 578	/* we're good if we have a matching bss struct */
 579	if (bss) {
 580		enum nl80211_timeout_reason treason;
 581
 582		err = cfg80211_conn_do_work(wdev, &treason);
 583		cfg80211_put_bss(wdev->wiphy, bss);
 584	} else {
 585		/* otherwise we'll need to scan for the AP first */
 586		err = cfg80211_conn_scan(wdev);
 587
 588		/*
 589		 * If we can't scan right now, then we need to scan again
 590		 * after the current scan finished, since the parameters
 591		 * changed (unless we find a good AP anyway).
 592		 */
 593		if (err == -EBUSY) {
 594			err = 0;
 595			wdev->conn->state = CFG80211_CONN_SCAN_AGAIN;
 596		}
 597	}
 598
 599	if (err)
 600		cfg80211_sme_free(wdev);
 601
 602	return err;
 603}
 604
 605static int cfg80211_sme_disconnect(struct wireless_dev *wdev, u16 reason)
 606{
 607	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 608	int err;
 609
 610	if (!wdev->conn)
 611		return 0;
 612
 613	if (!rdev->ops->deauth)
 614		return -EOPNOTSUPP;
 615
 616	if (wdev->conn->state == CFG80211_CONN_SCANNING ||
 617	    wdev->conn->state == CFG80211_CONN_SCAN_AGAIN) {
 618		err = 0;
 619		goto out;
 620	}
 621
 622	/* wdev->conn->params.bssid must be set if > SCANNING */
 623	err = cfg80211_mlme_deauth(rdev, wdev->netdev,
 624				   wdev->conn->params.bssid,
 625				   NULL, 0, reason, false);
 626 out:
 627	cfg80211_sme_free(wdev);
 628	return err;
 629}
 630
 631/*
 632 * code shared for in-device and software SME
 633 */
 634
 635static bool cfg80211_is_all_idle(void)
 636{
 637	struct cfg80211_registered_device *rdev;
 638	struct wireless_dev *wdev;
 639	bool is_all_idle = true;
 640
 641	/*
 642	 * All devices must be idle as otherwise if you are actively
 643	 * scanning some new beacon hints could be learned and would
 644	 * count as new regulatory hints.
 645	 * Also if there is any other active beaconing interface we
 646	 * need not issue a disconnect hint and reset any info such
 647	 * as chan dfs state, etc.
 648	 */
 649	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
 650		list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
 651			wdev_lock(wdev);
 652			if (wdev->conn || wdev->current_bss ||
 653			    cfg80211_beaconing_iface_active(wdev))
 654				is_all_idle = false;
 655			wdev_unlock(wdev);
 656		}
 657	}
 658
 659	return is_all_idle;
 660}
 661
 662static void disconnect_work(struct work_struct *work)
 663{
 664	rtnl_lock();
 665	if (cfg80211_is_all_idle())
 666		regulatory_hint_disconnect();
 667	rtnl_unlock();
 668}
 669
 670DECLARE_WORK(cfg80211_disconnect_work, disconnect_work);
 671
 672
 673/*
 674 * API calls for drivers implementing connect/disconnect and
 675 * SME event handling
 676 */
 677
 678/* This method must consume bss one way or another */
 679void __cfg80211_connect_result(struct net_device *dev,
 680			       struct cfg80211_connect_resp_params *cr,
 681			       bool wextev)
 682{
 683	struct wireless_dev *wdev = dev->ieee80211_ptr;
 684	const u8 *country_ie;
 685#ifdef CONFIG_CFG80211_WEXT
 686	union iwreq_data wrqu;
 687#endif
 688
 689	ASSERT_WDEV_LOCK(wdev);
 690
 691	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
 692		    wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)) {
 693		cfg80211_put_bss(wdev->wiphy, cr->bss);
 694		return;
 695	}
 696
 697	nl80211_send_connect_result(wiphy_to_rdev(wdev->wiphy), dev, cr,
 698				    GFP_KERNEL);
 699
 700#ifdef CONFIG_CFG80211_WEXT
 701	if (wextev) {
 702		if (cr->req_ie && cr->status == WLAN_STATUS_SUCCESS) {
 703			memset(&wrqu, 0, sizeof(wrqu));
 704			wrqu.data.length = cr->req_ie_len;
 705			wireless_send_event(dev, IWEVASSOCREQIE, &wrqu,
 706					    cr->req_ie);
 707		}
 708
 709		if (cr->resp_ie && cr->status == WLAN_STATUS_SUCCESS) {
 710			memset(&wrqu, 0, sizeof(wrqu));
 711			wrqu.data.length = cr->resp_ie_len;
 712			wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu,
 713					    cr->resp_ie);
 714		}
 715
 716		memset(&wrqu, 0, sizeof(wrqu));
 717		wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 718		if (cr->bssid && cr->status == WLAN_STATUS_SUCCESS) {
 719			memcpy(wrqu.ap_addr.sa_data, cr->bssid, ETH_ALEN);
 720			memcpy(wdev->wext.prev_bssid, cr->bssid, ETH_ALEN);
 721			wdev->wext.prev_bssid_valid = true;
 722		}
 723		wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
 724	}
 725#endif
 726
 727	if (!cr->bss && (cr->status == WLAN_STATUS_SUCCESS)) {
 728		WARN_ON_ONCE(!wiphy_to_rdev(wdev->wiphy)->ops->connect);
 729		cr->bss = cfg80211_get_bss(wdev->wiphy, NULL, cr->bssid,
 730					   wdev->ssid, wdev->ssid_len,
 731					   wdev->conn_bss_type,
 732					   IEEE80211_PRIVACY_ANY);
 733		if (cr->bss)
 734			cfg80211_hold_bss(bss_from_pub(cr->bss));
 735	}
 736
 737	if (wdev->current_bss) {
 738		cfg80211_unhold_bss(wdev->current_bss);
 739		cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
 740		wdev->current_bss = NULL;
 741	}
 742
 743	if (cr->status != WLAN_STATUS_SUCCESS) {
 744		kzfree(wdev->connect_keys);
 745		wdev->connect_keys = NULL;
 746		wdev->ssid_len = 0;
 747		wdev->conn_owner_nlportid = 0;
 748		if (cr->bss) {
 749			cfg80211_unhold_bss(bss_from_pub(cr->bss));
 750			cfg80211_put_bss(wdev->wiphy, cr->bss);
 751		}
 752		cfg80211_sme_free(wdev);
 753		return;
 754	}
 755
 756	if (WARN_ON(!cr->bss))
 757		return;
 758
 759	wdev->current_bss = bss_from_pub(cr->bss);
 760
 761	if (!(wdev->wiphy->flags & WIPHY_FLAG_HAS_STATIC_WEP))
 762		cfg80211_upload_connect_keys(wdev);
 763
 764	rcu_read_lock();
 765	country_ie = ieee80211_bss_get_ie(cr->bss, WLAN_EID_COUNTRY);
 766	if (!country_ie) {
 767		rcu_read_unlock();
 768		return;
 769	}
 770
 771	country_ie = kmemdup(country_ie, 2 + country_ie[1], GFP_ATOMIC);
 772	rcu_read_unlock();
 773
 774	if (!country_ie)
 775		return;
 776
 777	/*
 778	 * ieee80211_bss_get_ie() ensures we can access:
 779	 * - country_ie + 2, the start of the country ie data, and
 780	 * - and country_ie[1] which is the IE length
 781	 */
 782	regulatory_hint_country_ie(wdev->wiphy, cr->bss->channel->band,
 783				   country_ie + 2, country_ie[1]);
 784	kfree(country_ie);
 785}
 786
 787/* Consumes bss object one way or another */
 788void cfg80211_connect_done(struct net_device *dev,
 789			   struct cfg80211_connect_resp_params *params,
 790			   gfp_t gfp)
 791{
 792	struct wireless_dev *wdev = dev->ieee80211_ptr;
 793	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 794	struct cfg80211_event *ev;
 795	unsigned long flags;
 796	u8 *next;
 797
 798	if (params->bss) {
 799		struct cfg80211_internal_bss *ibss = bss_from_pub(params->bss);
 800
 801		if (list_empty(&ibss->list)) {
 802			struct cfg80211_bss *found = NULL, *tmp = params->bss;
 803
 804			found = cfg80211_get_bss(wdev->wiphy, NULL,
 805						 params->bss->bssid,
 806						 wdev->ssid, wdev->ssid_len,
 807						 wdev->conn_bss_type,
 808						 IEEE80211_PRIVACY_ANY);
 809			if (found) {
 810				/* The same BSS is already updated so use it
 811				 * instead, as it has latest info.
 812				 */
 813				params->bss = found;
 814			} else {
 815				/* Update with BSS provided by driver, it will
 816				 * be freshly added and ref cnted, we can free
 817				 * the old one.
 818				 *
 819				 * signal_valid can be false, as we are not
 820				 * expecting the BSS to be found.
 821				 *
 822				 * keep the old timestamp to avoid confusion
 823				 */
 824				cfg80211_bss_update(rdev, ibss, false,
 825						    ibss->ts);
 826			}
 827
 828			cfg80211_put_bss(wdev->wiphy, tmp);
 829		}
 830	}
 831
 832	ev = kzalloc(sizeof(*ev) + (params->bssid ? ETH_ALEN : 0) +
 833		     params->req_ie_len + params->resp_ie_len +
 834		     params->fils.kek_len + params->fils.pmk_len +
 835		     (params->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
 836	if (!ev) {
 837		cfg80211_put_bss(wdev->wiphy, params->bss);
 838		return;
 839	}
 840
 841	ev->type = EVENT_CONNECT_RESULT;
 842	next = ((u8 *)ev) + sizeof(*ev);
 843	if (params->bssid) {
 844		ev->cr.bssid = next;
 845		memcpy((void *)ev->cr.bssid, params->bssid, ETH_ALEN);
 846		next += ETH_ALEN;
 847	}
 848	if (params->req_ie_len) {
 849		ev->cr.req_ie = next;
 850		ev->cr.req_ie_len = params->req_ie_len;
 851		memcpy((void *)ev->cr.req_ie, params->req_ie,
 852		       params->req_ie_len);
 853		next += params->req_ie_len;
 854	}
 855	if (params->resp_ie_len) {
 856		ev->cr.resp_ie = next;
 857		ev->cr.resp_ie_len = params->resp_ie_len;
 858		memcpy((void *)ev->cr.resp_ie, params->resp_ie,
 859		       params->resp_ie_len);
 860		next += params->resp_ie_len;
 861	}
 862	if (params->fils.kek_len) {
 863		ev->cr.fils.kek = next;
 864		ev->cr.fils.kek_len = params->fils.kek_len;
 865		memcpy((void *)ev->cr.fils.kek, params->fils.kek,
 866		       params->fils.kek_len);
 867		next += params->fils.kek_len;
 868	}
 869	if (params->fils.pmk_len) {
 870		ev->cr.fils.pmk = next;
 871		ev->cr.fils.pmk_len = params->fils.pmk_len;
 872		memcpy((void *)ev->cr.fils.pmk, params->fils.pmk,
 873		       params->fils.pmk_len);
 874		next += params->fils.pmk_len;
 875	}
 876	if (params->fils.pmkid) {
 877		ev->cr.fils.pmkid = next;
 878		memcpy((void *)ev->cr.fils.pmkid, params->fils.pmkid,
 879		       WLAN_PMKID_LEN);
 880		next += WLAN_PMKID_LEN;
 881	}
 882	ev->cr.fils.update_erp_next_seq_num = params->fils.update_erp_next_seq_num;
 883	if (params->fils.update_erp_next_seq_num)
 884		ev->cr.fils.erp_next_seq_num = params->fils.erp_next_seq_num;
 885	if (params->bss)
 886		cfg80211_hold_bss(bss_from_pub(params->bss));
 887	ev->cr.bss = params->bss;
 888	ev->cr.status = params->status;
 889	ev->cr.timeout_reason = params->timeout_reason;
 890
 891	spin_lock_irqsave(&wdev->event_lock, flags);
 892	list_add_tail(&ev->list, &wdev->event_list);
 893	spin_unlock_irqrestore(&wdev->event_lock, flags);
 894	queue_work(cfg80211_wq, &rdev->event_work);
 895}
 896EXPORT_SYMBOL(cfg80211_connect_done);
 897
 898/* Consumes bss object one way or another */
 899void __cfg80211_roamed(struct wireless_dev *wdev,
 900		       struct cfg80211_roam_info *info)
 901{
 902#ifdef CONFIG_CFG80211_WEXT
 903	union iwreq_data wrqu;
 904#endif
 905	ASSERT_WDEV_LOCK(wdev);
 906
 907	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
 908		    wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
 909		goto out;
 910
 911	if (WARN_ON(!wdev->current_bss))
 912		goto out;
 913
 914	cfg80211_unhold_bss(wdev->current_bss);
 915	cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
 916	wdev->current_bss = NULL;
 917
 918	if (WARN_ON(!info->bss))
 919		return;
 920
 921	cfg80211_hold_bss(bss_from_pub(info->bss));
 922	wdev->current_bss = bss_from_pub(info->bss);
 923
 924	nl80211_send_roamed(wiphy_to_rdev(wdev->wiphy),
 925			    wdev->netdev, info, GFP_KERNEL);
 926
 927#ifdef CONFIG_CFG80211_WEXT
 928	if (info->req_ie) {
 929		memset(&wrqu, 0, sizeof(wrqu));
 930		wrqu.data.length = info->req_ie_len;
 931		wireless_send_event(wdev->netdev, IWEVASSOCREQIE,
 932				    &wrqu, info->req_ie);
 933	}
 934
 935	if (info->resp_ie) {
 936		memset(&wrqu, 0, sizeof(wrqu));
 937		wrqu.data.length = info->resp_ie_len;
 938		wireless_send_event(wdev->netdev, IWEVASSOCRESPIE,
 939				    &wrqu, info->resp_ie);
 940	}
 941
 942	memset(&wrqu, 0, sizeof(wrqu));
 943	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 944	memcpy(wrqu.ap_addr.sa_data, info->bss->bssid, ETH_ALEN);
 945	memcpy(wdev->wext.prev_bssid, info->bss->bssid, ETH_ALEN);
 946	wdev->wext.prev_bssid_valid = true;
 947	wireless_send_event(wdev->netdev, SIOCGIWAP, &wrqu, NULL);
 948#endif
 949
 950	return;
 951out:
 952	cfg80211_put_bss(wdev->wiphy, info->bss);
 953}
 954
 955/* Consumes info->bss object one way or another */
 956void cfg80211_roamed(struct net_device *dev, struct cfg80211_roam_info *info,
 957		     gfp_t gfp)
 958{
 959	struct wireless_dev *wdev = dev->ieee80211_ptr;
 960	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 961	struct cfg80211_event *ev;
 962	unsigned long flags;
 963	u8 *next;
 964
 965	if (!info->bss) {
 966		info->bss = cfg80211_get_bss(wdev->wiphy, info->channel,
 967					     info->bssid, wdev->ssid,
 968					     wdev->ssid_len,
 969					     wdev->conn_bss_type,
 970					     IEEE80211_PRIVACY_ANY);
 971	}
 972
 973	if (WARN_ON(!info->bss))
 974		return;
 975
 976	ev = kzalloc(sizeof(*ev) + info->req_ie_len + info->resp_ie_len +
 977		     info->fils.kek_len + info->fils.pmk_len +
 978		     (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
 979	if (!ev) {
 980		cfg80211_put_bss(wdev->wiphy, info->bss);
 981		return;
 982	}
 983
 984	ev->type = EVENT_ROAMED;
 985	next = ((u8 *)ev) + sizeof(*ev);
 986	if (info->req_ie_len) {
 987		ev->rm.req_ie = next;
 988		ev->rm.req_ie_len = info->req_ie_len;
 989		memcpy((void *)ev->rm.req_ie, info->req_ie, info->req_ie_len);
 990		next += info->req_ie_len;
 991	}
 992	if (info->resp_ie_len) {
 993		ev->rm.resp_ie = next;
 994		ev->rm.resp_ie_len = info->resp_ie_len;
 995		memcpy((void *)ev->rm.resp_ie, info->resp_ie,
 996		       info->resp_ie_len);
 997		next += info->resp_ie_len;
 998	}
 999	if (info->fils.kek_len) {
1000		ev->rm.fils.kek = next;
1001		ev->rm.fils.kek_len = info->fils.kek_len;
1002		memcpy((void *)ev->rm.fils.kek, info->fils.kek,
1003		       info->fils.kek_len);
1004		next += info->fils.kek_len;
1005	}
1006	if (info->fils.pmk_len) {
1007		ev->rm.fils.pmk = next;
1008		ev->rm.fils.pmk_len = info->fils.pmk_len;
1009		memcpy((void *)ev->rm.fils.pmk, info->fils.pmk,
1010		       info->fils.pmk_len);
1011		next += info->fils.pmk_len;
1012	}
1013	if (info->fils.pmkid) {
1014		ev->rm.fils.pmkid = next;
1015		memcpy((void *)ev->rm.fils.pmkid, info->fils.pmkid,
1016		       WLAN_PMKID_LEN);
1017		next += WLAN_PMKID_LEN;
1018	}
1019	ev->rm.fils.update_erp_next_seq_num = info->fils.update_erp_next_seq_num;
1020	if (info->fils.update_erp_next_seq_num)
1021		ev->rm.fils.erp_next_seq_num = info->fils.erp_next_seq_num;
1022	ev->rm.bss = info->bss;
1023
1024	spin_lock_irqsave(&wdev->event_lock, flags);
1025	list_add_tail(&ev->list, &wdev->event_list);
1026	spin_unlock_irqrestore(&wdev->event_lock, flags);
1027	queue_work(cfg80211_wq, &rdev->event_work);
1028}
1029EXPORT_SYMBOL(cfg80211_roamed);
1030
1031void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid)
1032{
1033	ASSERT_WDEV_LOCK(wdev);
1034
1035	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
1036		return;
1037
1038	if (WARN_ON(!wdev->current_bss) ||
1039	    WARN_ON(!ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))
1040		return;
1041
1042	nl80211_send_port_authorized(wiphy_to_rdev(wdev->wiphy), wdev->netdev,
1043				     bssid);
1044}
1045
1046void cfg80211_port_authorized(struct net_device *dev, const u8 *bssid,
1047			      gfp_t gfp)
1048{
1049	struct wireless_dev *wdev = dev->ieee80211_ptr;
1050	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1051	struct cfg80211_event *ev;
1052	unsigned long flags;
1053
1054	if (WARN_ON(!bssid))
1055		return;
1056
1057	ev = kzalloc(sizeof(*ev), gfp);
1058	if (!ev)
1059		return;
1060
1061	ev->type = EVENT_PORT_AUTHORIZED;
1062	memcpy(ev->pa.bssid, bssid, ETH_ALEN);
1063
1064	/*
1065	 * Use the wdev event list so that if there are pending
1066	 * connected/roamed events, they will be reported first.
1067	 */
1068	spin_lock_irqsave(&wdev->event_lock, flags);
1069	list_add_tail(&ev->list, &wdev->event_list);
1070	spin_unlock_irqrestore(&wdev->event_lock, flags);
1071	queue_work(cfg80211_wq, &rdev->event_work);
1072}
1073EXPORT_SYMBOL(cfg80211_port_authorized);
1074
1075void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
1076			     size_t ie_len, u16 reason, bool from_ap)
1077{
1078	struct wireless_dev *wdev = dev->ieee80211_ptr;
1079	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1080	int i;
1081#ifdef CONFIG_CFG80211_WEXT
1082	union iwreq_data wrqu;
1083#endif
1084
1085	ASSERT_WDEV_LOCK(wdev);
1086
1087	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
1088		    wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
1089		return;
1090
1091	if (wdev->current_bss) {
1092		cfg80211_unhold_bss(wdev->current_bss);
1093		cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);
1094	}
1095
1096	wdev->current_bss = NULL;
1097	wdev->ssid_len = 0;
1098	wdev->conn_owner_nlportid = 0;
1099	kzfree(wdev->connect_keys);
1100	wdev->connect_keys = NULL;
1101
1102	nl80211_send_disconnected(rdev, dev, reason, ie, ie_len, from_ap);
1103
1104	/* stop critical protocol if supported */
1105	if (rdev->ops->crit_proto_stop && rdev->crit_proto_nlportid) {
1106		rdev->crit_proto_nlportid = 0;
1107		rdev_crit_proto_stop(rdev, wdev);
1108	}
1109
1110	/*
1111	 * Delete all the keys ... pairwise keys can't really
1112	 * exist any more anyway, but default keys might.
1113	 */
1114	if (rdev->ops->del_key) {
1115		int max_key_idx = 5;
1116
1117		if (wiphy_ext_feature_isset(
1118			    wdev->wiphy,
1119			    NL80211_EXT_FEATURE_BEACON_PROTECTION))
1120			max_key_idx = 7;
1121		for (i = 0; i <= max_key_idx; i++)
1122			rdev_del_key(rdev, dev, i, false, NULL);
1123	}
1124
1125	rdev_set_qos_map(rdev, dev, NULL);
1126
1127#ifdef CONFIG_CFG80211_WEXT
1128	memset(&wrqu, 0, sizeof(wrqu));
1129	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1130	wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
1131	wdev->wext.connect.ssid_len = 0;
1132#endif
1133
1134	schedule_work(&cfg80211_disconnect_work);
1135}
1136
1137void cfg80211_disconnected(struct net_device *dev, u16 reason,
1138			   const u8 *ie, size_t ie_len,
1139			   bool locally_generated, gfp_t gfp)
1140{
1141	struct wireless_dev *wdev = dev->ieee80211_ptr;
1142	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1143	struct cfg80211_event *ev;
1144	unsigned long flags;
1145
1146	ev = kzalloc(sizeof(*ev) + ie_len, gfp);
1147	if (!ev)
1148		return;
1149
1150	ev->type = EVENT_DISCONNECTED;
1151	ev->dc.ie = ((u8 *)ev) + sizeof(*ev);
1152	ev->dc.ie_len = ie_len;
1153	memcpy((void *)ev->dc.ie, ie, ie_len);
1154	ev->dc.reason = reason;
1155	ev->dc.locally_generated = locally_generated;
1156
1157	spin_lock_irqsave(&wdev->event_lock, flags);
1158	list_add_tail(&ev->list, &wdev->event_list);
1159	spin_unlock_irqrestore(&wdev->event_lock, flags);
1160	queue_work(cfg80211_wq, &rdev->event_work);
1161}
1162EXPORT_SYMBOL(cfg80211_disconnected);
1163
1164/*
1165 * API calls for nl80211/wext compatibility code
1166 */
1167int cfg80211_connect(struct cfg80211_registered_device *rdev,
1168		     struct net_device *dev,
1169		     struct cfg80211_connect_params *connect,
1170		     struct cfg80211_cached_keys *connkeys,
1171		     const u8 *prev_bssid)
1172{
1173	struct wireless_dev *wdev = dev->ieee80211_ptr;
1174	int err;
1175
1176	ASSERT_WDEV_LOCK(wdev);
1177
1178	/*
1179	 * If we have an ssid_len, we're trying to connect or are
1180	 * already connected, so reject a new SSID unless it's the
1181	 * same (which is the case for re-association.)
1182	 */
1183	if (wdev->ssid_len &&
1184	    (wdev->ssid_len != connect->ssid_len ||
1185	     memcmp(wdev->ssid, connect->ssid, wdev->ssid_len)))
1186		return -EALREADY;
1187
1188	/*
1189	 * If connected, reject (re-)association unless prev_bssid
1190	 * matches the current BSSID.
1191	 */
1192	if (wdev->current_bss) {
1193		if (!prev_bssid)
1194			return -EALREADY;
1195		if (!ether_addr_equal(prev_bssid, wdev->current_bss->pub.bssid))
1196			return -ENOTCONN;
1197	}
1198
1199	/*
1200	 * Reject if we're in the process of connecting with WEP,
1201	 * this case isn't very interesting and trying to handle
1202	 * it would make the code much more complex.
1203	 */
1204	if (wdev->connect_keys)
1205		return -EINPROGRESS;
1206
1207	cfg80211_oper_and_ht_capa(&connect->ht_capa_mask,
1208				  rdev->wiphy.ht_capa_mod_mask);
1209	cfg80211_oper_and_vht_capa(&connect->vht_capa_mask,
1210				   rdev->wiphy.vht_capa_mod_mask);
1211
1212	if (connkeys && connkeys->def >= 0) {
1213		int idx;
1214		u32 cipher;
1215
1216		idx = connkeys->def;
1217		cipher = connkeys->params[idx].cipher;
1218		/* If given a WEP key we may need it for shared key auth */
1219		if (cipher == WLAN_CIPHER_SUITE_WEP40 ||
1220		    cipher == WLAN_CIPHER_SUITE_WEP104) {
1221			connect->key_idx = idx;
1222			connect->key = connkeys->params[idx].key;
1223			connect->key_len = connkeys->params[idx].key_len;
1224
1225			/*
1226			 * If ciphers are not set (e.g. when going through
1227			 * iwconfig), we have to set them appropriately here.
1228			 */
1229			if (connect->crypto.cipher_group == 0)
1230				connect->crypto.cipher_group = cipher;
1231
1232			if (connect->crypto.n_ciphers_pairwise == 0) {
1233				connect->crypto.n_ciphers_pairwise = 1;
1234				connect->crypto.ciphers_pairwise[0] = cipher;
1235			}
1236		}
1237
1238		connect->crypto.wep_keys = connkeys->params;
1239		connect->crypto.wep_tx_key = connkeys->def;
1240	} else {
1241		if (WARN_ON(connkeys))
1242			return -EINVAL;
1243	}
1244
1245	wdev->connect_keys = connkeys;
1246	memcpy(wdev->ssid, connect->ssid, connect->ssid_len);
1247	wdev->ssid_len = connect->ssid_len;
1248
1249	wdev->conn_bss_type = connect->pbss ? IEEE80211_BSS_TYPE_PBSS :
1250					      IEEE80211_BSS_TYPE_ESS;
1251
1252	if (!rdev->ops->connect)
1253		err = cfg80211_sme_connect(wdev, connect, prev_bssid);
1254	else
1255		err = rdev_connect(rdev, dev, connect);
1256
1257	if (err) {
1258		wdev->connect_keys = NULL;
1259		/*
1260		 * This could be reassoc getting refused, don't clear
1261		 * ssid_len in that case.
1262		 */
1263		if (!wdev->current_bss)
1264			wdev->ssid_len = 0;
1265		return err;
1266	}
1267
1268	return 0;
1269}
1270
1271int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
1272			struct net_device *dev, u16 reason, bool wextev)
1273{
1274	struct wireless_dev *wdev = dev->ieee80211_ptr;
1275	int err = 0;
1276
1277	ASSERT_WDEV_LOCK(wdev);
1278
1279	kzfree(wdev->connect_keys);
1280	wdev->connect_keys = NULL;
1281
1282	wdev->conn_owner_nlportid = 0;
1283
1284	if (wdev->conn)
1285		err = cfg80211_sme_disconnect(wdev, reason);
1286	else if (!rdev->ops->disconnect)
1287		cfg80211_mlme_down(rdev, dev);
1288	else if (wdev->ssid_len)
1289		err = rdev_disconnect(rdev, dev, reason);
1290
1291	/*
1292	 * Clear ssid_len unless we actually were fully connected,
1293	 * in which case cfg80211_disconnected() will take care of
1294	 * this later.
1295	 */
1296	if (!wdev->current_bss)
1297		wdev->ssid_len = 0;
1298
1299	return err;
1300}
1301
1302/*
1303 * Used to clean up after the connection / connection attempt owner socket
1304 * disconnects
1305 */
1306void cfg80211_autodisconnect_wk(struct work_struct *work)
1307{
1308	struct wireless_dev *wdev =
1309		container_of(work, struct wireless_dev, disconnect_wk);
1310	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
1311
1312	wdev_lock(wdev);
1313
1314	if (wdev->conn_owner_nlportid) {
1315		switch (wdev->iftype) {
1316		case NL80211_IFTYPE_ADHOC:
1317			__cfg80211_leave_ibss(rdev, wdev->netdev, false);
1318			break;
1319		case NL80211_IFTYPE_AP:
1320		case NL80211_IFTYPE_P2P_GO:
1321			__cfg80211_stop_ap(rdev, wdev->netdev, false);
1322			break;
1323		case NL80211_IFTYPE_MESH_POINT:
1324			__cfg80211_leave_mesh(rdev, wdev->netdev);
1325			break;
1326		case NL80211_IFTYPE_STATION:
1327		case NL80211_IFTYPE_P2P_CLIENT:
1328			/*
1329			 * Use disconnect_bssid if still connecting and
1330			 * ops->disconnect not implemented.  Otherwise we can
1331			 * use cfg80211_disconnect.
1332			 */
1333			if (rdev->ops->disconnect || wdev->current_bss)
1334				cfg80211_disconnect(rdev, wdev->netdev,
1335						    WLAN_REASON_DEAUTH_LEAVING,
1336						    true);
1337			else
1338				cfg80211_mlme_deauth(rdev, wdev->netdev,
1339						     wdev->disconnect_bssid,
1340						     NULL, 0,
1341						     WLAN_REASON_DEAUTH_LEAVING,
1342						     false);
1343			break;
1344		default:
1345			break;
1346		}
1347	}
1348
1349	wdev_unlock(wdev);
1350}