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