blob: c0042136f1d847702723cf637414aaf19aae36f8 [file] [log] [blame]
Johannes Berg46900292009-02-15 12:44:28 +01001/*
2 * IBSS mode implementation
3 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
4 * Copyright 2004, Instant802 Networks, Inc.
5 * Copyright 2005, Devicescape Software, Inc.
6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
8 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#include <linux/delay.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
Johannes Berg46900292009-02-15 12:44:28 +010017#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>
Johannes Berg46900292009-02-15 12:44:28 +010023
24#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020025#include "driver-ops.h"
Johannes Berg46900292009-02-15 12:44:28 +010026#include "rate.h"
27
28#define IEEE80211_SCAN_INTERVAL (2 * HZ)
Johannes Berg46900292009-02-15 12:44:28 +010029#define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
30
31#define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
32#define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
Antonio Quartullidad9def2013-07-26 21:15:02 +020033#define IEEE80211_IBSS_RSN_INACTIVITY_LIMIT (10 * HZ)
Johannes Berg46900292009-02-15 12:44:28 +010034
35#define IEEE80211_IBSS_MAX_STA_ENTRIES 128
36
Simon Wunderlichd51b70f2013-08-09 16:35:17 +020037static struct beacon_data *
38ieee80211_ibss_build_presp(struct ieee80211_sub_if_data *sdata,
39 const int beacon_int, const u32 basic_rates,
40 const u16 capability, u64 tsf,
41 struct cfg80211_chan_def *chandef,
Simon Wunderlichcd7760e2013-08-28 13:41:31 +020042 bool *have_higher_than_11mbit,
43 struct cfg80211_csa_settings *csa_settings)
Simon Wunderlichd51b70f2013-08-09 16:35:17 +020044{
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 */ +
Simon Wunderlichcd7760e2013-08-28 13:41:31 +020063 5 /* Channel Switch Announcement */ +
Simon Wunderlichd51b70f2013-08-09 16:35:17 +020064 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
65 2 + sizeof(struct ieee80211_ht_cap) +
66 2 + sizeof(struct ieee80211_ht_operation) +
67 ifibss->ie_len;
68 presp = kzalloc(sizeof(*presp) + frame_len, GFP_KERNEL);
69 if (!presp)
70 return NULL;
71
72 presp->head = (void *)(presp + 1);
73
74 mgmt = (void *) presp->head;
75 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
76 IEEE80211_STYPE_PROBE_RESP);
77 eth_broadcast_addr(mgmt->da);
78 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
79 memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
80 mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_int);
81 mgmt->u.beacon.timestamp = cpu_to_le64(tsf);
82 mgmt->u.beacon.capab_info = cpu_to_le16(capability);
83
84 pos = (u8 *)mgmt + offsetof(struct ieee80211_mgmt, u.beacon.variable);
85
86 *pos++ = WLAN_EID_SSID;
87 *pos++ = ifibss->ssid_len;
88 memcpy(pos, ifibss->ssid, ifibss->ssid_len);
89 pos += ifibss->ssid_len;
90
91 sband = local->hw.wiphy->bands[chandef->chan->band];
92 rate_flags = ieee80211_chandef_rate_flags(chandef);
93 shift = ieee80211_chandef_get_shift(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,
113 5 * (1 << shift));
114 u8 basic = 0;
115 if (!(rates & BIT(ri)))
116 continue;
117
118 if (basic_rates & BIT(ri))
119 basic = 0x80;
120 *pos++ = basic | (u8) rate;
121 if (++rates_added == 8) {
122 ri++; /* continue at next rate for EXT_SUPP_RATES */
123 break;
124 }
125 }
126
127 if (sband->band == IEEE80211_BAND_2GHZ) {
128 *pos++ = WLAN_EID_DS_PARAMS;
129 *pos++ = 1;
130 *pos++ = ieee80211_frequency_to_channel(
131 chandef->chan->center_freq);
132 }
133
134 *pos++ = WLAN_EID_IBSS_PARAMS;
135 *pos++ = 2;
136 /* FIX: set ATIM window based on scan results */
137 *pos++ = 0;
138 *pos++ = 0;
139
Simon Wunderlichcd7760e2013-08-28 13:41:31 +0200140 if (csa_settings) {
141 *pos++ = WLAN_EID_CHANNEL_SWITCH;
142 *pos++ = 3;
143 *pos++ = csa_settings->block_tx ? 1 : 0;
144 *pos++ = ieee80211_frequency_to_channel(
145 csa_settings->chandef.chan->center_freq);
146 sdata->csa_counter_offset_beacon = (pos - presp->head);
147 *pos++ = csa_settings->count;
148 }
149
Simon Wunderlichd51b70f2013-08-09 16:35:17 +0200150 /* 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,
156 5 * (1 << shift));
157 u8 basic = 0;
158 if (!(rates & BIT(ri)))
159 continue;
160
161 if (basic_rates & BIT(ri))
162 basic = 0x80;
163 *pos++ = basic | (u8) rate;
164 }
165 }
166
167 if (ifibss->ie_len) {
168 memcpy(pos, ifibss->ie, ifibss->ie_len);
169 pos += ifibss->ie_len;
170 }
171
172 /* add HT capability and information IEs */
173 if (chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
174 chandef->width != NL80211_CHAN_WIDTH_5 &&
175 chandef->width != NL80211_CHAN_WIDTH_10 &&
176 sband->ht_cap.ht_supported) {
177 struct ieee80211_sta_ht_cap ht_cap;
178
179 memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
180 ieee80211_apply_htcap_overrides(sdata, &ht_cap);
181
182 pos = ieee80211_ie_build_ht_cap(pos, &ht_cap, ht_cap.cap);
183 /*
184 * Note: According to 802.11n-2009 9.13.3.1, HT Protection
185 * field and RIFS Mode are reserved in IBSS mode, therefore
186 * keep them at 0
187 */
188 pos = ieee80211_ie_build_ht_oper(pos, &sband->ht_cap,
189 chandef, 0);
190 }
191
192 if (local->hw.queues >= IEEE80211_NUM_ACS) {
193 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
194 *pos++ = 7; /* len */
195 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
196 *pos++ = 0x50;
197 *pos++ = 0xf2;
198 *pos++ = 2; /* WME */
199 *pos++ = 0; /* WME info */
200 *pos++ = 1; /* WME ver */
201 *pos++ = 0; /* U-APSD no in use */
202 }
203
204 presp->head_len = pos - presp->head;
205 if (WARN_ON(presp->head_len > frame_len))
206 goto error;
207
208 return presp;
209error:
210 kfree(presp);
211 return NULL;
212}
Johannes Berg46900292009-02-15 12:44:28 +0100213
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200214static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
215 const u8 *bssid, const int beacon_int,
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200216 struct cfg80211_chan_def *req_chandef,
Johannes Bergb59066a2009-05-12 21:18:38 +0200217 const u32 basic_rates,
Sujith Manoharanc13a7652012-10-12 17:35:45 +0530218 const u16 capability, u64 tsf,
219 bool creator)
Johannes Berg46900292009-02-15 12:44:28 +0100220{
221 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
222 struct ieee80211_local *local = sdata->local;
Johannes Berg46900292009-02-15 12:44:28 +0100223 struct ieee80211_supported_band *sband;
Simon Wunderlichd51b70f2013-08-09 16:35:17 +0200224 struct ieee80211_mgmt *mgmt;
Johannes Bergf446d102009-10-28 15:12:32 +0100225 struct cfg80211_bss *bss;
Simon Wunderlichd51b70f2013-08-09 16:35:17 +0200226 u32 bss_change;
Johannes Berg683b6d32012-11-08 21:25:48 +0100227 struct cfg80211_chan_def chandef;
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200228 struct ieee80211_channel *chan;
Johannes Bergc3ffeab2013-03-07 20:54:29 +0100229 struct beacon_data *presp;
Simon Wunderlichd51b70f2013-08-09 16:35:17 +0200230 enum nl80211_bss_scan_width scan_width;
231 bool have_higher_than_11mbit;
Johannes Berg24487982009-04-23 18:52:52 +0200232
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200233 sdata_assert_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +0200234
Johannes Berg24487982009-04-23 18:52:52 +0200235 /* Reset own TSF to allow time synchronization work. */
Eliad Peller37a41b42011-09-21 14:06:11 +0300236 drv_reset_tsf(local, sdata);
Johannes Berg46900292009-02-15 12:44:28 +0100237
Joe Perchesb203ca32012-05-08 18:56:52 +0000238 if (!ether_addr_equal(ifibss->bssid, bssid))
Johannes Bergb998e8b2012-12-13 23:07:46 +0100239 sta_info_flush(sdata);
Johannes Berg46900292009-02-15 12:44:28 +0100240
Johannes Berg49b5c7f2010-04-29 21:34:01 +0200241 /* if merging, indicate to driver that we leave the old IBSS */
242 if (sdata->vif.bss_conf.ibss_joined) {
243 sdata->vif.bss_conf.ibss_joined = false;
Sujith Manoharanc13a7652012-10-12 17:35:45 +0530244 sdata->vif.bss_conf.ibss_creator = false;
Johannes Berg1852d402013-03-07 20:22:28 +0100245 sdata->vif.bss_conf.enable_beacon = false;
Eliad Peller86a2ea42011-11-08 15:36:59 +0200246 netif_carrier_off(sdata->dev);
Johannes Berg1852d402013-03-07 20:22:28 +0100247 ieee80211_bss_info_change_notify(sdata,
248 BSS_CHANGED_IBSS |
249 BSS_CHANGED_BEACON_ENABLED);
Johannes Berg49b5c7f2010-04-29 21:34:01 +0200250 }
251
Johannes Bergc3ffeab2013-03-07 20:54:29 +0100252 presp = rcu_dereference_protected(ifibss->presp,
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200253 lockdep_is_held(&sdata->wdev.mtx));
Johannes Bergc3ffeab2013-03-07 20:54:29 +0100254 rcu_assign_pointer(ifibss->presp, NULL);
255 if (presp)
256 kfree_rcu(presp, rcu_head);
Johannes Berg1852d402013-03-07 20:22:28 +0100257
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200258 sdata->drop_unencrypted = capability & WLAN_CAPABILITY_PRIVACY ? 1 : 0;
Johannes Berg46900292009-02-15 12:44:28 +0100259
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200260 /* make a copy of the chandef, it could be modified below. */
261 chandef = *req_chandef;
262 chan = chandef.chan;
Johannes Berg4bf88532012-11-09 11:39:59 +0100263 if (!cfg80211_reg_can_beacon(local->hw.wiphy, &chandef)) {
Simon Wunderlich4b42aab2013-07-08 16:55:57 +0200264 if (chandef.width == NL80211_CHAN_WIDTH_5 ||
265 chandef.width == NL80211_CHAN_WIDTH_10 ||
266 chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
267 chandef.width == NL80211_CHAN_WIDTH_20) {
268 sdata_info(sdata,
269 "Failed to join IBSS, beacons forbidden\n");
270 return;
271 }
Johannes Berg4bf88532012-11-09 11:39:59 +0100272 chandef.width = NL80211_CHAN_WIDTH_20;
273 chandef.center_freq1 = chan->center_freq;
274 }
Johannes Berg55de9082012-07-26 17:24:39 +0200275
276 ieee80211_vif_release_channel(sdata);
Johannes Berg4bf88532012-11-09 11:39:59 +0100277 if (ieee80211_vif_use_channel(sdata, &chandef,
Johannes Berg55de9082012-07-26 17:24:39 +0200278 ifibss->fixed_channel ?
279 IEEE80211_CHANCTX_SHARED :
280 IEEE80211_CHANCTX_EXCLUSIVE)) {
281 sdata_info(sdata, "Failed to join IBSS, no channel context\n");
282 return;
Alexander Simon13c40c52011-11-30 16:56:34 +0100283 }
Johannes Berg55de9082012-07-26 17:24:39 +0200284
285 memcpy(ifibss->bssid, bssid, ETH_ALEN);
Johannes Berg57c4d7b2009-04-23 16:10:04 +0200286
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200287 sband = local->hw.wiphy->bands[chan->band];
Johannes Berg46900292009-02-15 12:44:28 +0100288
Simon Wunderlichd51b70f2013-08-09 16:35:17 +0200289 presp = ieee80211_ibss_build_presp(sdata, beacon_int, basic_rates,
290 capability, tsf, &chandef,
Simon Wunderlichcd7760e2013-08-28 13:41:31 +0200291 &have_higher_than_11mbit, NULL);
Johannes Bergc3ffeab2013-03-07 20:54:29 +0100292 if (!presp)
293 return;
294
Johannes Bergc3ffeab2013-03-07 20:54:29 +0100295 rcu_assign_pointer(ifibss->presp, presp);
Simon Wunderlichd51b70f2013-08-09 16:35:17 +0200296 mgmt = (void *)presp->head;
Johannes Berg46900292009-02-15 12:44:28 +0100297
Johannes Bergd6a83222012-12-14 14:06:28 +0100298 sdata->vif.bss_conf.enable_beacon = true;
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200299 sdata->vif.bss_conf.beacon_int = beacon_int;
Teemu Paasikivifbd2c8d2010-06-14 12:55:31 +0300300 sdata->vif.bss_conf.basic_rates = basic_rates;
Marek Puzyniak0ca54f62013-04-10 13:19:13 +0200301 sdata->vif.bss_conf.ssid_len = ifibss->ssid_len;
302 memcpy(sdata->vif.bss_conf.ssid, ifibss->ssid, ifibss->ssid_len);
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200303 bss_change = BSS_CHANGED_BEACON_INT;
304 bss_change |= ieee80211_reset_erp_info(sdata);
305 bss_change |= BSS_CHANGED_BSSID;
306 bss_change |= BSS_CHANGED_BEACON;
307 bss_change |= BSS_CHANGED_BEACON_ENABLED;
Teemu Paasikivi392cfdb2010-06-14 12:55:32 +0300308 bss_change |= BSS_CHANGED_BASIC_RATES;
Alexander Simon13c40c52011-11-30 16:56:34 +0100309 bss_change |= BSS_CHANGED_HT;
Johannes Berg8fc214b2010-04-28 17:40:43 +0200310 bss_change |= BSS_CHANGED_IBSS;
Marek Puzyniak0ca54f62013-04-10 13:19:13 +0200311 bss_change |= BSS_CHANGED_SSID;
Simon Wunderlich2f91a962012-12-03 22:21:30 +0100312
313 /*
314 * In 5 GHz/802.11a, we can always use short slot time.
315 * (IEEE 802.11-2012 18.3.8.7)
316 *
317 * In 2.4GHz, we must always use long slots in IBSS for compatibility
318 * reasons.
319 * (IEEE 802.11-2012 19.4.5)
320 *
321 * HT follows these specifications (IEEE 802.11-2012 20.3.18)
322 */
323 sdata->vif.bss_conf.use_short_slot = chan->band == IEEE80211_BAND_5GHZ;
324 bss_change |= BSS_CHANGED_ERP_SLOT;
325
Simon Wunderlich2ec9c1f2013-07-11 18:07:46 +0200326 /* cf. IEEE 802.11 9.2.12 */
327 if (chan->band == IEEE80211_BAND_2GHZ && have_higher_than_11mbit)
328 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
329 else
330 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
331
Johannes Berg8fc214b2010-04-28 17:40:43 +0200332 sdata->vif.bss_conf.ibss_joined = true;
Sujith Manoharanc13a7652012-10-12 17:35:45 +0530333 sdata->vif.bss_conf.ibss_creator = creator;
Johannes Berg2d0ddec2009-04-23 16:13:26 +0200334 ieee80211_bss_info_change_notify(sdata, bss_change);
Johannes Berg46900292009-02-15 12:44:28 +0100335
Simon Wunderlich2ec9c1f2013-07-11 18:07:46 +0200336 ieee80211_set_wmm_default(sdata, true);
Johannes Berg46900292009-02-15 12:44:28 +0100337
Johannes Berg46900292009-02-15 12:44:28 +0100338 ifibss->state = IEEE80211_IBSS_MLME_JOINED;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200339 mod_timer(&ifibss->timer,
340 round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
Johannes Berg46900292009-02-15 12:44:28 +0100341
Simon Wunderlich7ca15a02013-07-08 16:55:56 +0200342 scan_width = cfg80211_chandef_to_scan_width(&chandef);
343 bss = cfg80211_inform_bss_width_frame(local->hw.wiphy, chan,
344 scan_width, mgmt,
345 presp->head_len, 0, GFP_KERNEL);
Johannes Berg5b112d32013-02-01 01:49:58 +0100346 cfg80211_put_bss(local->hw.wiphy, bss);
Eliad Peller86a2ea42011-11-08 15:36:59 +0200347 netif_carrier_on(sdata->dev);
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200348 cfg80211_ibss_joined(sdata->dev, ifibss->bssid, GFP_KERNEL);
Johannes Berg46900292009-02-15 12:44:28 +0100349}
350
Johannes Bergaf8cdcd2009-04-19 21:25:43 +0200351static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
352 struct ieee80211_bss *bss)
Johannes Berg46900292009-02-15 12:44:28 +0100353{
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100354 struct cfg80211_bss *cbss =
355 container_of((void *)bss, struct cfg80211_bss, priv);
Johannes Bergb59066a2009-05-12 21:18:38 +0200356 struct ieee80211_supported_band *sband;
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200357 struct cfg80211_chan_def chandef;
Johannes Bergb59066a2009-05-12 21:18:38 +0200358 u32 basic_rates;
359 int i, j;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100360 u16 beacon_int = cbss->beacon_interval;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100361 const struct cfg80211_bss_ies *ies;
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200362 enum nl80211_channel_type chan_type;
Johannes Berg8cef2c92013-02-05 16:54:31 +0100363 u64 tsf;
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200364 u32 rate_flags;
365 int shift;
Johannes Berg57c4d7b2009-04-23 16:10:04 +0200366
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200367 sdata_assert_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +0200368
Johannes Berg57c4d7b2009-04-23 16:10:04 +0200369 if (beacon_int < 10)
370 beacon_int = 10;
371
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200372 switch (sdata->u.ibss.chandef.width) {
373 case NL80211_CHAN_WIDTH_20_NOHT:
374 case NL80211_CHAN_WIDTH_20:
375 case NL80211_CHAN_WIDTH_40:
376 chan_type = cfg80211_get_chandef_type(&sdata->u.ibss.chandef);
377 cfg80211_chandef_create(&chandef, cbss->channel, chan_type);
378 break;
379 case NL80211_CHAN_WIDTH_5:
380 case NL80211_CHAN_WIDTH_10:
381 cfg80211_chandef_create(&chandef, cbss->channel,
382 NL80211_CHAN_WIDTH_20_NOHT);
383 chandef.width = sdata->u.ibss.chandef.width;
384 break;
385 default:
386 /* fall back to 20 MHz for unsupported modes */
387 cfg80211_chandef_create(&chandef, cbss->channel,
388 NL80211_CHAN_WIDTH_20_NOHT);
389 break;
390 }
391
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100392 sband = sdata->local->hw.wiphy->bands[cbss->channel->band];
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200393 rate_flags = ieee80211_chandef_rate_flags(&sdata->u.ibss.chandef);
394 shift = ieee80211_vif_get_shift(&sdata->vif);
Johannes Bergb59066a2009-05-12 21:18:38 +0200395
396 basic_rates = 0;
397
398 for (i = 0; i < bss->supp_rates_len; i++) {
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200399 int rate = bss->supp_rates[i] & 0x7f;
Johannes Bergb59066a2009-05-12 21:18:38 +0200400 bool is_basic = !!(bss->supp_rates[i] & 0x80);
401
402 for (j = 0; j < sband->n_bitrates; j++) {
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200403 int brate;
404 if ((rate_flags & sband->bitrates[j].flags)
405 != rate_flags)
406 continue;
407
408 brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
409 5 * (1 << shift));
410 if (brate == rate) {
Johannes Bergb59066a2009-05-12 21:18:38 +0200411 if (is_basic)
412 basic_rates |= BIT(j);
413 break;
414 }
415 }
416 }
417
Johannes Berg8cef2c92013-02-05 16:54:31 +0100418 rcu_read_lock();
419 ies = rcu_dereference(cbss->ies);
420 tsf = ies->tsf;
421 rcu_read_unlock();
422
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100423 __ieee80211_sta_join_ibss(sdata, cbss->bssid,
Johannes Berg57c4d7b2009-04-23 16:10:04 +0200424 beacon_int,
Simon Wunderlich75a423f2013-08-21 15:30:25 +0200425 &chandef,
Johannes Bergb59066a2009-05-12 21:18:38 +0200426 basic_rates,
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100427 cbss->capability,
Johannes Berg8cef2c92013-02-05 16:54:31 +0100428 tsf, false);
Johannes Berg46900292009-02-15 12:44:28 +0100429}
430
Simon Wunderlichcd7760e2013-08-28 13:41:31 +0200431int ieee80211_ibss_csa_beacon(struct ieee80211_sub_if_data *sdata,
432 struct cfg80211_csa_settings *csa_settings)
433{
434 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
435 struct beacon_data *presp, *old_presp;
436 struct cfg80211_bss *cbss;
437 const struct cfg80211_bss_ies *ies;
438 u16 capability;
439 u64 tsf;
440 int ret = 0;
441
442 sdata_assert_lock(sdata);
443
444 capability = WLAN_CAPABILITY_IBSS;
445
446 if (ifibss->privacy)
447 capability |= WLAN_CAPABILITY_PRIVACY;
448
449 cbss = cfg80211_get_bss(sdata->local->hw.wiphy, ifibss->chandef.chan,
450 ifibss->bssid, ifibss->ssid,
451 ifibss->ssid_len, WLAN_CAPABILITY_IBSS |
452 WLAN_CAPABILITY_PRIVACY,
453 capability);
454
455 if (WARN_ON(!cbss)) {
456 ret = -EINVAL;
457 goto out;
458 }
459
460 rcu_read_lock();
461 ies = rcu_dereference(cbss->ies);
462 tsf = ies->tsf;
463 rcu_read_unlock();
464 cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
465
466 old_presp = rcu_dereference_protected(ifibss->presp,
467 lockdep_is_held(&sdata->wdev.mtx));
468
469 presp = ieee80211_ibss_build_presp(sdata,
470 sdata->vif.bss_conf.beacon_int,
471 sdata->vif.bss_conf.basic_rates,
472 capability, tsf, &ifibss->chandef,
473 NULL, csa_settings);
474 if (!presp) {
475 ret = -ENOMEM;
476 goto out;
477 }
478
479 rcu_assign_pointer(ifibss->presp, presp);
480 if (old_presp)
481 kfree_rcu(old_presp, rcu_head);
482
483 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
484 out:
485 return ret;
486}
487
488int ieee80211_ibss_finish_csa(struct ieee80211_sub_if_data *sdata)
489{
490 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
491 struct cfg80211_bss *cbss;
492 int err;
493 u16 capability;
494
495 sdata_lock(sdata);
496 /* update cfg80211 bss information with the new channel */
497 if (!is_zero_ether_addr(ifibss->bssid)) {
498 capability = WLAN_CAPABILITY_IBSS;
499
500 if (ifibss->privacy)
501 capability |= WLAN_CAPABILITY_PRIVACY;
502
503 cbss = cfg80211_get_bss(sdata->local->hw.wiphy,
504 ifibss->chandef.chan,
505 ifibss->bssid, ifibss->ssid,
506 ifibss->ssid_len, WLAN_CAPABILITY_IBSS |
507 WLAN_CAPABILITY_PRIVACY,
508 capability);
509 /* XXX: should not really modify cfg80211 data */
510 if (cbss) {
511 cbss->channel = sdata->local->csa_chandef.chan;
512 cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
513 }
514 }
515
516 ifibss->chandef = sdata->local->csa_chandef;
517
518 /* generate the beacon */
519 err = ieee80211_ibss_csa_beacon(sdata, NULL);
520 sdata_unlock(sdata);
521 if (err < 0)
522 return err;
523
524 return 0;
525}
526
527void ieee80211_ibss_stop(struct ieee80211_sub_if_data *sdata)
528{
529 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
530
531 cancel_work_sync(&ifibss->csa_connection_drop_work);
532}
533
Antonio Quartulli52874a52013-06-18 14:20:40 +0200534static struct sta_info *ieee80211_ibss_finish_sta(struct sta_info *sta)
Johannes Berg8bf11d82011-12-15 11:17:37 +0100535 __acquires(RCU)
536{
537 struct ieee80211_sub_if_data *sdata = sta->sdata;
538 u8 addr[ETH_ALEN];
539
540 memcpy(addr, sta->sta.addr, ETH_ALEN);
541
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200542 ibss_dbg(sdata, "Adding new IBSS station %pM\n", addr);
Johannes Berg8bf11d82011-12-15 11:17:37 +0100543
Johannes Berg83d5cc02012-01-12 09:31:10 +0100544 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
545 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
Antonio Quartulli267335d2012-01-31 20:25:47 +0100546 /* authorize the station only if the network is not RSN protected. If
547 * not wait for the userspace to authorize it */
548 if (!sta->sdata->u.ibss.control_port)
549 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
Johannes Berg8bf11d82011-12-15 11:17:37 +0100550
551 rate_control_rate_init(sta);
552
553 /* If it fails, maybe we raced another insertion? */
554 if (sta_info_insert_rcu(sta))
555 return sta_info_get(sdata, addr);
556 return sta;
557}
558
559static struct sta_info *
Antonio Quartulli52874a52013-06-18 14:20:40 +0200560ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata, const u8 *bssid,
561 const u8 *addr, u32 supp_rates)
Johannes Berg8bf11d82011-12-15 11:17:37 +0100562 __acquires(RCU)
563{
564 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
565 struct ieee80211_local *local = sdata->local;
566 struct sta_info *sta;
Johannes Berg55de9082012-07-26 17:24:39 +0200567 struct ieee80211_chanctx_conf *chanctx_conf;
Ashok Nagarajanb422c6c2013-05-10 17:50:51 -0700568 struct ieee80211_supported_band *sband;
Simon Wunderlich74608ac2013-07-08 16:55:54 +0200569 enum nl80211_bss_scan_width scan_width;
Johannes Berg55de9082012-07-26 17:24:39 +0200570 int band;
Johannes Berg8bf11d82011-12-15 11:17:37 +0100571
572 /*
573 * XXX: Consider removing the least recently used entry and
574 * allow new one to be added.
575 */
576 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200577 net_info_ratelimited("%s: No room for a new IBSS STA entry %pM\n",
Joe Perchese87cc472012-05-13 21:56:26 +0000578 sdata->name, addr);
Johannes Berg8bf11d82011-12-15 11:17:37 +0100579 rcu_read_lock();
580 return NULL;
581 }
582
583 if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH) {
584 rcu_read_lock();
585 return NULL;
586 }
587
Joe Perchesb203ca32012-05-08 18:56:52 +0000588 if (!ether_addr_equal(bssid, sdata->u.ibss.bssid)) {
Johannes Berg8bf11d82011-12-15 11:17:37 +0100589 rcu_read_lock();
590 return NULL;
591 }
592
Johannes Berg55de9082012-07-26 17:24:39 +0200593 rcu_read_lock();
594 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
595 if (WARN_ON_ONCE(!chanctx_conf))
596 return NULL;
Johannes Berg4bf88532012-11-09 11:39:59 +0100597 band = chanctx_conf->def.chan->band;
Simon Wunderlich74608ac2013-07-08 16:55:54 +0200598 scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
Johannes Berg55de9082012-07-26 17:24:39 +0200599 rcu_read_unlock();
600
Johannes Berg8bf11d82011-12-15 11:17:37 +0100601 sta = sta_info_alloc(sdata, addr, GFP_KERNEL);
602 if (!sta) {
603 rcu_read_lock();
604 return NULL;
605 }
606
607 sta->last_rx = jiffies;
608
609 /* make sure mandatory rates are always added */
Ashok Nagarajanb422c6c2013-05-10 17:50:51 -0700610 sband = local->hw.wiphy->bands[band];
Johannes Berg8bf11d82011-12-15 11:17:37 +0100611 sta->sta.supp_rates[band] = supp_rates |
Simon Wunderlich74608ac2013-07-08 16:55:54 +0200612 ieee80211_mandatory_rates(sband, scan_width);
Johannes Berg8bf11d82011-12-15 11:17:37 +0100613
Antonio Quartulli52874a52013-06-18 14:20:40 +0200614 return ieee80211_ibss_finish_sta(sta);
Antonio Quartulli6d810f12012-01-18 00:10:44 +0100615}
616
Simon Wunderlich871a4182013-08-28 13:41:30 +0200617static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
618{
619 struct ieee80211_local *local = sdata->local;
620 int active = 0;
621 struct sta_info *sta;
622
623 sdata_assert_lock(sdata);
624
625 rcu_read_lock();
626
627 list_for_each_entry_rcu(sta, &local->sta_list, list) {
628 if (sta->sdata == sdata &&
629 time_after(sta->last_rx + IEEE80211_IBSS_MERGE_INTERVAL,
630 jiffies)) {
631 active++;
632 break;
633 }
634 }
635
636 rcu_read_unlock();
637
638 return active;
639}
640
641static void ieee80211_ibss_disconnect(struct ieee80211_sub_if_data *sdata)
642{
643 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
644 struct ieee80211_local *local = sdata->local;
645 struct cfg80211_bss *cbss;
646 struct beacon_data *presp;
647 struct sta_info *sta;
648 int active_ibss;
649 u16 capability;
650
651 active_ibss = ieee80211_sta_active_ibss(sdata);
652
653 if (!active_ibss && !is_zero_ether_addr(ifibss->bssid)) {
654 capability = WLAN_CAPABILITY_IBSS;
655
656 if (ifibss->privacy)
657 capability |= WLAN_CAPABILITY_PRIVACY;
658
659 cbss = cfg80211_get_bss(local->hw.wiphy, ifibss->chandef.chan,
660 ifibss->bssid, ifibss->ssid,
661 ifibss->ssid_len, WLAN_CAPABILITY_IBSS |
662 WLAN_CAPABILITY_PRIVACY,
663 capability);
664
665 if (cbss) {
666 cfg80211_unlink_bss(local->hw.wiphy, cbss);
667 cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
668 }
669 }
670
671 ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
672
673 sta_info_flush(sdata);
674
675 spin_lock_bh(&ifibss->incomplete_lock);
676 while (!list_empty(&ifibss->incomplete_stations)) {
677 sta = list_first_entry(&ifibss->incomplete_stations,
678 struct sta_info, list);
679 list_del(&sta->list);
680 spin_unlock_bh(&ifibss->incomplete_lock);
681
682 sta_info_free(local, sta);
683 spin_lock_bh(&ifibss->incomplete_lock);
684 }
685 spin_unlock_bh(&ifibss->incomplete_lock);
686
687 netif_carrier_off(sdata->dev);
688
689 sdata->vif.bss_conf.ibss_joined = false;
690 sdata->vif.bss_conf.ibss_creator = false;
691 sdata->vif.bss_conf.enable_beacon = false;
692 sdata->vif.bss_conf.ssid_len = 0;
693
694 /* remove beacon */
695 presp = rcu_dereference_protected(ifibss->presp,
696 lockdep_is_held(&sdata->wdev.mtx));
697 RCU_INIT_POINTER(sdata->u.ibss.presp, NULL);
698 if (presp)
699 kfree_rcu(presp, rcu_head);
700
701 clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
702 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
703 BSS_CHANGED_IBSS);
704 ieee80211_vif_release_channel(sdata);
705}
706
Simon Wunderlichcd7760e2013-08-28 13:41:31 +0200707static void ieee80211_csa_connection_drop_work(struct work_struct *work)
708{
709 struct ieee80211_sub_if_data *sdata =
710 container_of(work, struct ieee80211_sub_if_data,
711 u.ibss.csa_connection_drop_work);
712
713 ieee80211_ibss_disconnect(sdata);
714 synchronize_rcu();
715 skb_queue_purge(&sdata->skb_queue);
716
717 /* trigger a scan to find another IBSS network to join */
718 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
719}
720
721static bool
722ieee80211_ibss_process_chanswitch(struct ieee80211_sub_if_data *sdata,
723 struct ieee802_11_elems *elems,
724 bool beacon)
725{
726 struct cfg80211_csa_settings params;
727 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
728 struct ieee80211_chanctx_conf *chanctx_conf;
729 struct ieee80211_chanctx *chanctx;
730 enum nl80211_channel_type ch_type;
731 int err, num_chanctx;
732 u32 sta_flags;
733 u8 mode;
734
735 if (sdata->vif.csa_active)
736 return true;
737
738 if (!sdata->vif.bss_conf.ibss_joined)
739 return false;
740
741 sta_flags = IEEE80211_STA_DISABLE_VHT;
742 switch (ifibss->chandef.width) {
743 case NL80211_CHAN_WIDTH_5:
744 case NL80211_CHAN_WIDTH_10:
745 case NL80211_CHAN_WIDTH_20_NOHT:
746 sta_flags |= IEEE80211_STA_DISABLE_HT;
747 /* fall through */
748 case NL80211_CHAN_WIDTH_20:
749 sta_flags |= IEEE80211_STA_DISABLE_40MHZ;
750 break;
751 default:
752 break;
753 }
754
755 memset(&params, 0, sizeof(params));
756 err = ieee80211_parse_ch_switch_ie(sdata, elems, beacon,
757 ifibss->chandef.chan->band,
758 sta_flags, ifibss->bssid,
759 &params.count, &mode,
760 &params.chandef);
761
762 /* can't switch to destination channel, fail */
763 if (err < 0)
764 goto disconnect;
765
766 /* did not contain a CSA */
767 if (err)
768 return false;
769
770 if (ifibss->chandef.chan->band != params.chandef.chan->band)
771 goto disconnect;
772
773 switch (ifibss->chandef.width) {
774 case NL80211_CHAN_WIDTH_20_NOHT:
775 case NL80211_CHAN_WIDTH_20:
776 case NL80211_CHAN_WIDTH_40:
777 /* keep our current HT mode (HT20/HT40+/HT40-), even if
778 * another mode has been announced. The mode is not adopted
779 * within the beacon while doing CSA and we should therefore
780 * keep the mode which we announce.
781 */
782 ch_type = cfg80211_get_chandef_type(&ifibss->chandef);
783 cfg80211_chandef_create(&params.chandef, params.chandef.chan,
784 ch_type);
785 break;
786 case NL80211_CHAN_WIDTH_5:
787 case NL80211_CHAN_WIDTH_10:
788 if (params.chandef.width != ifibss->chandef.width) {
789 sdata_info(sdata,
790 "IBSS %pM received channel switch from incompatible channel width (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n",
791 ifibss->bssid,
792 params.chandef.chan->center_freq,
793 params.chandef.width,
794 params.chandef.center_freq1,
795 params.chandef.center_freq2);
796 goto disconnect;
797 }
798 break;
799 default:
800 /* should not happen, sta_flags should prevent VHT modes. */
801 WARN_ON(1);
802 goto disconnect;
803 }
804
805 if (!cfg80211_chandef_usable(sdata->local->hw.wiphy, &params.chandef,
806 IEEE80211_CHAN_DISABLED)) {
807 sdata_info(sdata,
808 "IBSS %pM switches to unsupported channel (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n",
809 ifibss->bssid,
810 params.chandef.chan->center_freq,
811 params.chandef.width,
812 params.chandef.center_freq1,
813 params.chandef.center_freq2);
814 goto disconnect;
815 }
816
817 err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
818 &params.chandef);
819 if (err < 0)
820 goto disconnect;
821 if (err) {
822 params.radar_required = true;
823
824 /* TODO: IBSS-DFS not (yet) supported, disconnect. */
825 goto disconnect;
826 }
827
828 rcu_read_lock();
829 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
830 if (!chanctx_conf) {
831 rcu_read_unlock();
832 goto disconnect;
833 }
834
835 /* don't handle for multi-VIF cases */
836 chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
837 if (chanctx->refcount > 1) {
838 rcu_read_unlock();
839 goto disconnect;
840 }
841 num_chanctx = 0;
842 list_for_each_entry_rcu(chanctx, &sdata->local->chanctx_list, list)
843 num_chanctx++;
844
845 if (num_chanctx > 1) {
846 rcu_read_unlock();
847 goto disconnect;
848 }
849 rcu_read_unlock();
850
851 /* all checks done, now perform the channel switch. */
852 ibss_dbg(sdata,
853 "received channel switch announcement to go to channel %d MHz\n",
854 params.chandef.chan->center_freq);
855
856 params.block_tx = !!mode;
857
858 ieee80211_ibss_csa_beacon(sdata, &params);
859 sdata->csa_radar_required = params.radar_required;
860
861 if (params.block_tx)
862 ieee80211_stop_queues_by_reason(&sdata->local->hw,
863 IEEE80211_MAX_QUEUE_MAP,
864 IEEE80211_QUEUE_STOP_REASON_CSA);
865
866 sdata->local->csa_chandef = params.chandef;
867 sdata->vif.csa_active = true;
868
869 ieee80211_bss_info_change_notify(sdata, err);
870 drv_channel_switch_beacon(sdata, &params.chandef);
871
872 return true;
873disconnect:
874 ibss_dbg(sdata, "Can't handle channel switch, disconnect\n");
875 ieee80211_queue_work(&sdata->local->hw,
876 &ifibss->csa_connection_drop_work);
877
878 return true;
879}
880
881static void
882ieee80211_rx_mgmt_spectrum_mgmt(struct ieee80211_sub_if_data *sdata,
883 struct ieee80211_mgmt *mgmt, size_t len,
884 struct ieee80211_rx_status *rx_status,
885 struct ieee802_11_elems *elems)
886{
887 int required_len;
888
889 if (len < IEEE80211_MIN_ACTION_SIZE + 1)
890 return;
891
892 /* CSA is the only action we handle for now */
893 if (mgmt->u.action.u.measurement.action_code !=
894 WLAN_ACTION_SPCT_CHL_SWITCH)
895 return;
896
897 required_len = IEEE80211_MIN_ACTION_SIZE +
898 sizeof(mgmt->u.action.u.chan_switch);
899 if (len < required_len)
900 return;
901
902 ieee80211_ibss_process_chanswitch(sdata, elems, false);
903}
904
Antonio Quartulli2cc59e72012-09-07 13:28:53 +0200905static void ieee80211_rx_mgmt_deauth_ibss(struct ieee80211_sub_if_data *sdata,
906 struct ieee80211_mgmt *mgmt,
907 size_t len)
908{
909 u16 reason = le16_to_cpu(mgmt->u.deauth.reason_code);
910
911 if (len < IEEE80211_DEAUTH_FRAME_LEN)
912 return;
913
914 ibss_dbg(sdata, "RX DeAuth SA=%pM DA=%pM BSSID=%pM (reason: %d)\n",
915 mgmt->sa, mgmt->da, mgmt->bssid, reason);
916 sta_info_destroy_addr(sdata, mgmt->sa);
917}
918
Antonio Quartulli6d810f12012-01-18 00:10:44 +0100919static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
920 struct ieee80211_mgmt *mgmt,
921 size_t len)
922{
923 u16 auth_alg, auth_transaction;
924
Johannes Berg8d61ffa2013-05-10 12:32:47 +0200925 sdata_assert_lock(sdata);
Antonio Quartulli6d810f12012-01-18 00:10:44 +0100926
927 if (len < 24 + 6)
928 return;
929
930 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
931 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
932
Johannes Bergbdcbd8e2012-06-22 11:29:50 +0200933 ibss_dbg(sdata,
934 "RX Auth SA=%pM DA=%pM BSSID=%pM (auth_transaction=%d)\n",
935 mgmt->sa, mgmt->da, mgmt->bssid, auth_transaction);
Antonio Quartulli7bed2052012-11-25 23:24:27 +0100936
937 if (auth_alg != WLAN_AUTH_OPEN || auth_transaction != 1)
938 return;
939
Antonio Quartulli2cc59e72012-09-07 13:28:53 +0200940 /*
Antonio Quartulli6d810f12012-01-18 00:10:44 +0100941 * IEEE 802.11 standard does not require authentication in IBSS
942 * networks and most implementations do not seem to use it.
943 * However, try to reply to authentication attempts if someone
944 * has actually implemented this.
945 */
Jouni Malinen700e8ea2012-09-30 19:29:37 +0300946 ieee80211_send_auth(sdata, 2, WLAN_AUTH_OPEN, 0, NULL, 0,
Johannes Berg1672c0e32013-01-29 15:02:27 +0100947 mgmt->sa, sdata->u.ibss.bssid, NULL, 0, 0, 0);
Johannes Berg8bf11d82011-12-15 11:17:37 +0100948}
949
Johannes Berg46900292009-02-15 12:44:28 +0100950static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +0200951 struct ieee80211_mgmt *mgmt, size_t len,
Johannes Berg46900292009-02-15 12:44:28 +0100952 struct ieee80211_rx_status *rx_status,
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +0200953 struct ieee802_11_elems *elems)
Johannes Berg46900292009-02-15 12:44:28 +0100954{
955 struct ieee80211_local *local = sdata->local;
956 int freq;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100957 struct cfg80211_bss *cbss;
Johannes Berg46900292009-02-15 12:44:28 +0100958 struct ieee80211_bss *bss;
959 struct sta_info *sta;
960 struct ieee80211_channel *channel;
961 u64 beacon_timestamp, rx_timestamp;
962 u32 supp_rates = 0;
963 enum ieee80211_band band = rx_status->band;
Simon Wunderlich74608ac2013-07-08 16:55:54 +0200964 enum nl80211_bss_scan_width scan_width;
Alexander Simon13c40c52011-11-30 16:56:34 +0100965 struct ieee80211_supported_band *sband = local->hw.wiphy->bands[band];
966 bool rates_updated = false;
Johannes Berg46900292009-02-15 12:44:28 +0100967
Johannes Berg1cd8e882013-03-27 14:30:12 +0100968 if (elems->ds_params)
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900969 freq = ieee80211_channel_to_frequency(elems->ds_params[0],
970 band);
Johannes Berg46900292009-02-15 12:44:28 +0100971 else
972 freq = rx_status->freq;
973
974 channel = ieee80211_get_channel(local->hw.wiphy, freq);
975
976 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
977 return;
978
Bruno Randolf9eba6122010-10-04 11:17:30 +0900979 if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
Joe Perchesb203ca32012-05-08 18:56:52 +0000980 ether_addr_equal(mgmt->bssid, sdata->u.ibss.bssid)) {
Johannes Berg46900292009-02-15 12:44:28 +0100981
982 rcu_read_lock();
Johannes Bergabe60632009-11-25 17:46:18 +0100983 sta = sta_info_get(sdata, mgmt->sa);
Johannes Berg46900292009-02-15 12:44:28 +0100984
Bruno Randolf9eba6122010-10-04 11:17:30 +0900985 if (elems->supp_rates) {
Simon Wunderlich2103dec2013-07-08 16:55:53 +0200986 supp_rates = ieee80211_sta_get_rates(sdata, elems,
Ashok Nagarajan9ebb61a2012-04-02 21:21:21 -0700987 band, NULL);
Bruno Randolf9eba6122010-10-04 11:17:30 +0900988 if (sta) {
989 u32 prev_rates;
Johannes Berg46900292009-02-15 12:44:28 +0100990
Bruno Randolf9eba6122010-10-04 11:17:30 +0900991 prev_rates = sta->sta.supp_rates[band];
992 /* make sure mandatory rates are always added */
Simon Wunderlich74608ac2013-07-08 16:55:54 +0200993 scan_width = NL80211_BSS_CHAN_WIDTH_20;
994 if (rx_status->flag & RX_FLAG_5MHZ)
995 scan_width = NL80211_BSS_CHAN_WIDTH_5;
996 if (rx_status->flag & RX_FLAG_10MHZ)
997 scan_width = NL80211_BSS_CHAN_WIDTH_10;
Bruno Randolf9eba6122010-10-04 11:17:30 +0900998
Simon Wunderlich74608ac2013-07-08 16:55:54 +0200999 sta->sta.supp_rates[band] = supp_rates |
1000 ieee80211_mandatory_rates(sband,
1001 scan_width);
Bruno Randolf9eba6122010-10-04 11:17:30 +09001002 if (sta->sta.supp_rates[band] != prev_rates) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001003 ibss_dbg(sdata,
1004 "updated supp_rates set for %pM based on beacon/probe_resp (0x%x -> 0x%x)\n",
1005 sta->sta.addr, prev_rates,
1006 sta->sta.supp_rates[band]);
Alexander Simon13c40c52011-11-30 16:56:34 +01001007 rates_updated = true;
Bruno Randolf9eba6122010-10-04 11:17:30 +09001008 }
Johannes Berg8bf11d82011-12-15 11:17:37 +01001009 } else {
1010 rcu_read_unlock();
Bruno Randolf9eba6122010-10-04 11:17:30 +09001011 sta = ieee80211_ibss_add_sta(sdata, mgmt->bssid,
Antonio Quartulli52874a52013-06-18 14:20:40 +02001012 mgmt->sa, supp_rates);
Johannes Berg8bf11d82011-12-15 11:17:37 +01001013 }
Johannes Berg34e89502010-02-03 13:59:58 +01001014 }
Bruno Randolf9eba6122010-10-04 11:17:30 +09001015
1016 if (sta && elems->wmm_info)
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001017 set_sta_flag(sta, WLAN_STA_WME);
Bruno Randolf9eba6122010-10-04 11:17:30 +09001018
Johannes Berg074d46d2012-03-15 19:45:16 +01001019 if (sta && elems->ht_operation && elems->ht_cap_elem &&
Simon Wunderlich3aede782013-05-16 13:00:36 +02001020 sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
1021 sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_5 &&
1022 sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_10) {
Alexander Simon13c40c52011-11-30 16:56:34 +01001023 /* we both use HT */
Johannes Berge1a0c6b2013-02-07 11:47:44 +01001024 struct ieee80211_ht_cap htcap_ie;
Johannes Berg4bf88532012-11-09 11:39:59 +01001025 struct cfg80211_chan_def chandef;
1026
1027 ieee80211_ht_oper_to_chandef(channel,
1028 elems->ht_operation,
1029 &chandef);
Alexander Simon13c40c52011-11-30 16:56:34 +01001030
Johannes Berge1a0c6b2013-02-07 11:47:44 +01001031 memcpy(&htcap_ie, elems->ht_cap_elem, sizeof(htcap_ie));
Alexander Simon13c40c52011-11-30 16:56:34 +01001032
1033 /*
1034 * fall back to HT20 if we don't use or use
1035 * the other extension channel
1036 */
Simon Wunderlich3aede782013-05-16 13:00:36 +02001037 if (chandef.center_freq1 !=
1038 sdata->u.ibss.chandef.center_freq1)
Johannes Berge1a0c6b2013-02-07 11:47:44 +01001039 htcap_ie.cap_info &=
1040 cpu_to_le16(~IEEE80211_HT_CAP_SUP_WIDTH_20_40);
Alexander Simon13c40c52011-11-30 16:56:34 +01001041
Johannes Berge1a0c6b2013-02-07 11:47:44 +01001042 rates_updated |= ieee80211_ht_cap_ie_to_sta_ht_cap(
1043 sdata, sband, &htcap_ie, sta);
Alexander Simon13c40c52011-11-30 16:56:34 +01001044 }
1045
Antonio Quartullie687f612012-08-12 18:24:55 +02001046 if (sta && rates_updated) {
1047 drv_sta_rc_update(local, sdata, &sta->sta,
1048 IEEE80211_RC_SUPP_RATES_CHANGED);
Alexander Simon13c40c52011-11-30 16:56:34 +01001049 rate_control_rate_init(sta);
Antonio Quartullie687f612012-08-12 18:24:55 +02001050 }
Alexander Simon13c40c52011-11-30 16:56:34 +01001051
Bruno Randolf9eba6122010-10-04 11:17:30 +09001052 rcu_read_unlock();
Johannes Berg46900292009-02-15 12:44:28 +01001053 }
1054
1055 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +02001056 channel);
Johannes Berg46900292009-02-15 12:44:28 +01001057 if (!bss)
1058 return;
1059
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001060 cbss = container_of((void *)bss, struct cfg80211_bss, priv);
1061
Johannes Berg8cef2c92013-02-05 16:54:31 +01001062 /* same for beacon and probe response */
1063 beacon_timestamp = le64_to_cpu(mgmt->u.beacon.timestamp);
Johannes Berg46900292009-02-15 12:44:28 +01001064
1065 /* check if we need to merge IBSS */
1066
Johannes Berg46900292009-02-15 12:44:28 +01001067 /* not an IBSS */
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001068 if (!(cbss->capability & WLAN_CAPABILITY_IBSS))
Johannes Berg46900292009-02-15 12:44:28 +01001069 goto put_bss;
1070
1071 /* different channel */
Johannes Berg55de9082012-07-26 17:24:39 +02001072 if (sdata->u.ibss.fixed_channel &&
Simon Wunderlich3aede782013-05-16 13:00:36 +02001073 sdata->u.ibss.chandef.chan != cbss->channel)
Johannes Berg46900292009-02-15 12:44:28 +01001074 goto put_bss;
1075
1076 /* different SSID */
1077 if (elems->ssid_len != sdata->u.ibss.ssid_len ||
1078 memcmp(elems->ssid, sdata->u.ibss.ssid,
1079 sdata->u.ibss.ssid_len))
1080 goto put_bss;
1081
Simon Wunderlichcd7760e2013-08-28 13:41:31 +02001082 /* process channel switch */
1083 if (ieee80211_ibss_process_chanswitch(sdata, elems, true))
1084 goto put_bss;
1085
Alina Friedrichsen34e8f082009-02-22 00:07:28 +01001086 /* same BSSID */
Joe Perchesb203ca32012-05-08 18:56:52 +00001087 if (ether_addr_equal(cbss->bssid, sdata->u.ibss.bssid))
Alina Friedrichsen34e8f082009-02-22 00:07:28 +01001088 goto put_bss;
1089
Simon Wunderlichcd7760e2013-08-28 13:41:31 +02001090 /* we use a fixed BSSID */
1091 if (sdata->u.ibss.fixed_bssid)
1092 goto put_bss;
1093
Thomas Pedersenf4bda332012-11-13 10:46:27 -08001094 if (ieee80211_have_rx_timestamp(rx_status)) {
1095 /* time when timestamp field was received */
1096 rx_timestamp =
1097 ieee80211_calculate_rx_timestamp(local, rx_status,
1098 len + FCS_LEN, 24);
Johannes Berg24487982009-04-23 18:52:52 +02001099 } else {
1100 /*
1101 * second best option: get current TSF
1102 * (will return -1 if not supported)
1103 */
Eliad Peller37a41b42011-09-21 14:06:11 +03001104 rx_timestamp = drv_get_tsf(local, sdata);
Johannes Berg24487982009-04-23 18:52:52 +02001105 }
Johannes Berg46900292009-02-15 12:44:28 +01001106
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001107 ibss_dbg(sdata,
1108 "RX beacon SA=%pM BSSID=%pM TSF=0x%llx BCN=0x%llx diff=%lld @%lu\n",
1109 mgmt->sa, mgmt->bssid,
1110 (unsigned long long)rx_timestamp,
1111 (unsigned long long)beacon_timestamp,
1112 (unsigned long long)(rx_timestamp - beacon_timestamp),
1113 jiffies);
Johannes Berg46900292009-02-15 12:44:28 +01001114
1115 if (beacon_timestamp > rx_timestamp) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001116 ibss_dbg(sdata,
1117 "beacon TSF higher than local TSF - IBSS merge with BSSID %pM\n",
1118 mgmt->bssid);
Johannes Berg46900292009-02-15 12:44:28 +01001119 ieee80211_sta_join_ibss(sdata, bss);
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001120 supp_rates = ieee80211_sta_get_rates(sdata, elems, band, NULL);
Johannes Berg34e89502010-02-03 13:59:58 +01001121 ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa,
Antonio Quartulli52874a52013-06-18 14:20:40 +02001122 supp_rates);
Johannes Berg8bf11d82011-12-15 11:17:37 +01001123 rcu_read_unlock();
Johannes Berg46900292009-02-15 12:44:28 +01001124 }
1125
1126 put_bss:
1127 ieee80211_rx_bss_put(local, bss);
1128}
1129
Johannes Berg8bf11d82011-12-15 11:17:37 +01001130void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
1131 const u8 *bssid, const u8 *addr,
1132 u32 supp_rates)
Johannes Berg46900292009-02-15 12:44:28 +01001133{
Felix Fietkau2e10d332009-12-20 19:07:09 +01001134 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
Johannes Berg46900292009-02-15 12:44:28 +01001135 struct ieee80211_local *local = sdata->local;
1136 struct sta_info *sta;
Johannes Berg55de9082012-07-26 17:24:39 +02001137 struct ieee80211_chanctx_conf *chanctx_conf;
Ashok Nagarajanb422c6c2013-05-10 17:50:51 -07001138 struct ieee80211_supported_band *sband;
Simon Wunderlich74608ac2013-07-08 16:55:54 +02001139 enum nl80211_bss_scan_width scan_width;
Johannes Berg55de9082012-07-26 17:24:39 +02001140 int band;
Johannes Berg46900292009-02-15 12:44:28 +01001141
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001142 /*
1143 * XXX: Consider removing the least recently used entry and
1144 * allow new one to be added.
1145 */
Johannes Berg46900292009-02-15 12:44:28 +01001146 if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001147 net_info_ratelimited("%s: No room for a new IBSS STA entry %pM\n",
Joe Perchese87cc472012-05-13 21:56:26 +00001148 sdata->name, addr);
Johannes Berg8bf11d82011-12-15 11:17:37 +01001149 return;
Johannes Berg46900292009-02-15 12:44:28 +01001150 }
1151
Felix Fietkau2e10d332009-12-20 19:07:09 +01001152 if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH)
Johannes Berg8bf11d82011-12-15 11:17:37 +01001153 return;
Felix Fietkau2e10d332009-12-20 19:07:09 +01001154
Joe Perchesb203ca32012-05-08 18:56:52 +00001155 if (!ether_addr_equal(bssid, sdata->u.ibss.bssid))
Johannes Berg8bf11d82011-12-15 11:17:37 +01001156 return;
Johannes Berg46900292009-02-15 12:44:28 +01001157
Johannes Berg55de9082012-07-26 17:24:39 +02001158 rcu_read_lock();
1159 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
1160 if (WARN_ON_ONCE(!chanctx_conf)) {
1161 rcu_read_unlock();
1162 return;
1163 }
Johannes Berg4bf88532012-11-09 11:39:59 +01001164 band = chanctx_conf->def.chan->band;
Simon Wunderlich74608ac2013-07-08 16:55:54 +02001165 scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
Johannes Berg55de9082012-07-26 17:24:39 +02001166 rcu_read_unlock();
1167
Johannes Berg8bf11d82011-12-15 11:17:37 +01001168 sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
Johannes Berg46900292009-02-15 12:44:28 +01001169 if (!sta)
Johannes Berg8bf11d82011-12-15 11:17:37 +01001170 return;
Johannes Berg46900292009-02-15 12:44:28 +01001171
Rajkumar Manoharanc8716d92010-10-23 10:59:57 +05301172 sta->last_rx = jiffies;
Johannes Bergd9a7ddb2011-12-14 12:35:30 +01001173
Johannes Berg46900292009-02-15 12:44:28 +01001174 /* make sure mandatory rates are always added */
Ashok Nagarajanb422c6c2013-05-10 17:50:51 -07001175 sband = local->hw.wiphy->bands[band];
Johannes Berg46900292009-02-15 12:44:28 +01001176 sta->sta.supp_rates[band] = supp_rates |
Simon Wunderlich74608ac2013-07-08 16:55:54 +02001177 ieee80211_mandatory_rates(sband, scan_width);
Johannes Berg46900292009-02-15 12:44:28 +01001178
Johannes Berg8bf11d82011-12-15 11:17:37 +01001179 spin_lock(&ifibss->incomplete_lock);
1180 list_add(&sta->list, &ifibss->incomplete_stations);
1181 spin_unlock(&ifibss->incomplete_lock);
1182 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg46900292009-02-15 12:44:28 +01001183}
1184
Antonio Quartullidad9def2013-07-26 21:15:02 +02001185static void ieee80211_ibss_sta_expire(struct ieee80211_sub_if_data *sdata)
1186{
1187 struct ieee80211_local *local = sdata->local;
1188 struct sta_info *sta, *tmp;
1189 unsigned long exp_time = IEEE80211_IBSS_INACTIVITY_LIMIT;
1190 unsigned long exp_rsn_time = IEEE80211_IBSS_RSN_INACTIVITY_LIMIT;
1191
1192 mutex_lock(&local->sta_mtx);
1193
1194 list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1195 if (sdata != sta->sdata)
1196 continue;
1197
1198 if (time_after(jiffies, sta->last_rx + exp_time) ||
1199 (time_after(jiffies, sta->last_rx + exp_rsn_time) &&
1200 sta->sta_state != IEEE80211_STA_AUTHORIZED)) {
1201 sta_dbg(sta->sdata, "expiring inactive %sSTA %pM\n",
1202 sta->sta_state != IEEE80211_STA_AUTHORIZED ?
1203 "not authorized " : "", sta->sta.addr);
1204
1205 WARN_ON(__sta_info_destroy(sta));
1206 }
1207 }
1208
1209 mutex_unlock(&local->sta_mtx);
1210}
1211
Benoit Papillaultce9058a2010-01-17 22:45:23 +01001212/*
1213 * This function is called with state == IEEE80211_IBSS_MLME_JOINED
1214 */
Johannes Berg46900292009-02-15 12:44:28 +01001215
1216static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata)
1217{
1218 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +02001219 enum nl80211_bss_scan_width scan_width;
Johannes Berg46900292009-02-15 12:44:28 +01001220
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001221 sdata_assert_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +02001222
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001223 mod_timer(&ifibss->timer,
1224 round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
Johannes Berg46900292009-02-15 12:44:28 +01001225
Antonio Quartullidad9def2013-07-26 21:15:02 +02001226 ieee80211_ibss_sta_expire(sdata);
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001227
Sujith450aae32009-11-02 12:33:23 +05301228 if (time_before(jiffies, ifibss->last_scan_completed +
1229 IEEE80211_IBSS_MERGE_INTERVAL))
1230 return;
1231
Johannes Berg46900292009-02-15 12:44:28 +01001232 if (ieee80211_sta_active_ibss(sdata))
1233 return;
1234
John W. Linvillec037b832012-01-30 15:28:11 -05001235 if (ifibss->fixed_channel)
Johannes Berg46900292009-02-15 12:44:28 +01001236 return;
1237
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001238 sdata_info(sdata,
1239 "No active IBSS STAs - trying to scan for other IBSS networks with same SSID (merge)\n");
Johannes Berg46900292009-02-15 12:44:28 +01001240
Simon Wunderlich7ca15a02013-07-08 16:55:56 +02001241 scan_width = cfg80211_chandef_to_scan_width(&ifibss->chandef);
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +01001242 ieee80211_request_ibss_scan(sdata, ifibss->ssid, ifibss->ssid_len,
Simon Wunderlich7ca15a02013-07-08 16:55:56 +02001243 NULL, scan_width);
Johannes Berg46900292009-02-15 12:44:28 +01001244}
1245
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001246static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
Johannes Berg46900292009-02-15 12:44:28 +01001247{
1248 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
Johannes Berg46900292009-02-15 12:44:28 +01001249 u8 bssid[ETH_ALEN];
Johannes Berg46900292009-02-15 12:44:28 +01001250 u16 capability;
1251 int i;
1252
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001253 sdata_assert_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +02001254
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001255 if (ifibss->fixed_bssid) {
Johannes Berg46900292009-02-15 12:44:28 +01001256 memcpy(bssid, ifibss->bssid, ETH_ALEN);
1257 } else {
1258 /* Generate random, not broadcast, locally administered BSSID. Mix in
1259 * own MAC address to make sure that devices that do not have proper
1260 * random number generator get different BSSID. */
1261 get_random_bytes(bssid, ETH_ALEN);
1262 for (i = 0; i < ETH_ALEN; i++)
Johannes Berg47846c92009-11-25 17:46:19 +01001263 bssid[i] ^= sdata->vif.addr[i];
Johannes Berg46900292009-02-15 12:44:28 +01001264 bssid[0] &= ~0x01;
1265 bssid[0] |= 0x02;
1266 }
1267
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001268 sdata_info(sdata, "Creating new IBSS network, BSSID %pM\n", bssid);
Johannes Berg46900292009-02-15 12:44:28 +01001269
Johannes Berg46900292009-02-15 12:44:28 +01001270 capability = WLAN_CAPABILITY_IBSS;
1271
Johannes Bergfffd0932009-07-08 14:22:54 +02001272 if (ifibss->privacy)
Johannes Berg46900292009-02-15 12:44:28 +01001273 capability |= WLAN_CAPABILITY_PRIVACY;
1274 else
1275 sdata->drop_unencrypted = 0;
1276
Johannes Berg57c4d7b2009-04-23 16:10:04 +02001277 __ieee80211_sta_join_ibss(sdata, bssid, sdata->vif.bss_conf.beacon_int,
Simon Wunderlich75a423f2013-08-21 15:30:25 +02001278 &ifibss->chandef, ifibss->basic_rates,
Sujith Manoharanc13a7652012-10-12 17:35:45 +05301279 capability, 0, true);
Johannes Berg46900292009-02-15 12:44:28 +01001280}
1281
Benoit Papillaultce9058a2010-01-17 22:45:23 +01001282/*
1283 * This function is called with state == IEEE80211_IBSS_MLME_SEARCH
1284 */
1285
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001286static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
Johannes Berg46900292009-02-15 12:44:28 +01001287{
1288 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1289 struct ieee80211_local *local = sdata->local;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001290 struct cfg80211_bss *cbss;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001291 struct ieee80211_channel *chan = NULL;
Johannes Berg46900292009-02-15 12:44:28 +01001292 const u8 *bssid = NULL;
Simon Wunderlich7ca15a02013-07-08 16:55:56 +02001293 enum nl80211_bss_scan_width scan_width;
Johannes Berg46900292009-02-15 12:44:28 +01001294 int active_ibss;
Johannes Berge0d61882009-05-12 20:47:32 +02001295 u16 capability;
Johannes Berg46900292009-02-15 12:44:28 +01001296
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001297 sdata_assert_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +02001298
Johannes Berg46900292009-02-15 12:44:28 +01001299 active_ibss = ieee80211_sta_active_ibss(sdata);
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001300 ibss_dbg(sdata, "sta_find_ibss (active_ibss=%d)\n", active_ibss);
Johannes Berg46900292009-02-15 12:44:28 +01001301
1302 if (active_ibss)
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001303 return;
Johannes Berg46900292009-02-15 12:44:28 +01001304
Johannes Berge0d61882009-05-12 20:47:32 +02001305 capability = WLAN_CAPABILITY_IBSS;
Johannes Bergfffd0932009-07-08 14:22:54 +02001306 if (ifibss->privacy)
Johannes Berge0d61882009-05-12 20:47:32 +02001307 capability |= WLAN_CAPABILITY_PRIVACY;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001308 if (ifibss->fixed_bssid)
Johannes Berg46900292009-02-15 12:44:28 +01001309 bssid = ifibss->bssid;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001310 if (ifibss->fixed_channel)
Simon Wunderlich3aede782013-05-16 13:00:36 +02001311 chan = ifibss->chandef.chan;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001312 if (!is_zero_ether_addr(ifibss->bssid))
1313 bssid = ifibss->bssid;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001314 cbss = cfg80211_get_bss(local->hw.wiphy, chan, bssid,
1315 ifibss->ssid, ifibss->ssid_len,
1316 WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_PRIVACY,
1317 capability);
Johannes Berg46900292009-02-15 12:44:28 +01001318
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001319 if (cbss) {
1320 struct ieee80211_bss *bss;
1321
1322 bss = (void *)cbss->priv;
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001323 ibss_dbg(sdata,
1324 "sta_find_ibss: selected %pM current %pM\n",
1325 cbss->bssid, ifibss->bssid);
1326 sdata_info(sdata,
1327 "Selected IBSS BSSID %pM based on configured SSID\n",
1328 cbss->bssid);
Johannes Berg46900292009-02-15 12:44:28 +01001329
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001330 ieee80211_sta_join_ibss(sdata, bss);
Johannes Berg46900292009-02-15 12:44:28 +01001331 ieee80211_rx_bss_put(local, bss);
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001332 return;
Reinette Chatred419b9f2009-10-19 14:55:37 -07001333 }
Johannes Berg46900292009-02-15 12:44:28 +01001334
Antonio Quartullid8eb7412013-08-09 18:58:32 +02001335 /* if a fixed bssid and a fixed freq have been provided create the IBSS
1336 * directly and do not waste time scanning
1337 */
1338 if (ifibss->fixed_bssid && ifibss->fixed_channel) {
1339 sdata_info(sdata, "Created IBSS using preconfigured BSSID %pM\n",
1340 bssid);
1341 ieee80211_sta_create_ibss(sdata);
1342 return;
1343 }
1344
1345
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001346 ibss_dbg(sdata, "sta_find_ibss: did not try to join ibss\n");
Johannes Berg46900292009-02-15 12:44:28 +01001347
1348 /* Selected IBSS not found in current scan results - try to scan */
Benoit Papillaultce9058a2010-01-17 22:45:23 +01001349 if (time_after(jiffies, ifibss->last_scan_completed +
Johannes Berg46900292009-02-15 12:44:28 +01001350 IEEE80211_SCAN_INTERVAL)) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001351 sdata_info(sdata, "Trigger new scan to find an IBSS to join\n");
Johannes Berg46900292009-02-15 12:44:28 +01001352
Simon Wunderlich7ca15a02013-07-08 16:55:56 +02001353 scan_width = cfg80211_chandef_to_scan_width(&ifibss->chandef);
Stanislaw Gruszka34bcf712012-12-11 10:48:23 +01001354 ieee80211_request_ibss_scan(sdata, ifibss->ssid,
Simon Wunderlich7ca15a02013-07-08 16:55:56 +02001355 ifibss->ssid_len, chan,
1356 scan_width);
Benoit Papillaultce9058a2010-01-17 22:45:23 +01001357 } else {
Johannes Berg46900292009-02-15 12:44:28 +01001358 int interval = IEEE80211_SCAN_INTERVAL;
1359
1360 if (time_after(jiffies, ifibss->ibss_join_req +
Johannes Berg55de9082012-07-26 17:24:39 +02001361 IEEE80211_IBSS_JOIN_TIMEOUT))
1362 ieee80211_sta_create_ibss(sdata);
Johannes Berg46900292009-02-15 12:44:28 +01001363
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001364 mod_timer(&ifibss->timer,
1365 round_jiffies(jiffies + interval));
Johannes Berg46900292009-02-15 12:44:28 +01001366 }
Johannes Berg46900292009-02-15 12:44:28 +01001367}
1368
1369static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
Johannes Bergc269a202011-02-14 12:20:22 +01001370 struct sk_buff *req)
Johannes Berg46900292009-02-15 12:44:28 +01001371{
Johannes Bergc269a202011-02-14 12:20:22 +01001372 struct ieee80211_mgmt *mgmt = (void *)req->data;
Johannes Berg46900292009-02-15 12:44:28 +01001373 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1374 struct ieee80211_local *local = sdata->local;
Johannes Bergc269a202011-02-14 12:20:22 +01001375 int tx_last_beacon, len = req->len;
Johannes Berg46900292009-02-15 12:44:28 +01001376 struct sk_buff *skb;
Johannes Bergc3ffeab2013-03-07 20:54:29 +01001377 struct beacon_data *presp;
Johannes Berg46900292009-02-15 12:44:28 +01001378 u8 *pos, *end;
1379
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001380 sdata_assert_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +02001381
Johannes Berg40b275b2011-05-13 14:15:49 +02001382 presp = rcu_dereference_protected(ifibss->presp,
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001383 lockdep_is_held(&sdata->wdev.mtx));
Johannes Berg40b275b2011-05-13 14:15:49 +02001384
Johannes Berg46900292009-02-15 12:44:28 +01001385 if (ifibss->state != IEEE80211_IBSS_MLME_JOINED ||
Johannes Berg40b275b2011-05-13 14:15:49 +02001386 len < 24 + 2 || !presp)
Johannes Berg46900292009-02-15 12:44:28 +01001387 return;
1388
Johannes Berg24487982009-04-23 18:52:52 +02001389 tx_last_beacon = drv_tx_last_beacon(local);
Johannes Berg46900292009-02-15 12:44:28 +01001390
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001391 ibss_dbg(sdata,
1392 "RX ProbeReq SA=%pM DA=%pM BSSID=%pM (tx_last_beacon=%d)\n",
1393 mgmt->sa, mgmt->da, mgmt->bssid, tx_last_beacon);
Johannes Berg46900292009-02-15 12:44:28 +01001394
Felix Fietkau1ed76482011-03-24 19:46:18 +01001395 if (!tx_last_beacon && is_multicast_ether_addr(mgmt->da))
Johannes Berg46900292009-02-15 12:44:28 +01001396 return;
1397
Joe Perchesb203ca32012-05-08 18:56:52 +00001398 if (!ether_addr_equal(mgmt->bssid, ifibss->bssid) &&
Felix Fietkau888d04d2012-03-01 15:22:09 +01001399 !is_broadcast_ether_addr(mgmt->bssid))
Johannes Berg46900292009-02-15 12:44:28 +01001400 return;
1401
1402 end = ((u8 *) mgmt) + len;
1403 pos = mgmt->u.probe_req.variable;
1404 if (pos[0] != WLAN_EID_SSID ||
1405 pos + 2 + pos[1] > end) {
Johannes Bergbdcbd8e2012-06-22 11:29:50 +02001406 ibss_dbg(sdata, "Invalid SSID IE in ProbeReq from %pM\n",
1407 mgmt->sa);
Johannes Berg46900292009-02-15 12:44:28 +01001408 return;
1409 }
1410 if (pos[1] != 0 &&
1411 (pos[1] != ifibss->ssid_len ||
Benoit Papillault0da780c2010-02-05 01:21:03 +01001412 memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len))) {
Johannes Berg46900292009-02-15 12:44:28 +01001413 /* Ignore ProbeReq for foreign SSID */
1414 return;
1415 }
1416
1417 /* Reply with ProbeResp */
Johannes Bergc3ffeab2013-03-07 20:54:29 +01001418 skb = dev_alloc_skb(local->tx_headroom + presp->head_len);
Johannes Berg46900292009-02-15 12:44:28 +01001419 if (!skb)
1420 return;
1421
Johannes Bergc3ffeab2013-03-07 20:54:29 +01001422 skb_reserve(skb, local->tx_headroom);
1423 memcpy(skb_put(skb, presp->head_len), presp->head, presp->head_len);
1424
1425 memcpy(((struct ieee80211_mgmt *) skb->data)->da, mgmt->sa, ETH_ALEN);
1426 ibss_dbg(sdata, "Sending ProbeResp to %pM\n", mgmt->sa);
Johannes Berg62ae67b2009-11-18 18:42:05 +01001427 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1428 ieee80211_tx_skb(sdata, skb);
Johannes Berg46900292009-02-15 12:44:28 +01001429}
1430
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +02001431static
1432void ieee80211_rx_mgmt_probe_beacon(struct ieee80211_sub_if_data *sdata,
1433 struct ieee80211_mgmt *mgmt, size_t len,
1434 struct ieee80211_rx_status *rx_status)
Johannes Berg46900292009-02-15 12:44:28 +01001435{
1436 size_t baselen;
1437 struct ieee802_11_elems elems;
1438
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +02001439 BUILD_BUG_ON(offsetof(typeof(mgmt->u.probe_resp), variable) !=
1440 offsetof(typeof(mgmt->u.beacon), variable));
1441
1442 /*
1443 * either beacon or probe_resp but the variable field is at the
1444 * same offset
1445 */
Johannes Berg46900292009-02-15 12:44:28 +01001446 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1447 if (baselen > len)
1448 return;
1449
1450 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
Johannes Bergb2e506b2013-03-26 14:54:16 +01001451 false, &elems);
Johannes Berg46900292009-02-15 12:44:28 +01001452
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +02001453 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems);
Johannes Berg46900292009-02-15 12:44:28 +01001454}
1455
Johannes Berg1fa57d02010-06-10 10:21:32 +02001456void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1457 struct sk_buff *skb)
Johannes Berg46900292009-02-15 12:44:28 +01001458{
1459 struct ieee80211_rx_status *rx_status;
1460 struct ieee80211_mgmt *mgmt;
1461 u16 fc;
Simon Wunderlichcd7760e2013-08-28 13:41:31 +02001462 struct ieee802_11_elems elems;
1463 int ies_len;
Johannes Berg46900292009-02-15 12:44:28 +01001464
Johannes Bergf1d58c22009-06-17 13:13:00 +02001465 rx_status = IEEE80211_SKB_RXCB(skb);
Johannes Berg46900292009-02-15 12:44:28 +01001466 mgmt = (struct ieee80211_mgmt *) skb->data;
1467 fc = le16_to_cpu(mgmt->frame_control);
1468
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001469 sdata_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +02001470
Tim Harveyc926d002010-12-09 10:43:13 -08001471 if (!sdata->u.ibss.ssid_len)
1472 goto mgmt_out; /* not ready to merge yet */
1473
Johannes Berg46900292009-02-15 12:44:28 +01001474 switch (fc & IEEE80211_FCTL_STYPE) {
1475 case IEEE80211_STYPE_PROBE_REQ:
Johannes Bergc269a202011-02-14 12:20:22 +01001476 ieee80211_rx_mgmt_probe_req(sdata, skb);
Johannes Berg46900292009-02-15 12:44:28 +01001477 break;
1478 case IEEE80211_STYPE_PROBE_RESP:
Johannes Berg46900292009-02-15 12:44:28 +01001479 case IEEE80211_STYPE_BEACON:
Emmanuel Grumbachd45c4172012-12-10 16:19:13 +02001480 ieee80211_rx_mgmt_probe_beacon(sdata, mgmt, skb->len,
1481 rx_status);
Johannes Berg46900292009-02-15 12:44:28 +01001482 break;
1483 case IEEE80211_STYPE_AUTH:
1484 ieee80211_rx_mgmt_auth_ibss(sdata, mgmt, skb->len);
1485 break;
Antonio Quartulli2cc59e72012-09-07 13:28:53 +02001486 case IEEE80211_STYPE_DEAUTH:
1487 ieee80211_rx_mgmt_deauth_ibss(sdata, mgmt, skb->len);
1488 break;
Simon Wunderlichcd7760e2013-08-28 13:41:31 +02001489 case IEEE80211_STYPE_ACTION:
1490 switch (mgmt->u.action.category) {
1491 case WLAN_CATEGORY_SPECTRUM_MGMT:
1492 ies_len = skb->len -
1493 offsetof(struct ieee80211_mgmt,
1494 u.action.u.chan_switch.variable);
1495
1496 if (ies_len < 0)
1497 break;
1498
1499 ieee802_11_parse_elems(
1500 mgmt->u.action.u.chan_switch.variable,
1501 ies_len, true, &elems);
1502
1503 if (elems.parse_error)
1504 break;
1505
1506 ieee80211_rx_mgmt_spectrum_mgmt(sdata, mgmt, skb->len,
1507 rx_status, &elems);
1508 break;
1509 }
Johannes Berg46900292009-02-15 12:44:28 +01001510 }
Johannes Berg7a17a332010-07-21 11:30:27 +02001511
Tim Harveyc926d002010-12-09 10:43:13 -08001512 mgmt_out:
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001513 sdata_unlock(sdata);
Johannes Berg46900292009-02-15 12:44:28 +01001514}
1515
Johannes Berg1fa57d02010-06-10 10:21:32 +02001516void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata)
Johannes Berg46900292009-02-15 12:44:28 +01001517{
Johannes Berg1fa57d02010-06-10 10:21:32 +02001518 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
Johannes Berg8bf11d82011-12-15 11:17:37 +01001519 struct sta_info *sta;
Johannes Berg46900292009-02-15 12:44:28 +01001520
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001521 sdata_lock(sdata);
Johannes Berg7a17a332010-07-21 11:30:27 +02001522
1523 /*
1524 * Work could be scheduled after scan or similar
1525 * when we aren't even joined (or trying) with a
1526 * network.
1527 */
1528 if (!ifibss->ssid_len)
1529 goto out;
Johannes Berg46900292009-02-15 12:44:28 +01001530
Johannes Berg8bf11d82011-12-15 11:17:37 +01001531 spin_lock_bh(&ifibss->incomplete_lock);
1532 while (!list_empty(&ifibss->incomplete_stations)) {
1533 sta = list_first_entry(&ifibss->incomplete_stations,
1534 struct sta_info, list);
1535 list_del(&sta->list);
1536 spin_unlock_bh(&ifibss->incomplete_lock);
1537
Antonio Quartulli52874a52013-06-18 14:20:40 +02001538 ieee80211_ibss_finish_sta(sta);
Johannes Berg8bf11d82011-12-15 11:17:37 +01001539 rcu_read_unlock();
1540 spin_lock_bh(&ifibss->incomplete_lock);
1541 }
1542 spin_unlock_bh(&ifibss->incomplete_lock);
1543
Johannes Berg46900292009-02-15 12:44:28 +01001544 switch (ifibss->state) {
1545 case IEEE80211_IBSS_MLME_SEARCH:
1546 ieee80211_sta_find_ibss(sdata);
1547 break;
1548 case IEEE80211_IBSS_MLME_JOINED:
1549 ieee80211_sta_merge_ibss(sdata);
1550 break;
1551 default:
1552 WARN_ON(1);
1553 break;
1554 }
Johannes Berg46900292009-02-15 12:44:28 +01001555
Johannes Berg7a17a332010-07-21 11:30:27 +02001556 out:
Johannes Berg8d61ffa2013-05-10 12:32:47 +02001557 sdata_unlock(sdata);
Johannes Berg3a4d4aa2010-05-26 16:41:40 +02001558}
1559
Johannes Berg46900292009-02-15 12:44:28 +01001560static void ieee80211_ibss_timer(unsigned long data)
1561{
1562 struct ieee80211_sub_if_data *sdata =
1563 (struct ieee80211_sub_if_data *) data;
Johannes Berg46900292009-02-15 12:44:28 +01001564
Stanislaw Gruszkaa6182942013-02-28 10:55:28 +01001565 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Johannes Berg46900292009-02-15 12:44:28 +01001566}
1567
1568void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
1569{
1570 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1571
Johannes Berg46900292009-02-15 12:44:28 +01001572 setup_timer(&ifibss->timer, ieee80211_ibss_timer,
1573 (unsigned long) sdata);
Johannes Berg8bf11d82011-12-15 11:17:37 +01001574 INIT_LIST_HEAD(&ifibss->incomplete_stations);
1575 spin_lock_init(&ifibss->incomplete_lock);
Simon Wunderlichcd7760e2013-08-28 13:41:31 +02001576 INIT_WORK(&ifibss->csa_connection_drop_work,
1577 ieee80211_csa_connection_drop_work);
Johannes Berg46900292009-02-15 12:44:28 +01001578}
1579
1580/* scan finished notification */
1581void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local)
1582{
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001583 struct ieee80211_sub_if_data *sdata;
Johannes Berg46900292009-02-15 12:44:28 +01001584
Johannes Berg29b4a4f2009-04-21 00:30:49 +02001585 mutex_lock(&local->iflist_mtx);
1586 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +01001587 if (!ieee80211_sdata_running(sdata))
Johannes Berg0e41f712009-04-23 11:48:56 +02001588 continue;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001589 if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
1590 continue;
1591 sdata->u.ibss.last_scan_completed = jiffies;
Johannes Berg7a17a332010-07-21 11:30:27 +02001592 ieee80211_queue_work(&local->hw, &sdata->work);
Johannes Berg46900292009-02-15 12:44:28 +01001593 }
Johannes Berg29b4a4f2009-04-21 00:30:49 +02001594 mutex_unlock(&local->iflist_mtx);
Johannes Berg46900292009-02-15 12:44:28 +01001595}
1596
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001597int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
1598 struct cfg80211_ibss_params *params)
1599{
Simon Wunderlichff3cc5f2011-11-30 16:56:33 +01001600 u32 changed = 0;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001601 u32 rate_flags;
1602 struct ieee80211_supported_band *sband;
1603 int i;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001604
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001605 if (params->bssid) {
1606 memcpy(sdata->u.ibss.bssid, params->bssid, ETH_ALEN);
1607 sdata->u.ibss.fixed_bssid = true;
1608 } else
1609 sdata->u.ibss.fixed_bssid = false;
1610
Johannes Bergfffd0932009-07-08 14:22:54 +02001611 sdata->u.ibss.privacy = params->privacy;
Antonio Quartulli267335d2012-01-31 20:25:47 +01001612 sdata->u.ibss.control_port = params->control_port;
Teemu Paasikivifbd2c8d2010-06-14 12:55:31 +03001613 sdata->u.ibss.basic_rates = params->basic_rates;
Simon Wunderlich2103dec2013-07-08 16:55:53 +02001614
1615 /* fix basic_rates if channel does not support these rates */
1616 rate_flags = ieee80211_chandef_rate_flags(&params->chandef);
1617 sband = sdata->local->hw.wiphy->bands[params->chandef.chan->band];
1618 for (i = 0; i < sband->n_bitrates; i++) {
1619 if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1620 sdata->u.ibss.basic_rates &= ~BIT(i);
1621 }
Felix Fietkaudd5b4cc2010-11-22 20:58:24 +01001622 memcpy(sdata->vif.bss_conf.mcast_rate, params->mcast_rate,
1623 sizeof(params->mcast_rate));
Johannes Bergfffd0932009-07-08 14:22:54 +02001624
Johannes Berg57c4d7b2009-04-23 16:10:04 +02001625 sdata->vif.bss_conf.beacon_int = params->beacon_interval;
1626
Simon Wunderlich3aede782013-05-16 13:00:36 +02001627 sdata->u.ibss.chandef = params->chandef;
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001628 sdata->u.ibss.fixed_channel = params->channel_fixed;
1629
1630 if (params->ie) {
1631 sdata->u.ibss.ie = kmemdup(params->ie, params->ie_len,
1632 GFP_KERNEL);
1633 if (sdata->u.ibss.ie)
1634 sdata->u.ibss.ie_len = params->ie_len;
1635 }
1636
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001637 sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH;
1638 sdata->u.ibss.ibss_join_req = jiffies;
1639
Antonio Quartullibadecb02012-10-26 18:54:25 +02001640 memcpy(sdata->u.ibss.ssid, params->ssid, params->ssid_len);
Johannes Berg0e41f712009-04-23 11:48:56 +02001641 sdata->u.ibss.ssid_len = params->ssid_len;
1642
Simon Wunderlich822854b2013-06-28 10:39:59 +02001643 memcpy(&sdata->u.ibss.ht_capa, &params->ht_capa,
1644 sizeof(sdata->u.ibss.ht_capa));
1645 memcpy(&sdata->u.ibss.ht_capa_mask, &params->ht_capa_mask,
1646 sizeof(sdata->u.ibss.ht_capa_mask));
1647
Simon Wunderlichff3cc5f2011-11-30 16:56:33 +01001648 /*
1649 * 802.11n-2009 9.13.3.1: In an IBSS, the HT Protection field is
1650 * reserved, but an HT STA shall protect HT transmissions as though
1651 * the HT Protection field were set to non-HT mixed mode.
1652 *
1653 * In an IBSS, the RIFS Mode field of the HT Operation element is
1654 * also reserved, but an HT STA shall operate as though this field
1655 * were set to 1.
1656 */
1657
1658 sdata->vif.bss_conf.ht_operation_mode |=
1659 IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
1660 | IEEE80211_HT_PARAM_RIFS_MODE;
1661
1662 changed |= BSS_CHANGED_HT;
1663 ieee80211_bss_info_change_notify(sdata, changed);
1664
Johannes Berg04ecd252012-09-11 14:34:12 +02001665 sdata->smps_mode = IEEE80211_SMPS_OFF;
1666 sdata->needed_rx_chains = sdata->local->rx_chains;
1667
Johannes Berg64592c82010-06-10 10:21:31 +02001668 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001669
1670 return 0;
1671}
1672
1673int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata)
1674{
Teemu Paasikivi5ea096c2010-06-14 12:55:33 +03001675 struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
Johannes Berg7a17a332010-07-21 11:30:27 +02001676
Simon Wunderlich871a4182013-08-28 13:41:30 +02001677 ieee80211_ibss_disconnect(sdata);
Simon Wunderlichb78a4932012-11-13 18:43:03 +01001678 ifibss->ssid_len = 0;
Simon Wunderlich871a4182013-08-28 13:41:30 +02001679 memset(ifibss->bssid, 0, ETH_ALEN);
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001680
1681 /* remove beacon */
1682 kfree(sdata->u.ibss.ie);
Simon Wunderlich822854b2013-06-28 10:39:59 +02001683
1684 /* on the next join, re-program HT parameters */
1685 memset(&ifibss->ht_capa, 0, sizeof(ifibss->ht_capa));
1686 memset(&ifibss->ht_capa_mask, 0, sizeof(ifibss->ht_capa_mask));
1687
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001688 synchronize_rcu();
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001689
Johannes Berg35f20c12010-06-10 10:21:30 +02001690 skb_queue_purge(&sdata->skb_queue);
Johannes Berg5cff20e2009-04-29 12:26:17 +02001691
Johannes Bergbc05d192010-07-21 10:52:40 +02001692 del_timer_sync(&sdata->u.ibss.timer);
Johannes Berg7a17a332010-07-21 11:30:27 +02001693
Johannes Bergaf8cdcd2009-04-19 21:25:43 +02001694 return 0;
1695}