1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * IBSS mode implementation
   4 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
   5 * Copyright 2004, Instant802 Networks, Inc.
   6 * Copyright 2005, Devicescape Software, Inc.
   7 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
   8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
   9 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
  10 * Copyright 2013-2014  Intel Mobile Communications GmbH
  11 * Copyright(c) 2016 Intel Deutschland GmbH
  12 * Copyright(c) 2018-2020 Intel Corporation
 
 
 
  13 */
  14
  15#include <linux/delay.h>
  16#include <linux/slab.h>
  17#include <linux/if_ether.h>
  18#include <linux/skbuff.h>
  19#include <linux/if_arp.h>
  20#include <linux/etherdevice.h>
  21#include <linux/rtnetlink.h>
  22#include <net/mac80211.h>
  23
  24#include "ieee80211_i.h"
  25#include "driver-ops.h"
  26#include "rate.h"
  27
  28#define IEEE80211_SCAN_INTERVAL (2 * HZ)
  29#define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
  30
  31#define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
  32#define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
  33#define IEEE80211_IBSS_RSN_INACTIVITY_LIMIT (10 * HZ)
  34
  35#define IEEE80211_IBSS_MAX_STA_ENTRIES 128
  36
  37static struct beacon_data *
  38ieee80211_ibss_build_presp(struct ieee80211_sub_if_data *sdata,
  39			   const int beacon_int, const u32 basic_rates,
  40			   const u16 capability, u64 tsf,
  41			   struct cfg80211_chan_def *chandef,
  42			   bool *have_higher_than_11mbit,
  43			   struct cfg80211_csa_settings *csa_settings)
  44{
  45	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
  46	struct ieee80211_local *local = sdata->local;
  47	int rates_n = 0, i, ri;
  48	struct ieee80211_mgmt *mgmt;
  49	u8 *pos;
  50	struct ieee80211_supported_band *sband;
  51	u32 rate_flags, rates = 0, rates_added = 0;
  52	struct beacon_data *presp;
  53	int frame_len;
  54	int shift;
  55
  56	/* Build IBSS probe response */
  57	frame_len = sizeof(struct ieee80211_hdr_3addr) +
  58		    12 /* struct ieee80211_mgmt.u.beacon */ +
  59		    2 + IEEE80211_MAX_SSID_LEN /* max SSID */ +
  60		    2 + 8 /* max Supported Rates */ +
  61		    3 /* max DS params */ +
  62		    4 /* IBSS params */ +
  63		    5 /* Channel Switch Announcement */ +
  64		    2 + (IEEE80211_MAX_SUPP_RATES - 8) +
  65		    2 + sizeof(struct ieee80211_ht_cap) +
  66		    2 + sizeof(struct ieee80211_ht_operation) +
  67		    2 + sizeof(struct ieee80211_vht_cap) +
  68		    2 + sizeof(struct ieee80211_vht_operation) +
  69		    ifibss->ie_len;
  70	presp = kzalloc(sizeof(*presp) + frame_len, GFP_KERNEL);
  71	if (!presp)
  72		return NULL;
  73
  74	presp->head = (void *)(presp + 1);
  75
  76	mgmt = (void *) presp->head;
  77	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  78					  IEEE80211_STYPE_PROBE_RESP);
  79	eth_broadcast_addr(mgmt->da);
  80	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
  81	memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
  82	mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_int);
  83	mgmt->u.beacon.timestamp = cpu_to_le64(tsf);
  84	mgmt->u.beacon.capab_info = cpu_to_le16(capability);
  85
  86	pos = (u8 *)mgmt + offsetof(struct ieee80211_mgmt, u.beacon.variable);
  87
  88	*pos++ = WLAN_EID_SSID;
  89	*pos++ = ifibss->ssid_len;
  90	memcpy(pos, ifibss->ssid, ifibss->ssid_len);
  91	pos += ifibss->ssid_len;
  92
  93	sband = local->hw.wiphy->bands[chandef->chan->band];
  94	rate_flags = ieee80211_chandef_rate_flags(chandef);
  95	shift = ieee80211_chandef_get_shift(chandef);
  96	rates_n = 0;
  97	if (have_higher_than_11mbit)
  98		*have_higher_than_11mbit = false;
  99
 100	for (i = 0; i < sband->n_bitrates; i++) {
 101		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
 102			continue;
 103		if (sband->bitrates[i].bitrate > 110 &&
 104		    have_higher_than_11mbit)
 105			*have_higher_than_11mbit = true;
 106
 107		rates |= BIT(i);
 108		rates_n++;
 109	}
 110
 111	*pos++ = WLAN_EID_SUPP_RATES;
 112	*pos++ = min_t(int, 8, rates_n);
 113	for (ri = 0; ri < sband->n_bitrates; ri++) {
 114		int rate = DIV_ROUND_UP(sband->bitrates[ri].bitrate,
 115					5 * (1 << shift));
 116		u8 basic = 0;
 117		if (!(rates & BIT(ri)))
 118			continue;
 119
 120		if (basic_rates & BIT(ri))
 121			basic = 0x80;
 122		*pos++ = basic | (u8) rate;
 123		if (++rates_added == 8) {
 124			ri++; /* continue at next rate for EXT_SUPP_RATES */
 125			break;
 126		}
 127	}
 128
 129	if (sband->band == NL80211_BAND_2GHZ) {
 130		*pos++ = WLAN_EID_DS_PARAMS;
 131		*pos++ = 1;
 132		*pos++ = ieee80211_frequency_to_channel(
 133				chandef->chan->center_freq);
 134	}
 135
 136	*pos++ = WLAN_EID_IBSS_PARAMS;
 137	*pos++ = 2;
 138	/* FIX: set ATIM window based on scan results */
 139	*pos++ = 0;
 140	*pos++ = 0;
 141
 142	if (csa_settings) {
 143		*pos++ = WLAN_EID_CHANNEL_SWITCH;
 144		*pos++ = 3;
 145		*pos++ = csa_settings->block_tx ? 1 : 0;
 146		*pos++ = ieee80211_frequency_to_channel(
 147				csa_settings->chandef.chan->center_freq);
 148		presp->cntdwn_counter_offsets[0] = (pos - presp->head);
 149		*pos++ = csa_settings->count;
 150		presp->cntdwn_current_counter = csa_settings->count;
 151	}
 152
 153	/* put the remaining rates in WLAN_EID_EXT_SUPP_RATES */
 154	if (rates_n > 8) {
 155		*pos++ = WLAN_EID_EXT_SUPP_RATES;
 156		*pos++ = rates_n - 8;
 157		for (; ri < sband->n_bitrates; ri++) {
 158			int rate = DIV_ROUND_UP(sband->bitrates[ri].bitrate,
 159						5 * (1 << shift));
 160			u8 basic = 0;
 161			if (!(rates & BIT(ri)))
 162				continue;
 163
 164			if (basic_rates & BIT(ri))
 165				basic = 0x80;
 166			*pos++ = basic | (u8) rate;
 167		}
 168	}
 169
 170	if (ifibss->ie_len) {
 171		memcpy(pos, ifibss->ie, ifibss->ie_len);
 172		pos += ifibss->ie_len;
 173	}
 174
 175	/* add HT capability and information IEs */
 176	if (chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
 177	    chandef->width != NL80211_CHAN_WIDTH_5 &&
 178	    chandef->width != NL80211_CHAN_WIDTH_10 &&
 179	    sband->ht_cap.ht_supported) {
 180		struct ieee80211_sta_ht_cap ht_cap;
 181
 182		memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
 183		ieee80211_apply_htcap_overrides(sdata, &ht_cap);
 184
 185		pos = ieee80211_ie_build_ht_cap(pos, &ht_cap, ht_cap.cap);
 186		/*
 187		 * Note: According to 802.11n-2009 9.13.3.1, HT Protection
 188		 * field and RIFS Mode are reserved in IBSS mode, therefore
 189		 * keep them at 0
 190		 */
 191		pos = ieee80211_ie_build_ht_oper(pos, &sband->ht_cap,
 192						 chandef, 0, false);
 193
 194		/* add VHT capability and information IEs */
 195		if (chandef->width != NL80211_CHAN_WIDTH_20 &&
 196		    chandef->width != NL80211_CHAN_WIDTH_40 &&
 197		    sband->vht_cap.vht_supported) {
 198			pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
 199							 sband->vht_cap.cap);
 200			pos = ieee80211_ie_build_vht_oper(pos, &sband->vht_cap,
 201							  chandef);
 202		}
 203	}
 204
 205	if (local->hw.queues >= IEEE80211_NUM_ACS)
 206		pos = ieee80211_add_wmm_info_ie(pos, 0); /* U-APSD not in use */
 207
 208	presp->head_len = pos - presp->head;
 209	if (WARN_ON(presp->head_len > frame_len))
 210		goto error;
 211
 212	return presp;
 213error:
 214	kfree(presp);
 215	return NULL;
 216}
 217
 218static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
 219				      const u8 *bssid, const int beacon_int,
 220				      struct cfg80211_chan_def *req_chandef,
 221				      const u32 basic_rates,
 222				      const u16 capability, u64 tsf,
 223				      bool creator)
 224{
 225	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 226	struct ieee80211_local *local = sdata->local;
 227	struct ieee80211_mgmt *mgmt;
 228	struct cfg80211_bss *bss;
 229	u32 bss_change;
 230	struct cfg80211_chan_def chandef;
 231	struct ieee80211_channel *chan;
 232	struct beacon_data *presp;
 233	struct cfg80211_inform_bss bss_meta = {};
 234	bool have_higher_than_11mbit;
 235	bool radar_required;
 236	int err;
 237
 238	sdata_assert_lock(sdata);
 239
 240	/* Reset own TSF to allow time synchronization work. */
 241	drv_reset_tsf(local, sdata);
 242
 243	if (!ether_addr_equal(ifibss->bssid, bssid))
 244		sta_info_flush(sdata);
 245
 246	/* if merging, indicate to driver that we leave the old IBSS */
 247	if (sdata->vif.bss_conf.ibss_joined) {
 248		sdata->vif.bss_conf.ibss_joined = false;
 249		sdata->vif.bss_conf.ibss_creator = false;
 250		sdata->vif.bss_conf.enable_beacon = false;
 251		netif_carrier_off(sdata->dev);
 252		ieee80211_bss_info_change_notify(sdata,
 253						 BSS_CHANGED_IBSS |
 254						 BSS_CHANGED_BEACON_ENABLED);
 255		drv_leave_ibss(local, sdata);
 256	}
 257
 258	presp = rcu_dereference_protected(ifibss->presp,
 259					  lockdep_is_held(&sdata->wdev.mtx));
 260	RCU_INIT_POINTER(ifibss->presp, NULL);
 261	if (presp)
 262		kfree_rcu(presp, rcu_head);
 263
 264	/* make a copy of the chandef, it could be modified below. */
 265	chandef = *req_chandef;
 266	chan = chandef.chan;
 267	if (!cfg80211_reg_can_beacon(local->hw.wiphy, &chandef,
 268				     NL80211_IFTYPE_ADHOC)) {
 269		if (chandef.width == NL80211_CHAN_WIDTH_5 ||
 270		    chandef.width == NL80211_CHAN_WIDTH_10 ||
 271		    chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
 272		    chandef.width == NL80211_CHAN_WIDTH_20) {
 273			sdata_info(sdata,
 274				   "Failed to join IBSS, beacons forbidden\n");
 275			return;
 276		}
 277		chandef.width = NL80211_CHAN_WIDTH_20;
 278		chandef.center_freq1 = chan->center_freq;
 279		/* check again for downgraded chandef */
 280		if (!cfg80211_reg_can_beacon(local->hw.wiphy, &chandef,
 281					     NL80211_IFTYPE_ADHOC)) {
 282			sdata_info(sdata,
 283				   "Failed to join IBSS, beacons forbidden\n");
 284			return;
 285		}
 286	}
 287
 288	err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
 289					    &chandef, NL80211_IFTYPE_ADHOC);
 290	if (err < 0) {
 291		sdata_info(sdata,
 292			   "Failed to join IBSS, invalid chandef\n");
 293		return;
 294	}
 295	if (err > 0 && !ifibss->userspace_handles_dfs) {
 296		sdata_info(sdata,
 297			   "Failed to join IBSS, DFS channel without control program\n");
 298		return;
 299	}
 300
 301	radar_required = err;
 302
 303	mutex_lock(&local->mtx);
 304	if (ieee80211_vif_use_channel(sdata, &chandef,
 305				      ifibss->fixed_channel ?
 306					IEEE80211_CHANCTX_SHARED :
 307					IEEE80211_CHANCTX_EXCLUSIVE)) {
 308		sdata_info(sdata, "Failed to join IBSS, no channel context\n");
 309		mutex_unlock(&local->mtx);
 310		return;
 311	}
 312	sdata->radar_required = radar_required;
 313	mutex_unlock(&local->mtx);
 314
 315	memcpy(ifibss->bssid, bssid, ETH_ALEN);
 316
 317	presp = ieee80211_ibss_build_presp(sdata, beacon_int, basic_rates,
 318					   capability, tsf, &chandef,
 319					   &have_higher_than_11mbit, NULL);
 320	if (!presp)
 321		return;
 322
 323	rcu_assign_pointer(ifibss->presp, presp);
 324	mgmt = (void *)presp->head;
 325
 326	sdata->vif.bss_conf.enable_beacon = true;
 327	sdata->vif.bss_conf.beacon_int = beacon_int;
 328	sdata->vif.bss_conf.basic_rates = basic_rates;
 329	sdata->vif.bss_conf.ssid_len = ifibss->ssid_len;
 330	memcpy(sdata->vif.bss_conf.ssid, ifibss->ssid, ifibss->ssid_len);
 331	bss_change = BSS_CHANGED_BEACON_INT;
 332	bss_change |= ieee80211_reset_erp_info(sdata);
 333	bss_change |= BSS_CHANGED_BSSID;
 334	bss_change |= BSS_CHANGED_BEACON;
 335	bss_change |= BSS_CHANGED_BEACON_ENABLED;
 336	bss_change |= BSS_CHANGED_BASIC_RATES;
 337	bss_change |= BSS_CHANGED_HT;
 338	bss_change |= BSS_CHANGED_IBSS;
 339	bss_change |= BSS_CHANGED_SSID;
 340
 341	/*
 342	 * In 5 GHz/802.11a, we can always use short slot time.
 343	 * (IEEE 802.11-2012 18.3.8.7)
 344	 *
 345	 * In 2.4GHz, we must always use long slots in IBSS for compatibility
 346	 * reasons.
 347	 * (IEEE 802.11-2012 19.4.5)
 348	 *
 349	 * HT follows these specifications (IEEE 802.11-2012 20.3.18)
 350	 */
 351	sdata->vif.bss_conf.use_short_slot = chan->band == NL80211_BAND_5GHZ;
 352	bss_change |= BSS_CHANGED_ERP_SLOT;
 353
 354	/* cf. IEEE 802.11 9.2.12 */
 355	if (chan->band == NL80211_BAND_2GHZ && have_higher_than_11mbit)
 356		sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
 357	else
 358		sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
 359
 360	ieee80211_set_wmm_default(sdata, true, false);
 361
 362	sdata->vif.bss_conf.ibss_joined = true;
 363	sdata->vif.bss_conf.ibss_creator = creator;
 364
 365	err = drv_join_ibss(local, sdata);
 366	if (err) {
 367		sdata->vif.bss_conf.ibss_joined = false;
 368		sdata->vif.bss_conf.ibss_creator = false;
 369		sdata->vif.bss_conf.enable_beacon = false;
 370		sdata->vif.bss_conf.ssid_len = 0;
 371		RCU_INIT_POINTER(ifibss->presp, NULL);
 372		kfree_rcu(presp, rcu_head);
 373		mutex_lock(&local->mtx);
 374		ieee80211_vif_release_channel(sdata);
 375		mutex_unlock(&local->mtx);
 376		sdata_info(sdata, "Failed to join IBSS, driver failure: %d\n",
 377			   err);
 378		return;
 379	}
 380
 381	ieee80211_bss_info_change_notify(sdata, bss_change);
 382
 383	ifibss->state = IEEE80211_IBSS_MLME_JOINED;
 384	mod_timer(&ifibss->timer,
 385		  round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
 386
 387	bss_meta.chan = chan;
 388	bss_meta.scan_width = cfg80211_chandef_to_scan_width(&chandef);
 389	bss = cfg80211_inform_bss_frame_data(local->hw.wiphy, &bss_meta, mgmt,
 390					     presp->head_len, GFP_KERNEL);
 391
 392	cfg80211_put_bss(local->hw.wiphy, bss);
 393	netif_carrier_on(sdata->dev);
 394	cfg80211_ibss_joined(sdata->dev, ifibss->bssid, chan, GFP_KERNEL);
 395}
 396
 397static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
 398				    struct ieee80211_bss *bss)
 399{
 400	struct cfg80211_bss *cbss =
 401		container_of((void *)bss, struct cfg80211_bss, priv);
 402	struct ieee80211_supported_band *sband;
 403	struct cfg80211_chan_def chandef;
 404	u32 basic_rates;
 405	int i, j;
 406	u16 beacon_int = cbss->beacon_interval;
 407	const struct cfg80211_bss_ies *ies;
 408	enum nl80211_channel_type chan_type;
 409	u64 tsf;
 410	u32 rate_flags;
 411	int shift;
 412
 413	sdata_assert_lock(sdata);
 414
 415	if (beacon_int < 10)
 416		beacon_int = 10;
 417
 418	switch (sdata->u.ibss.chandef.width) {
 419	case NL80211_CHAN_WIDTH_20_NOHT:
 420	case NL80211_CHAN_WIDTH_20:
 421	case NL80211_CHAN_WIDTH_40:
 422		chan_type = cfg80211_get_chandef_type(&sdata->u.ibss.chandef);
 423		cfg80211_chandef_create(&chandef, cbss->channel, chan_type);
 424		break;
 425	case NL80211_CHAN_WIDTH_5:
 426	case NL80211_CHAN_WIDTH_10:
 427		cfg80211_chandef_create(&chandef, cbss->channel,
 428					NL80211_CHAN_NO_HT);
 429		chandef.width = sdata->u.ibss.chandef.width;
 430		break;
 431	case NL80211_CHAN_WIDTH_80:
 432	case NL80211_CHAN_WIDTH_80P80:
 433	case NL80211_CHAN_WIDTH_160:
 434		chandef = sdata->u.ibss.chandef;
 435		chandef.chan = cbss->channel;
 436		break;
 437	default:
 438		/* fall back to 20 MHz for unsupported modes */
 439		cfg80211_chandef_create(&chandef, cbss->channel,
 440					NL80211_CHAN_NO_HT);
 441		break;
 442	}
 443
 444	sband = sdata->local->hw.wiphy->bands[cbss->channel->band];
 445	rate_flags = ieee80211_chandef_rate_flags(&sdata->u.ibss.chandef);
 446	shift = ieee80211_vif_get_shift(&sdata->vif);
 447
 448	basic_rates = 0;
 449
 450	for (i = 0; i < bss->supp_rates_len; i++) {
 451		int rate = bss->supp_rates[i] & 0x7f;
 452		bool is_basic = !!(bss->supp_rates[i] & 0x80);
 453
 454		for (j = 0; j < sband->n_bitrates; j++) {
 455			int brate;
 456			if ((rate_flags & sband->bitrates[j].flags)
 457			    != rate_flags)
 458				continue;
 459
 460			brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
 461					     5 * (1 << shift));
 462			if (brate == rate) {
 463				if (is_basic)
 464					basic_rates |= BIT(j);
 465				break;
 466			}
 467		}
 468	}
 469
 470	rcu_read_lock();
 471	ies = rcu_dereference(cbss->ies);
 472	tsf = ies->tsf;
 473	rcu_read_unlock();
 474
 475	__ieee80211_sta_join_ibss(sdata, cbss->bssid,
 476				  beacon_int,
 477				  &chandef,
 478				  basic_rates,
 479				  cbss->capability,
 480				  tsf, false);
 481}
 482
 483int ieee80211_ibss_csa_beacon(struct ieee80211_sub_if_data *sdata,
 484			      struct cfg80211_csa_settings *csa_settings)
 485{
 486	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 487	struct beacon_data *presp, *old_presp;
 488	struct cfg80211_bss *cbss;
 489	const struct cfg80211_bss_ies *ies;
 490	u16 capability = WLAN_CAPABILITY_IBSS;
 491	u64 tsf;
 492	int ret = 0;
 493
 494	sdata_assert_lock(sdata);
 495
 496	if (ifibss->privacy)
 497		capability |= WLAN_CAPABILITY_PRIVACY;
 498
 499	cbss = cfg80211_get_bss(sdata->local->hw.wiphy, ifibss->chandef.chan,
 500				ifibss->bssid, ifibss->ssid,
 501				ifibss->ssid_len, IEEE80211_BSS_TYPE_IBSS,
 502				IEEE80211_PRIVACY(ifibss->privacy));
 503
 504	if (WARN_ON(!cbss)) {
 505		ret = -EINVAL;
 506		goto out;
 507	}
 508
 509	rcu_read_lock();
 510	ies = rcu_dereference(cbss->ies);
 511	tsf = ies->tsf;
 512	rcu_read_unlock();
 513	cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
 514
 515	old_presp = rcu_dereference_protected(ifibss->presp,
 516					  lockdep_is_held(&sdata->wdev.mtx));
 517
 518	presp = ieee80211_ibss_build_presp(sdata,
 519					   sdata->vif.bss_conf.beacon_int,
 520					   sdata->vif.bss_conf.basic_rates,
 521					   capability, tsf, &ifibss->chandef,
 522					   NULL, csa_settings);
 523	if (!presp) {
 524		ret = -ENOMEM;
 525		goto out;
 526	}
 527
 528	rcu_assign_pointer(ifibss->presp, presp);
 529	if (old_presp)
 530		kfree_rcu(old_presp, rcu_head);
 531
 532	return BSS_CHANGED_BEACON;
 533 out:
 534	return ret;
 535}
 536
 537int ieee80211_ibss_finish_csa(struct ieee80211_sub_if_data *sdata)
 538{
 539	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 540	struct cfg80211_bss *cbss;
 
 541
 542	sdata_assert_lock(sdata);
 543
 544	/* update cfg80211 bss information with the new channel */
 545	if (!is_zero_ether_addr(ifibss->bssid)) {
 546		cbss = cfg80211_get_bss(sdata->local->hw.wiphy,
 547					ifibss->chandef.chan,
 548					ifibss->bssid, ifibss->ssid,
 549					ifibss->ssid_len,
 550					IEEE80211_BSS_TYPE_IBSS,
 551					IEEE80211_PRIVACY(ifibss->privacy));
 552		/* XXX: should not really modify cfg80211 data */
 553		if (cbss) {
 554			cbss->channel = sdata->csa_chandef.chan;
 555			cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
 556		}
 557	}
 558
 559	ifibss->chandef = sdata->csa_chandef;
 560
 561	/* generate the beacon */
 562	return ieee80211_ibss_csa_beacon(sdata, NULL);
 
 
 
 
 
 
 563}
 564
 565void ieee80211_ibss_stop(struct ieee80211_sub_if_data *sdata)
 566{
 567	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 568
 569	cancel_work_sync(&ifibss->csa_connection_drop_work);
 570}
 571
 572static struct sta_info *ieee80211_ibss_finish_sta(struct sta_info *sta)
 573	__acquires(RCU)
 574{
 575	struct ieee80211_sub_if_data *sdata = sta->sdata;
 576	u8 addr[ETH_ALEN];
 577
 578	memcpy(addr, sta->sta.addr, ETH_ALEN);
 579
 580	ibss_dbg(sdata, "Adding new IBSS station %pM\n", addr);
 581
 582	sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
 583	sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
 584	/* authorize the station only if the network is not RSN protected. If
 585	 * not wait for the userspace to authorize it */
 586	if (!sta->sdata->u.ibss.control_port)
 587		sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
 588
 589	rate_control_rate_init(sta);
 590
 591	/* If it fails, maybe we raced another insertion? */
 592	if (sta_info_insert_rcu(sta))
 593		return sta_info_get(sdata, addr);
 594	return sta;
 595}
 596
 597static struct sta_info *
 598ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata, const u8 *bssid,
 599		       const u8 *addr, u32 supp_rates)
 600	__acquires(RCU)
 601{
 602	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 603	struct ieee80211_local *local = sdata->local;
 604	struct sta_info *sta;
 605	struct ieee80211_chanctx_conf *chanctx_conf;
 606	struct ieee80211_supported_band *sband;
 607	enum nl80211_bss_scan_width scan_width;
 608	int band;
 609
 610	/*
 611	 * XXX: Consider removing the least recently used entry and
 612	 * 	allow new one to be added.
 613	 */
 614	if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
 615		net_info_ratelimited("%s: No room for a new IBSS STA entry %pM\n",
 616				    sdata->name, addr);
 617		rcu_read_lock();
 618		return NULL;
 619	}
 620
 621	if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH) {
 622		rcu_read_lock();
 623		return NULL;
 624	}
 625
 626	if (!ether_addr_equal(bssid, sdata->u.ibss.bssid)) {
 627		rcu_read_lock();
 628		return NULL;
 629	}
 630
 631	rcu_read_lock();
 632	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
 633	if (WARN_ON_ONCE(!chanctx_conf))
 634		return NULL;
 635	band = chanctx_conf->def.chan->band;
 636	scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
 637	rcu_read_unlock();
 638
 639	sta = sta_info_alloc(sdata, addr, GFP_KERNEL);
 640	if (!sta) {
 641		rcu_read_lock();
 642		return NULL;
 643	}
 644
 
 
 645	/* make sure mandatory rates are always added */
 646	sband = local->hw.wiphy->bands[band];
 647	sta->sta.supp_rates[band] = supp_rates |
 648			ieee80211_mandatory_rates(sband, scan_width);
 649
 650	return ieee80211_ibss_finish_sta(sta);
 651}
 652
 653static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
 654{
 655	struct ieee80211_local *local = sdata->local;
 656	int active = 0;
 657	struct sta_info *sta;
 658
 659	sdata_assert_lock(sdata);
 660
 661	rcu_read_lock();
 662
 663	list_for_each_entry_rcu(sta, &local->sta_list, list) {
 664		unsigned long last_active = ieee80211_sta_last_active(sta);
 665
 666		if (sta->sdata == sdata &&
 667		    time_is_after_jiffies(last_active +
 668					  IEEE80211_IBSS_MERGE_INTERVAL)) {
 
 669			active++;
 670			break;
 671		}
 672	}
 673
 674	rcu_read_unlock();
 675
 676	return active;
 677}
 678
 679static void ieee80211_ibss_disconnect(struct ieee80211_sub_if_data *sdata)
 680{
 681	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 682	struct ieee80211_local *local = sdata->local;
 683	struct cfg80211_bss *cbss;
 684	struct beacon_data *presp;
 685	struct sta_info *sta;
 686
 687	if (!is_zero_ether_addr(ifibss->bssid)) {
 688		cbss = cfg80211_get_bss(local->hw.wiphy, ifibss->chandef.chan,
 689					ifibss->bssid, ifibss->ssid,
 690					ifibss->ssid_len,
 691					IEEE80211_BSS_TYPE_IBSS,
 692					IEEE80211_PRIVACY(ifibss->privacy));
 693
 694		if (cbss) {
 695			cfg80211_unlink_bss(local->hw.wiphy, cbss);
 696			cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
 697		}
 698	}
 699
 700	ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
 701
 702	sta_info_flush(sdata);
 703
 704	spin_lock_bh(&ifibss->incomplete_lock);
 705	while (!list_empty(&ifibss->incomplete_stations)) {
 706		sta = list_first_entry(&ifibss->incomplete_stations,
 707				       struct sta_info, list);
 708		list_del(&sta->list);
 709		spin_unlock_bh(&ifibss->incomplete_lock);
 710
 711		sta_info_free(local, sta);
 712		spin_lock_bh(&ifibss->incomplete_lock);
 713	}
 714	spin_unlock_bh(&ifibss->incomplete_lock);
 715
 716	netif_carrier_off(sdata->dev);
 717
 718	sdata->vif.bss_conf.ibss_joined = false;
 719	sdata->vif.bss_conf.ibss_creator = false;
 720	sdata->vif.bss_conf.enable_beacon = false;
 721	sdata->vif.bss_conf.ssid_len = 0;
 722
 723	/* remove beacon */
 724	presp = rcu_dereference_protected(ifibss->presp,
 725					  lockdep_is_held(&sdata->wdev.mtx));
 726	RCU_INIT_POINTER(sdata->u.ibss.presp, NULL);
 727	if (presp)
 728		kfree_rcu(presp, rcu_head);
 729
 730	clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
 731	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
 732						BSS_CHANGED_IBSS);
 733	drv_leave_ibss(local, sdata);
 734	mutex_lock(&local->mtx);
 735	ieee80211_vif_release_channel(sdata);
 736	mutex_unlock(&local->mtx);
 737}
 738
 739static void ieee80211_csa_connection_drop_work(struct work_struct *work)
 740{
 741	struct ieee80211_sub_if_data *sdata =
 742		container_of(work, struct ieee80211_sub_if_data,
 743			     u.ibss.csa_connection_drop_work);
 744
 745	sdata_lock(sdata);
 746
 747	ieee80211_ibss_disconnect(sdata);
 748	synchronize_rcu();
 749	skb_queue_purge(&sdata->skb_queue);
 750
 751	/* trigger a scan to find another IBSS network to join */
 752	ieee80211_queue_work(&sdata->local->hw, &sdata->work);
 753
 754	sdata_unlock(sdata);
 755}
 756
 757static void ieee80211_ibss_csa_mark_radar(struct ieee80211_sub_if_data *sdata)
 758{
 759	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 760	int err;
 761
 762	/* if the current channel is a DFS channel, mark the channel as
 763	 * unavailable.
 764	 */
 765	err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
 766					    &ifibss->chandef,
 767					    NL80211_IFTYPE_ADHOC);
 768	if (err > 0)
 769		cfg80211_radar_event(sdata->local->hw.wiphy, &ifibss->chandef,
 770				     GFP_ATOMIC);
 771}
 772
 773static bool
 774ieee80211_ibss_process_chanswitch(struct ieee80211_sub_if_data *sdata,
 775				  struct ieee802_11_elems *elems,
 776				  bool beacon)
 777{
 778	struct cfg80211_csa_settings params;
 779	struct ieee80211_csa_ie csa_ie;
 780	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
 781	enum nl80211_channel_type ch_type;
 782	int err;
 783	u32 sta_flags;
 784	u32 vht_cap_info = 0;
 785
 786	sdata_assert_lock(sdata);
 787
 788	sta_flags = IEEE80211_STA_DISABLE_VHT;
 789	switch (ifibss->chandef.width) {
 790	case NL80211_CHAN_WIDTH_5:
 791	case NL80211_CHAN_WIDTH_10:
 792	case NL80211_CHAN_WIDTH_20_NOHT:
 793		sta_flags |= IEEE80211_STA_DISABLE_HT;
 794		fallthrough;
 795	case NL80211_CHAN_WIDTH_20:
 796		sta_flags |= IEEE80211_STA_DISABLE_40MHZ;
 797		break;
 798	default:
 799		break;
 800	}
 801
 802	if (elems->vht_cap_elem)
 803		vht_cap_info = le32_to_cpu(elems->vht_cap_elem->vht_cap_info);
 804
 805	memset(&params, 0, sizeof(params));
 
 806	err = ieee80211_parse_ch_switch_ie(sdata, elems,
 807					   ifibss->chandef.chan->band,
 808					   vht_cap_info,
 809					   sta_flags, ifibss->bssid, &csa_ie);
 810	/* can't switch to destination channel, fail */
 811	if (err < 0)
 812		goto disconnect;
 813
 814	/* did not contain a CSA */
 815	if (err)
 816		return false;
 817
 818	/* channel switch is not supported, disconnect */
 819	if (!(sdata->local->hw.wiphy->flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
 820		goto disconnect;
 821
 822	params.count = csa_ie.count;
 823	params.chandef = csa_ie.chandef;
 824
 825	switch (ifibss->chandef.width) {
 826	case NL80211_CHAN_WIDTH_20_NOHT:
 827	case NL80211_CHAN_WIDTH_20:
 828	case NL80211_CHAN_WIDTH_40:
 829		/* keep our current HT mode (HT20/HT40+/HT40-), even if
 830		 * another mode  has been announced. The mode is not adopted
 831		 * within the beacon while doing CSA and we should therefore
 832		 * keep the mode which we announce.
 833		 */
 834		ch_type = cfg80211_get_chandef_type(&ifibss->chandef);
 835		cfg80211_chandef_create(&params.chandef, params.chandef.chan,
 836					ch_type);
 837		break;
 838	case NL80211_CHAN_WIDTH_5:
 839	case NL80211_CHAN_WIDTH_10:
 840		if (params.chandef.width != ifibss->chandef.width) {
 841			sdata_info(sdata,
 842				   "IBSS %pM received channel switch from incompatible channel width (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n",
 843				   ifibss->bssid,
 844				   params.chandef.chan->center_freq,
 845				   params.chandef.width,
 846				   params.chandef.center_freq1,
 847				   params.chandef.center_freq2);
 848			goto disconnect;
 849		}
 850		break;
 851	default:
 852		/* should not happen, sta_flags should prevent VHT modes. */
 853		WARN_ON(1);
 854		goto disconnect;
 855	}
 856
 857	if (!cfg80211_reg_can_beacon(sdata->local->hw.wiphy, &params.chandef,
 858				     NL80211_IFTYPE_ADHOC)) {
 859		sdata_info(sdata,
 860			   "IBSS %pM switches to unsupported channel (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n",
 861			   ifibss->bssid,
 862			   params.chandef.chan->center_freq,
 863			   params.chandef.width,
 864			   params.chandef.center_freq1,
 865			   params.chandef.center_freq2);
 866		goto disconnect;
 867	}
 868
 869	err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
 870					    &params.chandef,
 871					    NL80211_IFTYPE_ADHOC);
 872	if (err < 0)
 873		goto disconnect;
 874	if (err > 0 && !ifibss->userspace_handles_dfs) {
 875		/* IBSS-DFS only allowed with a control program */
 876		goto disconnect;
 877	}
 878
 879	params.radar_required = err;
 880
 881	if (cfg80211_chandef_identical(&params.chandef,
 882				       &sdata->vif.bss_conf.chandef)) {
 883		ibss_dbg(sdata,
 884			 "received csa with an identical chandef, ignoring\n");
 885		return true;
 886	}
 887
 888	/* all checks done, now perform the channel switch. */
 889	ibss_dbg(sdata,
 890		 "received channel switch announcement to go to channel %d MHz\n",
 891		 params.chandef.chan->center_freq);
 892
 893	params.block_tx = !!csa_ie.mode;
 894
 895	if (ieee80211_channel_switch(sdata->local->hw.wiphy, sdata->dev,
 896				     &params))
 897		goto disconnect;
 898
 899	ieee80211_ibss_csa_mark_radar(sdata);
 900
 901	return true;
 902disconnect:
 903	ibss_dbg(sdata, "Can't handle channel switch, disconnect\n");
 904	ieee80211_queue_work(&sdata->local->hw,
 905			     &ifibss->csa_connection_drop_work);
 906
 907	ieee80211_ibss_csa_mark_radar(sdata);
 908
 909	return true;
 910}
 911
 912static void
 913ieee80211_rx_mgmt_spectrum_mgmt(struct ieee80211_sub_if_data *sdata,
 914				struct ieee80211_mgmt *mgmt, size_t len,
 915				struct ieee80211_rx_status *rx_status,
 916				struct ieee802_11_elems *elems)
 917{
 918	int required_len;
 919
 920	if (len < IEEE80211_MIN_ACTION_SIZE + 1)
 921		return;
 922
 923	/* CSA is the only action we handle for now */
 924	if (mgmt->u.action.u.measurement.action_code !=
 925	    WLAN_ACTION_SPCT_CHL_SWITCH)
 926		return;
 927
 928	required_len = IEEE80211_MIN_ACTION_SIZE +
 929		       sizeof(mgmt->u.action.u.chan_switch);
 930	if (len < required_len)
 931		return;
 932
 933	if (!sdata->vif.csa_active)
 934		ieee80211_ibss_process_chanswitch(sdata, elems, false);
 935}
 936
 937static void ieee80211_rx_mgmt_deauth_ibss(struct ieee80211_sub_if_data *sdata,
 938					  struct ieee80211_mgmt *mgmt,
 939					  size_t len)
 940{
 941	u16 reason = le16_to_cpu(mgmt->u.deauth.reason_code);
 942
 943	if (len < IEEE80211_DEAUTH_FRAME_LEN)
 944		return;
 945
 946	ibss_dbg(sdata, "RX DeAuth SA=%pM DA=%pM\n", mgmt->sa, mgmt->da);
 947	ibss_dbg(sdata, "\tBSSID=%pM (reason: %d)\n", mgmt->bssid, reason);
 948	sta_info_destroy_addr(sdata, mgmt->sa);
 949}
 950
 951static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
 952					struct ieee80211_mgmt *mgmt,
 953					size_t len)
 954{
 955	u16 auth_alg, auth_transaction;
 956
 957	sdata_assert_lock(sdata);
 958
 959	if (len < 24 + 6)
 960		return;
 961
 962	auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
 963	auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
 964
 965	ibss_dbg(sdata, "RX Auth SA=%pM DA=%pM\n", mgmt->sa, mgmt->da);
 966	ibss_dbg(sdata, "\tBSSID=%pM (auth_transaction=%d)\n",
 967		 mgmt->bssid, auth_transaction);
 968
 969	if (auth_alg != WLAN_AUTH_OPEN || auth_transaction != 1)
 970		return;
 971
 972	/*
 973	 * IEEE 802.11 standard does not require authentication in IBSS
 974	 * networks and most implementations do not seem to use it.
 975	 * However, try to reply to authentication attempts if someone
 976	 * has actually implemented this.
 977	 */
 978	ieee80211_send_auth(sdata, 2, WLAN_AUTH_OPEN, 0, NULL, 0,
 979			    mgmt->sa, sdata->u.ibss.bssid, NULL, 0, 0, 0);
 980}
 981
 982static void ieee80211_update_sta_info(struct ieee80211_sub_if_data *sdata,
 983				      struct ieee80211_mgmt *mgmt, size_t len,
 984				      struct ieee80211_rx_status *rx_status,
 985				      struct ieee802_11_elems *elems,
 986				      struct ieee80211_channel *channel)
 987{
 988	struct sta_info *sta;
 989	enum nl80211_band band = rx_status->band;
 990	enum nl80211_bss_scan_width scan_width;
 991	struct ieee80211_local *local = sdata->local;
 992	struct ieee80211_supported_band *sband;
 993	bool rates_updated = false;
 994	u32 supp_rates = 0;
 995
 996	if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
 997		return;
 998
 999	if (!ether_addr_equal(mgmt->bssid, sdata->u.ibss.bssid))
1000		return;
1001
1002	sband = local->hw.wiphy->bands[band];
1003	if (WARN_ON(!sband))
1004		return;
1005
1006	rcu_read_lock();
1007	sta = sta_info_get(sdata, mgmt->sa);
1008
1009	if (elems->supp_rates) {
1010		supp_rates = ieee80211_sta_get_rates(sdata, elems,
1011						     band, NULL);
1012		if (sta) {
1013			u32 prev_rates;
1014
1015			prev_rates = sta->sta.supp_rates[band];
1016			/* make sure mandatory rates are always added */
1017			scan_width = NL80211_BSS_CHAN_WIDTH_20;
1018			if (rx_status->bw == RATE_INFO_BW_5)
1019				scan_width = NL80211_BSS_CHAN_WIDTH_5;
1020			else if (rx_status->bw == RATE_INFO_BW_10)
1021				scan_width = NL80211_BSS_CHAN_WIDTH_10;
1022
1023			sta->sta.supp_rates[band] = supp_rates |
1024				ieee80211_mandatory_rates(sband, scan_width);
1025			if (sta->sta.supp_rates[band] != prev_rates) {
1026				ibss_dbg(sdata,
1027					 "updated supp_rates set for %pM based on beacon/probe_resp (0x%x -> 0x%x)\n",
1028					 sta->sta.addr, prev_rates,
1029					 sta->sta.supp_rates[band]);
1030				rates_updated = true;
1031			}
1032		} else {
1033			rcu_read_unlock();
1034			sta = ieee80211_ibss_add_sta(sdata, mgmt->bssid,
1035						     mgmt->sa, supp_rates);
1036		}
1037	}
1038
1039	if (sta && !sta->sta.wme &&
1040	    (elems->wmm_info || elems->s1g_capab) &&
1041	    local->hw.queues >= IEEE80211_NUM_ACS) {
1042		sta->sta.wme = true;
1043		ieee80211_check_fast_xmit(sta);
1044	}
1045
1046	if (sta && elems->ht_operation && elems->ht_cap_elem &&
1047	    sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
1048	    sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_5 &&
1049	    sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_10) {
1050		/* we both use HT */
1051		struct ieee80211_ht_cap htcap_ie;
1052		struct cfg80211_chan_def chandef;
1053		enum ieee80211_sta_rx_bandwidth bw = sta->sta.bandwidth;
1054
1055		cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);
1056		ieee80211_chandef_ht_oper(elems->ht_operation, &chandef);
1057
1058		memcpy(&htcap_ie, elems->ht_cap_elem, sizeof(htcap_ie));
1059		rates_updated |= ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1060								   &htcap_ie,
1061								   sta);
1062
1063		if (elems->vht_operation && elems->vht_cap_elem &&
1064		    sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_20 &&
1065		    sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_40) {
1066			/* we both use VHT */
1067			struct ieee80211_vht_cap cap_ie;
1068			struct ieee80211_sta_vht_cap cap = sta->sta.vht_cap;
1069			u32 vht_cap_info =
1070				le32_to_cpu(elems->vht_cap_elem->vht_cap_info);
1071
1072			ieee80211_chandef_vht_oper(&local->hw, vht_cap_info,
1073						   elems->vht_operation,
1074						   elems->ht_operation,
1075						   &chandef);
1076			memcpy(&cap_ie, elems->vht_cap_elem, sizeof(cap_ie));
1077			ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1078							    &cap_ie, sta);
1079			if (memcmp(&cap, &sta->sta.vht_cap, sizeof(cap)))
1080				rates_updated |= true;
1081		}
1082
1083		if (bw != sta->sta.bandwidth)
1084			rates_updated |= true;
1085
1086		if (!cfg80211_chandef_compatible(&sdata->u.ibss.chandef,
1087						 &chandef))
1088			WARN_ON_ONCE(1);
1089	}
1090
1091	if (sta && rates_updated) {
1092		u32 changed = IEEE80211_RC_SUPP_RATES_CHANGED;
1093		u8 rx_nss = sta->sta.rx_nss;
1094
1095		/* Force rx_nss recalculation */
1096		sta->sta.rx_nss = 0;
1097		rate_control_rate_init(sta);
1098		if (sta->sta.rx_nss != rx_nss)
1099			changed |= IEEE80211_RC_NSS_CHANGED;
1100
1101		drv_sta_rc_update(local, sdata, &sta->sta, changed);
1102	}
1103
1104	rcu_read_unlock();
1105}
1106
1107static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1108				  struct ieee80211_mgmt *mgmt, size_t len,
1109				  struct ieee80211_rx_status *rx_status,
1110				  struct ieee802_11_elems *elems)
1111{
1112	struct ieee80211_local *local = sdata->local;
1113	struct cfg80211_bss *cbss;
1114	struct ieee80211_bss *bss;
1115	struct ieee80211_channel *channel;
1116	u64 beacon_timestamp, rx_timestamp;
1117	u32 supp_rates = 0;
1118	enum nl80211_band band = rx_status->band;
1119
1120	channel = ieee80211_get_channel(local->hw.wiphy, rx_status->freq);
1121	if (!channel)
1122		return;
1123
1124	ieee80211_update_sta_info(sdata, mgmt, len, rx_status, elems, channel);
1125
1126	bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, channel);
 
1127	if (!bss)
1128		return;
1129
1130	cbss = container_of((void *)bss, struct cfg80211_bss, priv);
1131
1132	/* same for beacon and probe response */
1133	beacon_timestamp = le64_to_cpu(mgmt->u.beacon.timestamp);
1134
1135	/* check if we need to merge IBSS */
1136
1137	/* not an IBSS */
1138	if (!(cbss->capability & WLAN_CAPABILITY_IBSS))
1139		goto put_bss;
1140
1141	/* different channel */
1142	if (sdata->u.ibss.fixed_channel &&
1143	    sdata->u.ibss.chandef.chan != cbss->channel)
1144		goto put_bss;
1145
1146	/* different SSID */
1147	if (elems->ssid_len != sdata->u.ibss.ssid_len ||
1148	    memcmp(elems->ssid, sdata->u.ibss.ssid,
1149				sdata->u.ibss.ssid_len))
1150		goto put_bss;
1151
1152	/* process channel switch */
1153	if (sdata->vif.csa_active ||
1154	    ieee80211_ibss_process_chanswitch(sdata, elems, true))
1155		goto put_bss;
1156
1157	/* same BSSID */
1158	if (ether_addr_equal(cbss->bssid, sdata->u.ibss.bssid))
1159		goto put_bss;
1160
1161	/* we use a fixed BSSID */
1162	if (sdata->u.ibss.fixed_bssid)
1163		goto put_bss;
1164
1165	if (ieee80211_have_rx_timestamp(rx_status)) {
1166		/* time when timestamp field was received */
1167		rx_timestamp =
1168			ieee80211_calculate_rx_timestamp(local, rx_status,
1169							 len + FCS_LEN, 24);
1170	} else {
1171		/*
1172		 * second best option: get current TSF
1173		 * (will return -1 if not supported)
1174		 */
1175		rx_timestamp = drv_get_tsf(local, sdata);
1176	}
1177
1178	ibss_dbg(sdata, "RX beacon SA=%pM BSSID=%pM TSF=0x%llx\n",
 
1179		 mgmt->sa, mgmt->bssid,
1180		 (unsigned long long)rx_timestamp);
1181	ibss_dbg(sdata, "\tBCN=0x%llx diff=%lld @%lu\n",
1182		 (unsigned long long)beacon_timestamp,
1183		 (unsigned long long)(rx_timestamp - beacon_timestamp),
1184		 jiffies);
1185
1186	if (beacon_timestamp > rx_timestamp) {
1187		ibss_dbg(sdata,
1188			 "beacon TSF higher than local TSF - IBSS merge with BSSID %pM\n",
1189			 mgmt->bssid);
1190		ieee80211_sta_join_ibss(sdata, bss);
1191		supp_rates = ieee80211_sta_get_rates(sdata, elems, band, NULL);
1192		ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa,
1193				       supp_rates);
1194		rcu_read_unlock();
1195	}
1196
1197 put_bss:
1198	ieee80211_rx_bss_put(local, bss);
1199}
1200
1201void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
1202			      const u8 *bssid, const u8 *addr,
1203			      u32 supp_rates)
1204{
1205	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1206	struct ieee80211_local *local = sdata->local;
1207	struct sta_info *sta;
1208	struct ieee80211_chanctx_conf *chanctx_conf;
1209	struct ieee80211_supported_band *sband;
1210	enum nl80211_bss_scan_width scan_width;
1211	int band;
1212
1213	/*
1214	 * XXX: Consider removing the least recently used entry and
1215	 * 	allow new one to be added.
1216	 */
1217	if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
1218		net_info_ratelimited("%s: No room for a new IBSS STA entry %pM\n",
1219				    sdata->name, addr);
1220		return;
1221	}
1222
1223	if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH)
1224		return;
1225
1226	if (!ether_addr_equal(bssid, sdata->u.ibss.bssid))
1227		return;
1228
1229	rcu_read_lock();
1230	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1231	if (WARN_ON_ONCE(!chanctx_conf)) {
1232		rcu_read_unlock();
1233		return;
1234	}
1235	band = chanctx_conf->def.chan->band;
1236	scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
1237	rcu_read_unlock();
1238
1239	sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
1240	if (!sta)
1241		return;
1242
 
 
1243	/* make sure mandatory rates are always added */
1244	sband = local->hw.wiphy->bands[band];
1245	sta->sta.supp_rates[band] = supp_rates |
1246			ieee80211_mandatory_rates(sband, scan_width);
1247
1248	spin_lock(&ifibss->incomplete_lock);
1249	list_add(&sta->list, &ifibss->incomplete_stations);
1250	spin_unlock(&ifibss->incomplete_lock);
1251	ieee80211_queue_work(&local->hw, &sdata->work);
1252}
1253
1254static void ieee80211_ibss_sta_expire(struct ieee80211_sub_if_data *sdata)
1255{
1256	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1257	struct ieee80211_local *local = sdata->local;
1258	struct sta_info *sta, *tmp;
1259	unsigned long exp_time = IEEE80211_IBSS_INACTIVITY_LIMIT;
1260	unsigned long exp_rsn = IEEE80211_IBSS_RSN_INACTIVITY_LIMIT;
1261
1262	mutex_lock(&local->sta_mtx);
1263
1264	list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1265		unsigned long last_active = ieee80211_sta_last_active(sta);
1266
1267		if (sdata != sta->sdata)
1268			continue;
1269
1270		if (time_is_before_jiffies(last_active + exp_time) ||
1271		    (time_is_before_jiffies(last_active + exp_rsn) &&
1272		     sta->sta_state != IEEE80211_STA_AUTHORIZED)) {
1273			u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
1274
1275			sta_dbg(sta->sdata, "expiring inactive %sSTA %pM\n",
1276				sta->sta_state != IEEE80211_STA_AUTHORIZED ?
1277				"not authorized " : "", sta->sta.addr);
1278
1279			ieee80211_send_deauth_disassoc(sdata, sta->sta.addr,
1280						       ifibss->bssid,
1281						       IEEE80211_STYPE_DEAUTH,
1282						       WLAN_REASON_DEAUTH_LEAVING,
1283						       true, frame_buf);
1284			WARN_ON(__sta_info_destroy(sta));
1285		}
1286	}
1287
1288	mutex_unlock(&local->sta_mtx);
1289}
1290
1291/*
1292 * This function is called with state == IEEE80211_IBSS_MLME_JOINED
1293 */
1294
1295static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata)
1296{
1297	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1298	enum nl80211_bss_scan_width scan_width;
1299
1300	sdata_assert_lock(sdata);
1301
1302	mod_timer(&ifibss->timer,
1303		  round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
1304
1305	ieee80211_ibss_sta_expire(sdata);
1306
1307	if (time_before(jiffies, ifibss->last_scan_completed +
1308		       IEEE80211_IBSS_MERGE_INTERVAL))
1309		return;
1310
1311	if (ieee80211_sta_active_ibss(sdata))
1312		return;
1313
1314	if (ifibss->fixed_channel)
1315		return;
1316
1317	sdata_info(sdata,
1318		   "No active IBSS STAs - trying to scan for other IBSS networks with same SSID (merge)\n");
1319
1320	scan_width = cfg80211_chandef_to_scan_width(&ifibss->chandef);
1321	ieee80211_request_ibss_scan(sdata, ifibss->ssid, ifibss->ssid_len,
1322				    NULL, 0, scan_width);
1323}
1324
1325static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
1326{
1327	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1328	u8 bssid[ETH_ALEN];
1329	u16 capability;
1330	int i;
1331
1332	sdata_assert_lock(sdata);
1333
1334	if (ifibss->fixed_bssid) {
1335		memcpy(bssid, ifibss->bssid, ETH_ALEN);
1336	} else {
1337		/* Generate random, not broadcast, locally administered BSSID. Mix in
1338		 * own MAC address to make sure that devices that do not have proper
1339		 * random number generator get different BSSID. */
1340		get_random_bytes(bssid, ETH_ALEN);
1341		for (i = 0; i < ETH_ALEN; i++)
1342			bssid[i] ^= sdata->vif.addr[i];
1343		bssid[0] &= ~0x01;
1344		bssid[0] |= 0x02;
1345	}
1346
1347	sdata_info(sdata, "Creating new IBSS network, BSSID %pM\n", bssid);
1348
1349	capability = WLAN_CAPABILITY_IBSS;
1350
1351	if (ifibss->privacy)
1352		capability |= WLAN_CAPABILITY_PRIVACY;
1353
1354	__ieee80211_sta_join_ibss(sdata, bssid, sdata->vif.bss_conf.beacon_int,
1355				  &ifibss->chandef, ifibss->basic_rates,
1356				  capability, 0, true);
1357}
1358
1359static unsigned ibss_setup_channels(struct wiphy *wiphy,
1360				    struct ieee80211_channel **channels,
1361				    unsigned int channels_max,
1362				    u32 center_freq, u32 width)
1363{
1364	struct ieee80211_channel *chan = NULL;
1365	unsigned int n_chan = 0;
1366	u32 start_freq, end_freq, freq;
1367
1368	if (width <= 20) {
1369		start_freq = center_freq;
1370		end_freq = center_freq;
1371	} else {
1372		start_freq = center_freq - width / 2 + 10;
1373		end_freq = center_freq + width / 2 - 10;
1374	}
1375
1376	for (freq = start_freq; freq <= end_freq; freq += 20) {
1377		chan = ieee80211_get_channel(wiphy, freq);
1378		if (!chan)
1379			continue;
1380		if (n_chan >= channels_max)
1381			return n_chan;
1382
1383		channels[n_chan] = chan;
1384		n_chan++;
1385	}
1386
1387	return n_chan;
1388}
1389
1390static unsigned int
1391ieee80211_ibss_setup_scan_channels(struct wiphy *wiphy,
1392				   const struct cfg80211_chan_def *chandef,
1393				   struct ieee80211_channel **channels,
1394				   unsigned int channels_max)
1395{
1396	unsigned int n_chan = 0;
1397	u32 width, cf1, cf2 = 0;
1398
1399	switch (chandef->width) {
1400	case NL80211_CHAN_WIDTH_40:
1401		width = 40;
1402		break;
1403	case NL80211_CHAN_WIDTH_80P80:
1404		cf2 = chandef->center_freq2;
1405		fallthrough;
1406	case NL80211_CHAN_WIDTH_80:
1407		width = 80;
1408		break;
1409	case NL80211_CHAN_WIDTH_160:
1410		width = 160;
1411		break;
1412	default:
1413		width = 20;
1414		break;
1415	}
1416
1417	cf1 = chandef->center_freq1;
1418
1419	n_chan = ibss_setup_channels(wiphy, channels, channels_max, cf1, width);
1420
1421	if (cf2)
1422		n_chan += ibss_setup_channels(wiphy, &channels[n_chan],
1423					      channels_max - n_chan, cf2,
1424					      width);
1425
1426	return n_chan;
1427}
1428
1429/*
1430 * This function is called with state == IEEE80211_IBSS_MLME_SEARCH
1431 */
1432
1433static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
1434{
1435	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1436	struct ieee80211_local *local = sdata->local;
1437	struct cfg80211_bss *cbss;
1438	struct ieee80211_channel *chan = NULL;
1439	const u8 *bssid = NULL;
1440	enum nl80211_bss_scan_width scan_width;
1441	int active_ibss;
1442
1443	sdata_assert_lock(sdata);
1444
1445	active_ibss = ieee80211_sta_active_ibss(sdata);
1446	ibss_dbg(sdata, "sta_find_ibss (active_ibss=%d)\n", active_ibss);
1447
1448	if (active_ibss)
1449		return;
1450
1451	if (ifibss->fixed_bssid)
1452		bssid = ifibss->bssid;
1453	if (ifibss->fixed_channel)
1454		chan = ifibss->chandef.chan;
1455	if (!is_zero_ether_addr(ifibss->bssid))
1456		bssid = ifibss->bssid;
1457	cbss = cfg80211_get_bss(local->hw.wiphy, chan, bssid,
1458				ifibss->ssid, ifibss->ssid_len,
1459				IEEE80211_BSS_TYPE_IBSS,
1460				IEEE80211_PRIVACY(ifibss->privacy));
1461
1462	if (cbss) {
1463		struct ieee80211_bss *bss;
1464
1465		bss = (void *)cbss->priv;
1466		ibss_dbg(sdata,
1467			 "sta_find_ibss: selected %pM current %pM\n",
1468			 cbss->bssid, ifibss->bssid);
1469		sdata_info(sdata,
1470			   "Selected IBSS BSSID %pM based on configured SSID\n",
1471			   cbss->bssid);
1472
1473		ieee80211_sta_join_ibss(sdata, bss);
1474		ieee80211_rx_bss_put(local, bss);
1475		return;
1476	}
1477
1478	/* if a fixed bssid and a fixed freq have been provided create the IBSS
1479	 * directly and do not waste time scanning
1480	 */
1481	if (ifibss->fixed_bssid && ifibss->fixed_channel) {
1482		sdata_info(sdata, "Created IBSS using preconfigured BSSID %pM\n",
1483			   bssid);
1484		ieee80211_sta_create_ibss(sdata);
1485		return;
1486	}
1487
1488
1489	ibss_dbg(sdata, "sta_find_ibss: did not try to join ibss\n");
1490
1491	/* Selected IBSS not found in current scan results - try to scan */
1492	if (time_after(jiffies, ifibss->last_scan_completed +
1493					IEEE80211_SCAN_INTERVAL)) {
1494		struct ieee80211_channel *channels[8];
1495		unsigned int num;
1496
1497		sdata_info(sdata, "Trigger new scan to find an IBSS to join\n");
1498
1499		scan_width = cfg80211_chandef_to_scan_width(&ifibss->chandef);
1500
1501		if (ifibss->fixed_channel) {
1502			num = ieee80211_ibss_setup_scan_channels(local->hw.wiphy,
1503								 &ifibss->chandef,
1504								 channels,
1505								 ARRAY_SIZE(channels));
1506			ieee80211_request_ibss_scan(sdata, ifibss->ssid,
1507						    ifibss->ssid_len, channels,
1508						    num, scan_width);
1509		} else {
1510			ieee80211_request_ibss_scan(sdata, ifibss->ssid,
1511						    ifibss->ssid_len, NULL,
1512						    0, scan_width);
1513		}
1514	} else {
1515		int interval = IEEE80211_SCAN_INTERVAL;
1516
1517		if (time_after(jiffies, ifibss->ibss_join_req +
1518			       IEEE80211_IBSS_JOIN_TIMEOUT))
1519			ieee80211_sta_create_ibss(sdata);
1520
1521		mod_timer(&ifibss->timer,
1522			  round_jiffies(jiffies + interval));
1523	}
1524}
1525
1526static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
1527					struct sk_buff *req)
1528{
1529	struct ieee80211_mgmt *mgmt = (void *)req->data;
1530	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1531	struct ieee80211_local *local = sdata->local;
1532	int tx_last_beacon, len = req->len;
1533	struct sk_buff *skb;
1534	struct beacon_data *presp;
1535	u8 *pos, *end;
1536
1537	sdata_assert_lock(sdata);
1538
1539	presp = rcu_dereference_protected(ifibss->presp,
1540					  lockdep_is_held(&sdata->wdev.mtx));
1541
1542	if (ifibss->state != IEEE80211_IBSS_MLME_JOINED ||
1543	    len < 24 + 2 || !presp)
1544		return;
1545
1546	tx_last_beacon = drv_tx_last_beacon(local);
1547
1548	ibss_dbg(sdata, "RX ProbeReq SA=%pM DA=%pM\n", mgmt->sa, mgmt->da);
1549	ibss_dbg(sdata, "\tBSSID=%pM (tx_last_beacon=%d)\n",
1550		 mgmt->bssid, tx_last_beacon);
1551
1552	if (!tx_last_beacon && is_multicast_ether_addr(mgmt->da))
1553		return;
1554
1555	if (!ether_addr_equal(mgmt->bssid, ifibss->bssid) &&
1556	    !is_broadcast_ether_addr(mgmt->bssid))
1557		return;
1558
1559	end = ((u8 *) mgmt) + len;
1560	pos = mgmt->u.probe_req.variable;
1561	if (pos[0] != WLAN_EID_SSID ||
1562	    pos + 2 + pos[1] > end) {
1563		ibss_dbg(sdata, "Invalid SSID IE in ProbeReq from %pM\n",
1564			 mgmt->sa);
1565		return;
1566	}
1567	if (pos[1] != 0 &&
1568	    (pos[1] != ifibss->ssid_len ||
1569	     memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len))) {
1570		/* Ignore ProbeReq for foreign SSID */
1571		return;
1572	}
1573
1574	/* Reply with ProbeResp */
1575	skb = dev_alloc_skb(local->tx_headroom + presp->head_len);
1576	if (!skb)
1577		return;
1578
1579	skb_reserve(skb, local->tx_headroom);
1580	skb_put_data(skb, presp->head, presp->head_len);
1581
1582	memcpy(((struct ieee80211_mgmt *) skb->data)->da, mgmt->sa, ETH_ALEN);
1583	ibss_dbg(sdata, "Sending ProbeResp to %pM\n", mgmt->sa);
1584	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1585
1586	/* avoid excessive retries for probe request to wildcard SSIDs */
1587	if (pos[1] == 0)
1588		IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_NO_ACK;
1589
1590	ieee80211_tx_skb(sdata, skb);
1591}
1592
1593static
1594void ieee80211_rx_mgmt_probe_beacon(struct ieee80211_sub_if_data *sdata,
1595				    struct ieee80211_mgmt *mgmt, size_t len,
1596				    struct ieee80211_rx_status *rx_status)
1597{
1598	size_t baselen;
1599	struct ieee802_11_elems elems;
1600
1601	BUILD_BUG_ON(offsetof(typeof(mgmt->u.probe_resp), variable) !=
1602		     offsetof(typeof(mgmt->u.beacon), variable));
1603
1604	/*
1605	 * either beacon or probe_resp but the variable field is at the
1606	 * same offset
1607	 */
1608	baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1609	if (baselen > len)
1610		return;
1611
1612	ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
1613			       false, &elems, mgmt->bssid, NULL);
1614
1615	ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems);
1616}
1617
1618void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1619				   struct sk_buff *skb)
1620{
1621	struct ieee80211_rx_status *rx_status;
1622	struct ieee80211_mgmt *mgmt;
1623	u16 fc;
1624	struct ieee802_11_elems elems;
1625	int ies_len;
1626
1627	rx_status = IEEE80211_SKB_RXCB(skb);
1628	mgmt = (struct ieee80211_mgmt *) skb->data;
1629	fc = le16_to_cpu(mgmt->frame_control);
1630
1631	sdata_lock(sdata);
1632
1633	if (!sdata->u.ibss.ssid_len)
1634		goto mgmt_out; /* not ready to merge yet */
1635
1636	switch (fc & IEEE80211_FCTL_STYPE) {
1637	case IEEE80211_STYPE_PROBE_REQ:
1638		ieee80211_rx_mgmt_probe_req(sdata, skb);
1639		break;
1640	case IEEE80211_STYPE_PROBE_RESP:
1641	case IEEE80211_STYPE_BEACON:
1642		ieee80211_rx_mgmt_probe_beacon(sdata, mgmt, skb->len,
1643					       rx_status);
1644		break;
1645	case IEEE80211_STYPE_AUTH:
1646		ieee80211_rx_mgmt_auth_ibss(sdata, mgmt, skb->len);
1647		break;
1648	case IEEE80211_STYPE_DEAUTH:
1649		ieee80211_rx_mgmt_deauth_ibss(sdata, mgmt, skb->len);
1650		break;
1651	case IEEE80211_STYPE_ACTION:
1652		switch (mgmt->u.action.category) {
1653		case WLAN_CATEGORY_SPECTRUM_MGMT:
1654			ies_len = skb->len -
1655				  offsetof(struct ieee80211_mgmt,
1656					   u.action.u.chan_switch.variable);
1657
1658			if (ies_len < 0)
1659				break;
1660
1661			ieee802_11_parse_elems(
1662				mgmt->u.action.u.chan_switch.variable,
1663				ies_len, true, &elems, mgmt->bssid, NULL);
1664
1665			if (elems.parse_error)
1666				break;
1667
1668			ieee80211_rx_mgmt_spectrum_mgmt(sdata, mgmt, skb->len,
1669							rx_status, &elems);
1670			break;
1671		}
1672	}
1673
1674 mgmt_out:
1675	sdata_unlock(sdata);
1676}
1677
1678void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata)
1679{
1680	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1681	struct sta_info *sta;
1682
1683	sdata_lock(sdata);
1684
1685	/*
1686	 * Work could be scheduled after scan or similar
1687	 * when we aren't even joined (or trying) with a
1688	 * network.
1689	 */
1690	if (!ifibss->ssid_len)
1691		goto out;
1692
1693	spin_lock_bh(&ifibss->incomplete_lock);
1694	while (!list_empty(&ifibss->incomplete_stations)) {
1695		sta = list_first_entry(&ifibss->incomplete_stations,
1696				       struct sta_info, list);
1697		list_del(&sta->list);
1698		spin_unlock_bh(&ifibss->incomplete_lock);
1699
1700		ieee80211_ibss_finish_sta(sta);
1701		rcu_read_unlock();
1702		spin_lock_bh(&ifibss->incomplete_lock);
1703	}
1704	spin_unlock_bh(&ifibss->incomplete_lock);
1705
1706	switch (ifibss->state) {
1707	case IEEE80211_IBSS_MLME_SEARCH:
1708		ieee80211_sta_find_ibss(sdata);
1709		break;
1710	case IEEE80211_IBSS_MLME_JOINED:
1711		ieee80211_sta_merge_ibss(sdata);
1712		break;
1713	default:
1714		WARN_ON(1);
1715		break;
1716	}
1717
1718 out:
1719	sdata_unlock(sdata);
1720}
1721
1722static void ieee80211_ibss_timer(struct timer_list *t)
1723{
1724	struct ieee80211_sub_if_data *sdata =
1725		from_timer(sdata, t, u.ibss.timer);
1726
1727	ieee80211_queue_work(&sdata->local->hw, &sdata->work);
1728}
1729
1730void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
1731{
1732	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1733
1734	timer_setup(&ifibss->timer, ieee80211_ibss_timer, 0);
 
1735	INIT_LIST_HEAD(&ifibss->incomplete_stations);
1736	spin_lock_init(&ifibss->incomplete_lock);
1737	INIT_WORK(&ifibss->csa_connection_drop_work,
1738		  ieee80211_csa_connection_drop_work);
1739}
1740
1741/* scan finished notification */
1742void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local)
1743{
1744	struct ieee80211_sub_if_data *sdata;
1745
1746	mutex_lock(&local->iflist_mtx);
1747	list_for_each_entry(sdata, &local->interfaces, list) {
1748		if (!ieee80211_sdata_running(sdata))
1749			continue;
1750		if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
1751			continue;
1752		sdata->u.ibss.last_scan_completed = jiffies;
1753	}
1754	mutex_unlock(&local->iflist_mtx);
1755}
1756
1757int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
1758			struct cfg80211_ibss_params *params)
1759{
1760	u32 changed = 0;
1761	u32 rate_flags;
1762	struct ieee80211_supported_band *sband;
1763	enum ieee80211_chanctx_mode chanmode;
1764	struct ieee80211_local *local = sdata->local;
1765	int radar_detect_width = 0;
1766	int i;
1767	int ret;
1768
1769	if (params->chandef.chan->freq_offset) {
1770		/* this may work, but is untested */
1771		return -EOPNOTSUPP;
1772	}
1773
1774	ret = cfg80211_chandef_dfs_required(local->hw.wiphy,
1775					    &params->chandef,
1776					    sdata->wdev.iftype);
1777	if (ret < 0)
1778		return ret;
1779
1780	if (ret > 0) {
1781		if (!params->userspace_handles_dfs)
1782			return -EINVAL;
1783		radar_detect_width = BIT(params->chandef.width);
1784	}
1785
1786	chanmode = (params->channel_fixed && !ret) ?
1787		IEEE80211_CHANCTX_SHARED : IEEE80211_CHANCTX_EXCLUSIVE;
1788
1789	mutex_lock(&local->chanctx_mtx);
1790	ret = ieee80211_check_combinations(sdata, &params->chandef, chanmode,
1791					   radar_detect_width);
1792	mutex_unlock(&local->chanctx_mtx);
1793	if (ret < 0)
1794		return ret;
1795
1796	if (params->bssid) {
1797		memcpy(sdata->u.ibss.bssid, params->bssid, ETH_ALEN);
1798		sdata->u.ibss.fixed_bssid = true;
1799	} else
1800		sdata->u.ibss.fixed_bssid = false;
1801
1802	sdata->u.ibss.privacy = params->privacy;
1803	sdata->u.ibss.control_port = params->control_port;
1804	sdata->u.ibss.userspace_handles_dfs = params->userspace_handles_dfs;
1805	sdata->u.ibss.basic_rates = params->basic_rates;
1806	sdata->u.ibss.last_scan_completed = jiffies;
1807
1808	/* fix basic_rates if channel does not support these rates */
1809	rate_flags = ieee80211_chandef_rate_flags(&params->chandef);
1810	sband = local->hw.wiphy->bands[params->chandef.chan->band];
1811	for (i = 0; i < sband->n_bitrates; i++) {
1812		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1813			sdata->u.ibss.basic_rates &= ~BIT(i);
1814	}
1815	memcpy(sdata->vif.bss_conf.mcast_rate, params->mcast_rate,
1816	       sizeof(params->mcast_rate));
1817
1818	sdata->vif.bss_conf.beacon_int = params->beacon_interval;
1819
1820	sdata->u.ibss.chandef = params->chandef;
1821	sdata->u.ibss.fixed_channel = params->channel_fixed;
1822
1823	if (params->ie) {
1824		sdata->u.ibss.ie = kmemdup(params->ie, params->ie_len,
1825					   GFP_KERNEL);
1826		if (sdata->u.ibss.ie)
1827			sdata->u.ibss.ie_len = params->ie_len;
1828	}
1829
1830	sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH;
1831	sdata->u.ibss.ibss_join_req = jiffies;
1832
1833	memcpy(sdata->u.ibss.ssid, params->ssid, params->ssid_len);
1834	sdata->u.ibss.ssid_len = params->ssid_len;
1835
1836	memcpy(&sdata->u.ibss.ht_capa, &params->ht_capa,
1837	       sizeof(sdata->u.ibss.ht_capa));
1838	memcpy(&sdata->u.ibss.ht_capa_mask, &params->ht_capa_mask,
1839	       sizeof(sdata->u.ibss.ht_capa_mask));
1840
1841	/*
1842	 * 802.11n-2009 9.13.3.1: In an IBSS, the HT Protection field is
1843	 * reserved, but an HT STA shall protect HT transmissions as though
1844	 * the HT Protection field were set to non-HT mixed mode.
1845	 *
1846	 * In an IBSS, the RIFS Mode field of the HT Operation element is
1847	 * also reserved, but an HT STA shall operate as though this field
1848	 * were set to 1.
1849	 */
1850
1851	sdata->vif.bss_conf.ht_operation_mode |=
1852		  IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
1853		| IEEE80211_HT_PARAM_RIFS_MODE;
1854
1855	changed |= BSS_CHANGED_HT | BSS_CHANGED_MCAST_RATE;
1856	ieee80211_bss_info_change_notify(sdata, changed);
1857
1858	sdata->smps_mode = IEEE80211_SMPS_OFF;
1859	sdata->needed_rx_chains = local->rx_chains;
1860	sdata->control_port_over_nl80211 = params->control_port_over_nl80211;
1861
1862	ieee80211_queue_work(&local->hw, &sdata->work);
1863
1864	return 0;
1865}
1866
1867int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata)
1868{
1869	struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1870
1871	ieee80211_ibss_disconnect(sdata);
1872	ifibss->ssid_len = 0;
1873	eth_zero_addr(ifibss->bssid);
1874
1875	/* remove beacon */
1876	kfree(sdata->u.ibss.ie);
1877	sdata->u.ibss.ie = NULL;
1878	sdata->u.ibss.ie_len = 0;
1879
1880	/* on the next join, re-program HT parameters */
1881	memset(&ifibss->ht_capa, 0, sizeof(ifibss->ht_capa));
1882	memset(&ifibss->ht_capa_mask, 0, sizeof(ifibss->ht_capa_mask));
1883
1884	synchronize_rcu();
1885
1886	skb_queue_purge(&sdata->skb_queue);
1887
1888	del_timer_sync(&sdata->u.ibss.timer);
1889
1890	return 0;
1891}