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