Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * IBSS mode implementation
0004  * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
0005  * Copyright 2004, Instant802 Networks, Inc.
0006  * Copyright 2005, Devicescape Software, Inc.
0007  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
0008  * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
0009  * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
0010  * Copyright 2013-2014  Intel Mobile Communications GmbH
0011  * Copyright(c) 2016 Intel Deutschland GmbH
0012  * Copyright(c) 2018-2022 Intel Corporation
0013  */
0014 
0015 #include <linux/delay.h>
0016 #include <linux/slab.h>
0017 #include <linux/if_ether.h>
0018 #include <linux/skbuff.h>
0019 #include <linux/if_arp.h>
0020 #include <linux/etherdevice.h>
0021 #include <linux/rtnetlink.h>
0022 #include <net/mac80211.h>
0023 
0024 #include "ieee80211_i.h"
0025 #include "driver-ops.h"
0026 #include "rate.h"
0027 
0028 #define IEEE80211_SCAN_INTERVAL (2 * HZ)
0029 #define IEEE80211_IBSS_JOIN_TIMEOUT (7 * HZ)
0030 
0031 #define IEEE80211_IBSS_MERGE_INTERVAL (30 * HZ)
0032 #define IEEE80211_IBSS_INACTIVITY_LIMIT (60 * HZ)
0033 #define IEEE80211_IBSS_RSN_INACTIVITY_LIMIT (10 * HZ)
0034 
0035 #define IEEE80211_IBSS_MAX_STA_ENTRIES 128
0036 
0037 static struct beacon_data *
0038 ieee80211_ibss_build_presp(struct ieee80211_sub_if_data *sdata,
0039                const int beacon_int, const u32 basic_rates,
0040                const u16 capability, u64 tsf,
0041                struct cfg80211_chan_def *chandef,
0042                bool *have_higher_than_11mbit,
0043                struct cfg80211_csa_settings *csa_settings)
0044 {
0045     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0046     struct ieee80211_local *local = sdata->local;
0047     int rates_n = 0, i, ri;
0048     struct ieee80211_mgmt *mgmt;
0049     u8 *pos;
0050     struct ieee80211_supported_band *sband;
0051     u32 rate_flags, rates = 0, rates_added = 0;
0052     struct beacon_data *presp;
0053     int frame_len;
0054     int shift;
0055 
0056     /* Build IBSS probe response */
0057     frame_len = sizeof(struct ieee80211_hdr_3addr) +
0058             12 /* struct ieee80211_mgmt.u.beacon */ +
0059             2 + IEEE80211_MAX_SSID_LEN /* max SSID */ +
0060             2 + 8 /* max Supported Rates */ +
0061             3 /* max DS params */ +
0062             4 /* IBSS params */ +
0063             5 /* Channel Switch Announcement */ +
0064             2 + (IEEE80211_MAX_SUPP_RATES - 8) +
0065             2 + sizeof(struct ieee80211_ht_cap) +
0066             2 + sizeof(struct ieee80211_ht_operation) +
0067             2 + sizeof(struct ieee80211_vht_cap) +
0068             2 + sizeof(struct ieee80211_vht_operation) +
0069             ifibss->ie_len;
0070     presp = kzalloc(sizeof(*presp) + frame_len, GFP_KERNEL);
0071     if (!presp)
0072         return NULL;
0073 
0074     presp->head = (void *)(presp + 1);
0075 
0076     mgmt = (void *) presp->head;
0077     mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
0078                       IEEE80211_STYPE_PROBE_RESP);
0079     eth_broadcast_addr(mgmt->da);
0080     memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
0081     memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
0082     mgmt->u.beacon.beacon_int = cpu_to_le16(beacon_int);
0083     mgmt->u.beacon.timestamp = cpu_to_le64(tsf);
0084     mgmt->u.beacon.capab_info = cpu_to_le16(capability);
0085 
0086     pos = (u8 *)mgmt + offsetof(struct ieee80211_mgmt, u.beacon.variable);
0087 
0088     *pos++ = WLAN_EID_SSID;
0089     *pos++ = ifibss->ssid_len;
0090     memcpy(pos, ifibss->ssid, ifibss->ssid_len);
0091     pos += ifibss->ssid_len;
0092 
0093     sband = local->hw.wiphy->bands[chandef->chan->band];
0094     rate_flags = ieee80211_chandef_rate_flags(chandef);
0095     shift = ieee80211_chandef_get_shift(chandef);
0096     rates_n = 0;
0097     if (have_higher_than_11mbit)
0098         *have_higher_than_11mbit = false;
0099 
0100     for (i = 0; i < sband->n_bitrates; i++) {
0101         if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
0102             continue;
0103         if (sband->bitrates[i].bitrate > 110 &&
0104             have_higher_than_11mbit)
0105             *have_higher_than_11mbit = true;
0106 
0107         rates |= BIT(i);
0108         rates_n++;
0109     }
0110 
0111     *pos++ = WLAN_EID_SUPP_RATES;
0112     *pos++ = min_t(int, 8, rates_n);
0113     for (ri = 0; ri < sband->n_bitrates; ri++) {
0114         int rate = DIV_ROUND_UP(sband->bitrates[ri].bitrate,
0115                     5 * (1 << shift));
0116         u8 basic = 0;
0117         if (!(rates & BIT(ri)))
0118             continue;
0119 
0120         if (basic_rates & BIT(ri))
0121             basic = 0x80;
0122         *pos++ = basic | (u8) rate;
0123         if (++rates_added == 8) {
0124             ri++; /* continue at next rate for EXT_SUPP_RATES */
0125             break;
0126         }
0127     }
0128 
0129     if (sband->band == NL80211_BAND_2GHZ) {
0130         *pos++ = WLAN_EID_DS_PARAMS;
0131         *pos++ = 1;
0132         *pos++ = ieee80211_frequency_to_channel(
0133                 chandef->chan->center_freq);
0134     }
0135 
0136     *pos++ = WLAN_EID_IBSS_PARAMS;
0137     *pos++ = 2;
0138     /* FIX: set ATIM window based on scan results */
0139     *pos++ = 0;
0140     *pos++ = 0;
0141 
0142     if (csa_settings) {
0143         *pos++ = WLAN_EID_CHANNEL_SWITCH;
0144         *pos++ = 3;
0145         *pos++ = csa_settings->block_tx ? 1 : 0;
0146         *pos++ = ieee80211_frequency_to_channel(
0147                 csa_settings->chandef.chan->center_freq);
0148         presp->cntdwn_counter_offsets[0] = (pos - presp->head);
0149         *pos++ = csa_settings->count;
0150         presp->cntdwn_current_counter = csa_settings->count;
0151     }
0152 
0153     /* put the remaining rates in WLAN_EID_EXT_SUPP_RATES */
0154     if (rates_n > 8) {
0155         *pos++ = WLAN_EID_EXT_SUPP_RATES;
0156         *pos++ = rates_n - 8;
0157         for (; ri < sband->n_bitrates; ri++) {
0158             int rate = DIV_ROUND_UP(sband->bitrates[ri].bitrate,
0159                         5 * (1 << shift));
0160             u8 basic = 0;
0161             if (!(rates & BIT(ri)))
0162                 continue;
0163 
0164             if (basic_rates & BIT(ri))
0165                 basic = 0x80;
0166             *pos++ = basic | (u8) rate;
0167         }
0168     }
0169 
0170     if (ifibss->ie_len) {
0171         memcpy(pos, ifibss->ie, ifibss->ie_len);
0172         pos += ifibss->ie_len;
0173     }
0174 
0175     /* add HT capability and information IEs */
0176     if (chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
0177         chandef->width != NL80211_CHAN_WIDTH_5 &&
0178         chandef->width != NL80211_CHAN_WIDTH_10 &&
0179         sband->ht_cap.ht_supported) {
0180         struct ieee80211_sta_ht_cap ht_cap;
0181 
0182         memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
0183         ieee80211_apply_htcap_overrides(sdata, &ht_cap);
0184 
0185         pos = ieee80211_ie_build_ht_cap(pos, &ht_cap, ht_cap.cap);
0186         /*
0187          * Note: According to 802.11n-2009 9.13.3.1, HT Protection
0188          * field and RIFS Mode are reserved in IBSS mode, therefore
0189          * keep them at 0
0190          */
0191         pos = ieee80211_ie_build_ht_oper(pos, &sband->ht_cap,
0192                          chandef, 0, false);
0193 
0194         /* add VHT capability and information IEs */
0195         if (chandef->width != NL80211_CHAN_WIDTH_20 &&
0196             chandef->width != NL80211_CHAN_WIDTH_40 &&
0197             sband->vht_cap.vht_supported) {
0198             pos = ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
0199                              sband->vht_cap.cap);
0200             pos = ieee80211_ie_build_vht_oper(pos, &sband->vht_cap,
0201                               chandef);
0202         }
0203     }
0204 
0205     if (local->hw.queues >= IEEE80211_NUM_ACS)
0206         pos = ieee80211_add_wmm_info_ie(pos, 0); /* U-APSD not in use */
0207 
0208     presp->head_len = pos - presp->head;
0209     if (WARN_ON(presp->head_len > frame_len))
0210         goto error;
0211 
0212     return presp;
0213 error:
0214     kfree(presp);
0215     return NULL;
0216 }
0217 
0218 static void __ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
0219                       const u8 *bssid, const int beacon_int,
0220                       struct cfg80211_chan_def *req_chandef,
0221                       const u32 basic_rates,
0222                       const u16 capability, u64 tsf,
0223                       bool creator)
0224 {
0225     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0226     struct ieee80211_local *local = sdata->local;
0227     struct ieee80211_mgmt *mgmt;
0228     struct cfg80211_bss *bss;
0229     u32 bss_change;
0230     struct cfg80211_chan_def chandef;
0231     struct ieee80211_channel *chan;
0232     struct beacon_data *presp;
0233     struct cfg80211_inform_bss bss_meta = {};
0234     bool have_higher_than_11mbit;
0235     bool radar_required;
0236     int err;
0237 
0238     sdata_assert_lock(sdata);
0239 
0240     /* Reset own TSF to allow time synchronization work. */
0241     drv_reset_tsf(local, sdata);
0242 
0243     if (!ether_addr_equal(ifibss->bssid, bssid))
0244         sta_info_flush(sdata);
0245 
0246     /* if merging, indicate to driver that we leave the old IBSS */
0247     if (sdata->vif.cfg.ibss_joined) {
0248         sdata->vif.cfg.ibss_joined = false;
0249         sdata->vif.cfg.ibss_creator = false;
0250         sdata->vif.bss_conf.enable_beacon = false;
0251         netif_carrier_off(sdata->dev);
0252         ieee80211_bss_info_change_notify(sdata,
0253                          BSS_CHANGED_IBSS |
0254                          BSS_CHANGED_BEACON_ENABLED);
0255         drv_leave_ibss(local, sdata);
0256     }
0257 
0258     presp = sdata_dereference(ifibss->presp, sdata);
0259     RCU_INIT_POINTER(ifibss->presp, NULL);
0260     if (presp)
0261         kfree_rcu(presp, rcu_head);
0262 
0263     /* make a copy of the chandef, it could be modified below. */
0264     chandef = *req_chandef;
0265     chan = chandef.chan;
0266     if (!cfg80211_reg_can_beacon(local->hw.wiphy, &chandef,
0267                      NL80211_IFTYPE_ADHOC)) {
0268         if (chandef.width == NL80211_CHAN_WIDTH_5 ||
0269             chandef.width == NL80211_CHAN_WIDTH_10 ||
0270             chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
0271             chandef.width == NL80211_CHAN_WIDTH_20) {
0272             sdata_info(sdata,
0273                    "Failed to join IBSS, beacons forbidden\n");
0274             return;
0275         }
0276         chandef.width = NL80211_CHAN_WIDTH_20;
0277         chandef.center_freq1 = chan->center_freq;
0278         /* check again for downgraded chandef */
0279         if (!cfg80211_reg_can_beacon(local->hw.wiphy, &chandef,
0280                          NL80211_IFTYPE_ADHOC)) {
0281             sdata_info(sdata,
0282                    "Failed to join IBSS, beacons forbidden\n");
0283             return;
0284         }
0285     }
0286 
0287     err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
0288                         &chandef, NL80211_IFTYPE_ADHOC);
0289     if (err < 0) {
0290         sdata_info(sdata,
0291                "Failed to join IBSS, invalid chandef\n");
0292         return;
0293     }
0294     if (err > 0 && !ifibss->userspace_handles_dfs) {
0295         sdata_info(sdata,
0296                "Failed to join IBSS, DFS channel without control program\n");
0297         return;
0298     }
0299 
0300     radar_required = err;
0301 
0302     mutex_lock(&local->mtx);
0303     if (ieee80211_link_use_channel(&sdata->deflink, &chandef,
0304                        ifibss->fixed_channel ?
0305                     IEEE80211_CHANCTX_SHARED :
0306                     IEEE80211_CHANCTX_EXCLUSIVE)) {
0307         sdata_info(sdata, "Failed to join IBSS, no channel context\n");
0308         mutex_unlock(&local->mtx);
0309         return;
0310     }
0311     sdata->deflink.radar_required = radar_required;
0312     mutex_unlock(&local->mtx);
0313 
0314     memcpy(ifibss->bssid, bssid, ETH_ALEN);
0315 
0316     presp = ieee80211_ibss_build_presp(sdata, beacon_int, basic_rates,
0317                        capability, tsf, &chandef,
0318                        &have_higher_than_11mbit, NULL);
0319     if (!presp)
0320         return;
0321 
0322     rcu_assign_pointer(ifibss->presp, presp);
0323     mgmt = (void *)presp->head;
0324 
0325     sdata->vif.bss_conf.enable_beacon = true;
0326     sdata->vif.bss_conf.beacon_int = beacon_int;
0327     sdata->vif.bss_conf.basic_rates = basic_rates;
0328     sdata->vif.cfg.ssid_len = ifibss->ssid_len;
0329     memcpy(sdata->vif.cfg.ssid, ifibss->ssid, ifibss->ssid_len);
0330     bss_change = BSS_CHANGED_BEACON_INT;
0331     bss_change |= ieee80211_reset_erp_info(sdata);
0332     bss_change |= BSS_CHANGED_BSSID;
0333     bss_change |= BSS_CHANGED_BEACON;
0334     bss_change |= BSS_CHANGED_BEACON_ENABLED;
0335     bss_change |= BSS_CHANGED_BASIC_RATES;
0336     bss_change |= BSS_CHANGED_HT;
0337     bss_change |= BSS_CHANGED_IBSS;
0338     bss_change |= BSS_CHANGED_SSID;
0339 
0340     /*
0341      * In 5 GHz/802.11a, we can always use short slot time.
0342      * (IEEE 802.11-2012 18.3.8.7)
0343      *
0344      * In 2.4GHz, we must always use long slots in IBSS for compatibility
0345      * reasons.
0346      * (IEEE 802.11-2012 19.4.5)
0347      *
0348      * HT follows these specifications (IEEE 802.11-2012 20.3.18)
0349      */
0350     sdata->vif.bss_conf.use_short_slot = chan->band == NL80211_BAND_5GHZ;
0351     bss_change |= BSS_CHANGED_ERP_SLOT;
0352 
0353     /* cf. IEEE 802.11 9.2.12 */
0354     sdata->deflink.operating_11g_mode =
0355         chan->band == NL80211_BAND_2GHZ && have_higher_than_11mbit;
0356 
0357     ieee80211_set_wmm_default(&sdata->deflink, true, false);
0358 
0359     sdata->vif.cfg.ibss_joined = true;
0360     sdata->vif.cfg.ibss_creator = creator;
0361 
0362     err = drv_join_ibss(local, sdata);
0363     if (err) {
0364         sdata->vif.cfg.ibss_joined = false;
0365         sdata->vif.cfg.ibss_creator = false;
0366         sdata->vif.bss_conf.enable_beacon = false;
0367         sdata->vif.cfg.ssid_len = 0;
0368         RCU_INIT_POINTER(ifibss->presp, NULL);
0369         kfree_rcu(presp, rcu_head);
0370         mutex_lock(&local->mtx);
0371         ieee80211_link_release_channel(&sdata->deflink);
0372         mutex_unlock(&local->mtx);
0373         sdata_info(sdata, "Failed to join IBSS, driver failure: %d\n",
0374                err);
0375         return;
0376     }
0377 
0378     ieee80211_bss_info_change_notify(sdata, bss_change);
0379 
0380     ifibss->state = IEEE80211_IBSS_MLME_JOINED;
0381     mod_timer(&ifibss->timer,
0382           round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
0383 
0384     bss_meta.chan = chan;
0385     bss_meta.scan_width = cfg80211_chandef_to_scan_width(&chandef);
0386     bss = cfg80211_inform_bss_frame_data(local->hw.wiphy, &bss_meta, mgmt,
0387                          presp->head_len, GFP_KERNEL);
0388 
0389     cfg80211_put_bss(local->hw.wiphy, bss);
0390     netif_carrier_on(sdata->dev);
0391     cfg80211_ibss_joined(sdata->dev, ifibss->bssid, chan, GFP_KERNEL);
0392 }
0393 
0394 static void ieee80211_sta_join_ibss(struct ieee80211_sub_if_data *sdata,
0395                     struct ieee80211_bss *bss)
0396 {
0397     struct cfg80211_bss *cbss =
0398         container_of((void *)bss, struct cfg80211_bss, priv);
0399     struct ieee80211_supported_band *sband;
0400     struct cfg80211_chan_def chandef;
0401     u32 basic_rates;
0402     int i, j;
0403     u16 beacon_int = cbss->beacon_interval;
0404     const struct cfg80211_bss_ies *ies;
0405     enum nl80211_channel_type chan_type;
0406     u64 tsf;
0407     u32 rate_flags;
0408     int shift;
0409 
0410     sdata_assert_lock(sdata);
0411 
0412     if (beacon_int < 10)
0413         beacon_int = 10;
0414 
0415     switch (sdata->u.ibss.chandef.width) {
0416     case NL80211_CHAN_WIDTH_20_NOHT:
0417     case NL80211_CHAN_WIDTH_20:
0418     case NL80211_CHAN_WIDTH_40:
0419         chan_type = cfg80211_get_chandef_type(&sdata->u.ibss.chandef);
0420         cfg80211_chandef_create(&chandef, cbss->channel, chan_type);
0421         break;
0422     case NL80211_CHAN_WIDTH_5:
0423     case NL80211_CHAN_WIDTH_10:
0424         cfg80211_chandef_create(&chandef, cbss->channel,
0425                     NL80211_CHAN_NO_HT);
0426         chandef.width = sdata->u.ibss.chandef.width;
0427         break;
0428     case NL80211_CHAN_WIDTH_80:
0429     case NL80211_CHAN_WIDTH_80P80:
0430     case NL80211_CHAN_WIDTH_160:
0431         chandef = sdata->u.ibss.chandef;
0432         chandef.chan = cbss->channel;
0433         break;
0434     default:
0435         /* fall back to 20 MHz for unsupported modes */
0436         cfg80211_chandef_create(&chandef, cbss->channel,
0437                     NL80211_CHAN_NO_HT);
0438         break;
0439     }
0440 
0441     sband = sdata->local->hw.wiphy->bands[cbss->channel->band];
0442     rate_flags = ieee80211_chandef_rate_flags(&sdata->u.ibss.chandef);
0443     shift = ieee80211_vif_get_shift(&sdata->vif);
0444 
0445     basic_rates = 0;
0446 
0447     for (i = 0; i < bss->supp_rates_len; i++) {
0448         int rate = bss->supp_rates[i] & 0x7f;
0449         bool is_basic = !!(bss->supp_rates[i] & 0x80);
0450 
0451         for (j = 0; j < sband->n_bitrates; j++) {
0452             int brate;
0453             if ((rate_flags & sband->bitrates[j].flags)
0454                 != rate_flags)
0455                 continue;
0456 
0457             brate = DIV_ROUND_UP(sband->bitrates[j].bitrate,
0458                          5 * (1 << shift));
0459             if (brate == rate) {
0460                 if (is_basic)
0461                     basic_rates |= BIT(j);
0462                 break;
0463             }
0464         }
0465     }
0466 
0467     rcu_read_lock();
0468     ies = rcu_dereference(cbss->ies);
0469     tsf = ies->tsf;
0470     rcu_read_unlock();
0471 
0472     __ieee80211_sta_join_ibss(sdata, cbss->bssid,
0473                   beacon_int,
0474                   &chandef,
0475                   basic_rates,
0476                   cbss->capability,
0477                   tsf, false);
0478 }
0479 
0480 int ieee80211_ibss_csa_beacon(struct ieee80211_sub_if_data *sdata,
0481                   struct cfg80211_csa_settings *csa_settings)
0482 {
0483     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0484     struct beacon_data *presp, *old_presp;
0485     struct cfg80211_bss *cbss;
0486     const struct cfg80211_bss_ies *ies;
0487     u16 capability = WLAN_CAPABILITY_IBSS;
0488     u64 tsf;
0489 
0490     sdata_assert_lock(sdata);
0491 
0492     if (ifibss->privacy)
0493         capability |= WLAN_CAPABILITY_PRIVACY;
0494 
0495     cbss = cfg80211_get_bss(sdata->local->hw.wiphy, ifibss->chandef.chan,
0496                 ifibss->bssid, ifibss->ssid,
0497                 ifibss->ssid_len, IEEE80211_BSS_TYPE_IBSS,
0498                 IEEE80211_PRIVACY(ifibss->privacy));
0499 
0500     if (WARN_ON(!cbss))
0501         return -EINVAL;
0502 
0503     rcu_read_lock();
0504     ies = rcu_dereference(cbss->ies);
0505     tsf = ies->tsf;
0506     rcu_read_unlock();
0507     cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
0508 
0509     old_presp = sdata_dereference(ifibss->presp, sdata);
0510 
0511     presp = ieee80211_ibss_build_presp(sdata,
0512                        sdata->vif.bss_conf.beacon_int,
0513                        sdata->vif.bss_conf.basic_rates,
0514                        capability, tsf, &ifibss->chandef,
0515                        NULL, csa_settings);
0516     if (!presp)
0517         return -ENOMEM;
0518 
0519     rcu_assign_pointer(ifibss->presp, presp);
0520     if (old_presp)
0521         kfree_rcu(old_presp, rcu_head);
0522 
0523     return BSS_CHANGED_BEACON;
0524 }
0525 
0526 int ieee80211_ibss_finish_csa(struct ieee80211_sub_if_data *sdata)
0527 {
0528     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0529     struct cfg80211_bss *cbss;
0530 
0531     sdata_assert_lock(sdata);
0532 
0533     /* When not connected/joined, sending CSA doesn't make sense. */
0534     if (ifibss->state != IEEE80211_IBSS_MLME_JOINED)
0535         return -ENOLINK;
0536 
0537     /* update cfg80211 bss information with the new channel */
0538     if (!is_zero_ether_addr(ifibss->bssid)) {
0539         cbss = cfg80211_get_bss(sdata->local->hw.wiphy,
0540                     ifibss->chandef.chan,
0541                     ifibss->bssid, ifibss->ssid,
0542                     ifibss->ssid_len,
0543                     IEEE80211_BSS_TYPE_IBSS,
0544                     IEEE80211_PRIVACY(ifibss->privacy));
0545         /* XXX: should not really modify cfg80211 data */
0546         if (cbss) {
0547             cbss->channel = sdata->deflink.csa_chandef.chan;
0548             cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
0549         }
0550     }
0551 
0552     ifibss->chandef = sdata->deflink.csa_chandef;
0553 
0554     /* generate the beacon */
0555     return ieee80211_ibss_csa_beacon(sdata, NULL);
0556 }
0557 
0558 void ieee80211_ibss_stop(struct ieee80211_sub_if_data *sdata)
0559 {
0560     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0561 
0562     cancel_work_sync(&ifibss->csa_connection_drop_work);
0563 }
0564 
0565 static struct sta_info *ieee80211_ibss_finish_sta(struct sta_info *sta)
0566     __acquires(RCU)
0567 {
0568     struct ieee80211_sub_if_data *sdata = sta->sdata;
0569     u8 addr[ETH_ALEN];
0570 
0571     memcpy(addr, sta->sta.addr, ETH_ALEN);
0572 
0573     ibss_dbg(sdata, "Adding new IBSS station %pM\n", addr);
0574 
0575     sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
0576     sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
0577     /* authorize the station only if the network is not RSN protected. If
0578      * not wait for the userspace to authorize it */
0579     if (!sta->sdata->u.ibss.control_port)
0580         sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
0581 
0582     rate_control_rate_init(sta);
0583 
0584     /* If it fails, maybe we raced another insertion? */
0585     if (sta_info_insert_rcu(sta))
0586         return sta_info_get(sdata, addr);
0587     return sta;
0588 }
0589 
0590 static struct sta_info *
0591 ieee80211_ibss_add_sta(struct ieee80211_sub_if_data *sdata, const u8 *bssid,
0592                const u8 *addr, u32 supp_rates)
0593     __acquires(RCU)
0594 {
0595     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0596     struct ieee80211_local *local = sdata->local;
0597     struct sta_info *sta;
0598     struct ieee80211_chanctx_conf *chanctx_conf;
0599     struct ieee80211_supported_band *sband;
0600     enum nl80211_bss_scan_width scan_width;
0601     int band;
0602 
0603     /*
0604      * XXX: Consider removing the least recently used entry and
0605      *  allow new one to be added.
0606      */
0607     if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
0608         net_info_ratelimited("%s: No room for a new IBSS STA entry %pM\n",
0609                     sdata->name, addr);
0610         rcu_read_lock();
0611         return NULL;
0612     }
0613 
0614     if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH) {
0615         rcu_read_lock();
0616         return NULL;
0617     }
0618 
0619     if (!ether_addr_equal(bssid, sdata->u.ibss.bssid)) {
0620         rcu_read_lock();
0621         return NULL;
0622     }
0623 
0624     rcu_read_lock();
0625     chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
0626     if (WARN_ON_ONCE(!chanctx_conf))
0627         return NULL;
0628     band = chanctx_conf->def.chan->band;
0629     scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
0630     rcu_read_unlock();
0631 
0632     sta = sta_info_alloc(sdata, addr, GFP_KERNEL);
0633     if (!sta) {
0634         rcu_read_lock();
0635         return NULL;
0636     }
0637 
0638     /* make sure mandatory rates are always added */
0639     sband = local->hw.wiphy->bands[band];
0640     sta->sta.deflink.supp_rates[band] = supp_rates |
0641             ieee80211_mandatory_rates(sband, scan_width);
0642 
0643     return ieee80211_ibss_finish_sta(sta);
0644 }
0645 
0646 static int ieee80211_sta_active_ibss(struct ieee80211_sub_if_data *sdata)
0647 {
0648     struct ieee80211_local *local = sdata->local;
0649     int active = 0;
0650     struct sta_info *sta;
0651 
0652     sdata_assert_lock(sdata);
0653 
0654     rcu_read_lock();
0655 
0656     list_for_each_entry_rcu(sta, &local->sta_list, list) {
0657         unsigned long last_active = ieee80211_sta_last_active(sta);
0658 
0659         if (sta->sdata == sdata &&
0660             time_is_after_jiffies(last_active +
0661                       IEEE80211_IBSS_MERGE_INTERVAL)) {
0662             active++;
0663             break;
0664         }
0665     }
0666 
0667     rcu_read_unlock();
0668 
0669     return active;
0670 }
0671 
0672 static void ieee80211_ibss_disconnect(struct ieee80211_sub_if_data *sdata)
0673 {
0674     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0675     struct ieee80211_local *local = sdata->local;
0676     struct cfg80211_bss *cbss;
0677     struct beacon_data *presp;
0678     struct sta_info *sta;
0679 
0680     if (!is_zero_ether_addr(ifibss->bssid)) {
0681         cbss = cfg80211_get_bss(local->hw.wiphy, ifibss->chandef.chan,
0682                     ifibss->bssid, ifibss->ssid,
0683                     ifibss->ssid_len,
0684                     IEEE80211_BSS_TYPE_IBSS,
0685                     IEEE80211_PRIVACY(ifibss->privacy));
0686 
0687         if (cbss) {
0688             cfg80211_unlink_bss(local->hw.wiphy, cbss);
0689             cfg80211_put_bss(sdata->local->hw.wiphy, cbss);
0690         }
0691     }
0692 
0693     ifibss->state = IEEE80211_IBSS_MLME_SEARCH;
0694 
0695     sta_info_flush(sdata);
0696 
0697     spin_lock_bh(&ifibss->incomplete_lock);
0698     while (!list_empty(&ifibss->incomplete_stations)) {
0699         sta = list_first_entry(&ifibss->incomplete_stations,
0700                        struct sta_info, list);
0701         list_del(&sta->list);
0702         spin_unlock_bh(&ifibss->incomplete_lock);
0703 
0704         sta_info_free(local, sta);
0705         spin_lock_bh(&ifibss->incomplete_lock);
0706     }
0707     spin_unlock_bh(&ifibss->incomplete_lock);
0708 
0709     netif_carrier_off(sdata->dev);
0710 
0711     sdata->vif.cfg.ibss_joined = false;
0712     sdata->vif.cfg.ibss_creator = false;
0713     sdata->vif.bss_conf.enable_beacon = false;
0714     sdata->vif.cfg.ssid_len = 0;
0715 
0716     /* remove beacon */
0717     presp = sdata_dereference(ifibss->presp, sdata);
0718     RCU_INIT_POINTER(sdata->u.ibss.presp, NULL);
0719     if (presp)
0720         kfree_rcu(presp, rcu_head);
0721 
0722     clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
0723     ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
0724                         BSS_CHANGED_IBSS);
0725     drv_leave_ibss(local, sdata);
0726     mutex_lock(&local->mtx);
0727     ieee80211_link_release_channel(&sdata->deflink);
0728     mutex_unlock(&local->mtx);
0729 }
0730 
0731 static void ieee80211_csa_connection_drop_work(struct work_struct *work)
0732 {
0733     struct ieee80211_sub_if_data *sdata =
0734         container_of(work, struct ieee80211_sub_if_data,
0735                  u.ibss.csa_connection_drop_work);
0736 
0737     sdata_lock(sdata);
0738 
0739     ieee80211_ibss_disconnect(sdata);
0740     synchronize_rcu();
0741     skb_queue_purge(&sdata->skb_queue);
0742 
0743     /* trigger a scan to find another IBSS network to join */
0744     ieee80211_queue_work(&sdata->local->hw, &sdata->work);
0745 
0746     sdata_unlock(sdata);
0747 }
0748 
0749 static void ieee80211_ibss_csa_mark_radar(struct ieee80211_sub_if_data *sdata)
0750 {
0751     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0752     int err;
0753 
0754     /* if the current channel is a DFS channel, mark the channel as
0755      * unavailable.
0756      */
0757     err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
0758                         &ifibss->chandef,
0759                         NL80211_IFTYPE_ADHOC);
0760     if (err > 0)
0761         cfg80211_radar_event(sdata->local->hw.wiphy, &ifibss->chandef,
0762                      GFP_ATOMIC);
0763 }
0764 
0765 static bool
0766 ieee80211_ibss_process_chanswitch(struct ieee80211_sub_if_data *sdata,
0767                   struct ieee802_11_elems *elems,
0768                   bool beacon)
0769 {
0770     struct cfg80211_csa_settings params;
0771     struct ieee80211_csa_ie csa_ie;
0772     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
0773     enum nl80211_channel_type ch_type;
0774     int err;
0775     ieee80211_conn_flags_t conn_flags;
0776     u32 vht_cap_info = 0;
0777 
0778     sdata_assert_lock(sdata);
0779 
0780     conn_flags = IEEE80211_CONN_DISABLE_VHT;
0781 
0782     switch (ifibss->chandef.width) {
0783     case NL80211_CHAN_WIDTH_5:
0784     case NL80211_CHAN_WIDTH_10:
0785     case NL80211_CHAN_WIDTH_20_NOHT:
0786         conn_flags |= IEEE80211_CONN_DISABLE_HT;
0787         fallthrough;
0788     case NL80211_CHAN_WIDTH_20:
0789         conn_flags |= IEEE80211_CONN_DISABLE_40MHZ;
0790         break;
0791     default:
0792         break;
0793     }
0794 
0795     if (elems->vht_cap_elem)
0796         vht_cap_info = le32_to_cpu(elems->vht_cap_elem->vht_cap_info);
0797 
0798     memset(&params, 0, sizeof(params));
0799     err = ieee80211_parse_ch_switch_ie(sdata, elems,
0800                        ifibss->chandef.chan->band,
0801                        vht_cap_info,
0802                        conn_flags, ifibss->bssid, &csa_ie);
0803     /* can't switch to destination channel, fail */
0804     if (err < 0)
0805         goto disconnect;
0806 
0807     /* did not contain a CSA */
0808     if (err)
0809         return false;
0810 
0811     /* channel switch is not supported, disconnect */
0812     if (!(sdata->local->hw.wiphy->flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
0813         goto disconnect;
0814 
0815     params.count = csa_ie.count;
0816     params.chandef = csa_ie.chandef;
0817 
0818     switch (ifibss->chandef.width) {
0819     case NL80211_CHAN_WIDTH_20_NOHT:
0820     case NL80211_CHAN_WIDTH_20:
0821     case NL80211_CHAN_WIDTH_40:
0822         /* keep our current HT mode (HT20/HT40+/HT40-), even if
0823          * another mode  has been announced. The mode is not adopted
0824          * within the beacon while doing CSA and we should therefore
0825          * keep the mode which we announce.
0826          */
0827         ch_type = cfg80211_get_chandef_type(&ifibss->chandef);
0828         cfg80211_chandef_create(&params.chandef, params.chandef.chan,
0829                     ch_type);
0830         break;
0831     case NL80211_CHAN_WIDTH_5:
0832     case NL80211_CHAN_WIDTH_10:
0833         if (params.chandef.width != ifibss->chandef.width) {
0834             sdata_info(sdata,
0835                    "IBSS %pM received channel switch from incompatible channel width (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n",
0836                    ifibss->bssid,
0837                    params.chandef.chan->center_freq,
0838                    params.chandef.width,
0839                    params.chandef.center_freq1,
0840                    params.chandef.center_freq2);
0841             goto disconnect;
0842         }
0843         break;
0844     default:
0845         /* should not happen, conn_flags should prevent VHT modes. */
0846         WARN_ON(1);
0847         goto disconnect;
0848     }
0849 
0850     if (!cfg80211_reg_can_beacon(sdata->local->hw.wiphy, &params.chandef,
0851                      NL80211_IFTYPE_ADHOC)) {
0852         sdata_info(sdata,
0853                "IBSS %pM switches to unsupported channel (%d MHz, width:%d, CF1/2: %d/%d MHz), disconnecting\n",
0854                ifibss->bssid,
0855                params.chandef.chan->center_freq,
0856                params.chandef.width,
0857                params.chandef.center_freq1,
0858                params.chandef.center_freq2);
0859         goto disconnect;
0860     }
0861 
0862     err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
0863                         &params.chandef,
0864                         NL80211_IFTYPE_ADHOC);
0865     if (err < 0)
0866         goto disconnect;
0867     if (err > 0 && !ifibss->userspace_handles_dfs) {
0868         /* IBSS-DFS only allowed with a control program */
0869         goto disconnect;
0870     }
0871 
0872     params.radar_required = err;
0873 
0874     if (cfg80211_chandef_identical(&params.chandef,
0875                        &sdata->vif.bss_conf.chandef)) {
0876         ibss_dbg(sdata,
0877              "received csa with an identical chandef, ignoring\n");
0878         return true;
0879     }
0880 
0881     /* all checks done, now perform the channel switch. */
0882     ibss_dbg(sdata,
0883          "received channel switch announcement to go to channel %d MHz\n",
0884          params.chandef.chan->center_freq);
0885 
0886     params.block_tx = !!csa_ie.mode;
0887 
0888     if (ieee80211_channel_switch(sdata->local->hw.wiphy, sdata->dev,
0889                      &params))
0890         goto disconnect;
0891 
0892     ieee80211_ibss_csa_mark_radar(sdata);
0893 
0894     return true;
0895 disconnect:
0896     ibss_dbg(sdata, "Can't handle channel switch, disconnect\n");
0897     ieee80211_queue_work(&sdata->local->hw,
0898                  &ifibss->csa_connection_drop_work);
0899 
0900     ieee80211_ibss_csa_mark_radar(sdata);
0901 
0902     return true;
0903 }
0904 
0905 static void
0906 ieee80211_rx_mgmt_spectrum_mgmt(struct ieee80211_sub_if_data *sdata,
0907                 struct ieee80211_mgmt *mgmt, size_t len,
0908                 struct ieee80211_rx_status *rx_status,
0909                 struct ieee802_11_elems *elems)
0910 {
0911     int required_len;
0912 
0913     if (len < IEEE80211_MIN_ACTION_SIZE + 1)
0914         return;
0915 
0916     /* CSA is the only action we handle for now */
0917     if (mgmt->u.action.u.measurement.action_code !=
0918         WLAN_ACTION_SPCT_CHL_SWITCH)
0919         return;
0920 
0921     required_len = IEEE80211_MIN_ACTION_SIZE +
0922                sizeof(mgmt->u.action.u.chan_switch);
0923     if (len < required_len)
0924         return;
0925 
0926     if (!sdata->vif.bss_conf.csa_active)
0927         ieee80211_ibss_process_chanswitch(sdata, elems, false);
0928 }
0929 
0930 static void ieee80211_rx_mgmt_deauth_ibss(struct ieee80211_sub_if_data *sdata,
0931                       struct ieee80211_mgmt *mgmt,
0932                       size_t len)
0933 {
0934     u16 reason = le16_to_cpu(mgmt->u.deauth.reason_code);
0935 
0936     if (len < IEEE80211_DEAUTH_FRAME_LEN)
0937         return;
0938 
0939     ibss_dbg(sdata, "RX DeAuth SA=%pM DA=%pM\n", mgmt->sa, mgmt->da);
0940     ibss_dbg(sdata, "\tBSSID=%pM (reason: %d)\n", mgmt->bssid, reason);
0941     sta_info_destroy_addr(sdata, mgmt->sa);
0942 }
0943 
0944 static void ieee80211_rx_mgmt_auth_ibss(struct ieee80211_sub_if_data *sdata,
0945                     struct ieee80211_mgmt *mgmt,
0946                     size_t len)
0947 {
0948     u16 auth_alg, auth_transaction;
0949 
0950     sdata_assert_lock(sdata);
0951 
0952     if (len < 24 + 6)
0953         return;
0954 
0955     auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
0956     auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
0957 
0958     ibss_dbg(sdata, "RX Auth SA=%pM DA=%pM\n", mgmt->sa, mgmt->da);
0959     ibss_dbg(sdata, "\tBSSID=%pM (auth_transaction=%d)\n",
0960          mgmt->bssid, auth_transaction);
0961 
0962     if (auth_alg != WLAN_AUTH_OPEN || auth_transaction != 1)
0963         return;
0964 
0965     /*
0966      * IEEE 802.11 standard does not require authentication in IBSS
0967      * networks and most implementations do not seem to use it.
0968      * However, try to reply to authentication attempts if someone
0969      * has actually implemented this.
0970      */
0971     ieee80211_send_auth(sdata, 2, WLAN_AUTH_OPEN, 0, NULL, 0,
0972                 mgmt->sa, sdata->u.ibss.bssid, NULL, 0, 0, 0);
0973 }
0974 
0975 static void ieee80211_update_sta_info(struct ieee80211_sub_if_data *sdata,
0976                       struct ieee80211_mgmt *mgmt, size_t len,
0977                       struct ieee80211_rx_status *rx_status,
0978                       struct ieee802_11_elems *elems,
0979                       struct ieee80211_channel *channel)
0980 {
0981     struct sta_info *sta;
0982     enum nl80211_band band = rx_status->band;
0983     enum nl80211_bss_scan_width scan_width;
0984     struct ieee80211_local *local = sdata->local;
0985     struct ieee80211_supported_band *sband;
0986     bool rates_updated = false;
0987     u32 supp_rates = 0;
0988 
0989     if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
0990         return;
0991 
0992     if (!ether_addr_equal(mgmt->bssid, sdata->u.ibss.bssid))
0993         return;
0994 
0995     sband = local->hw.wiphy->bands[band];
0996     if (WARN_ON(!sband))
0997         return;
0998 
0999     rcu_read_lock();
1000     sta = sta_info_get(sdata, mgmt->sa);
1001 
1002     if (elems->supp_rates) {
1003         supp_rates = ieee80211_sta_get_rates(sdata, elems,
1004                              band, NULL);
1005         if (sta) {
1006             u32 prev_rates;
1007 
1008             prev_rates = sta->sta.deflink.supp_rates[band];
1009             /* make sure mandatory rates are always added */
1010             scan_width = NL80211_BSS_CHAN_WIDTH_20;
1011             if (rx_status->bw == RATE_INFO_BW_5)
1012                 scan_width = NL80211_BSS_CHAN_WIDTH_5;
1013             else if (rx_status->bw == RATE_INFO_BW_10)
1014                 scan_width = NL80211_BSS_CHAN_WIDTH_10;
1015 
1016             sta->sta.deflink.supp_rates[band] = supp_rates |
1017                 ieee80211_mandatory_rates(sband, scan_width);
1018             if (sta->sta.deflink.supp_rates[band] != prev_rates) {
1019                 ibss_dbg(sdata,
1020                      "updated supp_rates set for %pM based on beacon/probe_resp (0x%x -> 0x%x)\n",
1021                      sta->sta.addr, prev_rates,
1022                      sta->sta.deflink.supp_rates[band]);
1023                 rates_updated = true;
1024             }
1025         } else {
1026             rcu_read_unlock();
1027             sta = ieee80211_ibss_add_sta(sdata, mgmt->bssid,
1028                              mgmt->sa, supp_rates);
1029         }
1030     }
1031 
1032     if (sta && !sta->sta.wme &&
1033         (elems->wmm_info || elems->s1g_capab) &&
1034         local->hw.queues >= IEEE80211_NUM_ACS) {
1035         sta->sta.wme = true;
1036         ieee80211_check_fast_xmit(sta);
1037     }
1038 
1039     if (sta && elems->ht_operation && elems->ht_cap_elem &&
1040         sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
1041         sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_5 &&
1042         sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_10) {
1043         /* we both use HT */
1044         struct ieee80211_ht_cap htcap_ie;
1045         struct cfg80211_chan_def chandef;
1046         enum ieee80211_sta_rx_bandwidth bw = sta->sta.deflink.bandwidth;
1047 
1048         cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);
1049         ieee80211_chandef_ht_oper(elems->ht_operation, &chandef);
1050 
1051         memcpy(&htcap_ie, elems->ht_cap_elem, sizeof(htcap_ie));
1052         rates_updated |= ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1053                                    &htcap_ie,
1054                                    &sta->deflink);
1055 
1056         if (elems->vht_operation && elems->vht_cap_elem &&
1057             sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_20 &&
1058             sdata->u.ibss.chandef.width != NL80211_CHAN_WIDTH_40) {
1059             /* we both use VHT */
1060             struct ieee80211_vht_cap cap_ie;
1061             struct ieee80211_sta_vht_cap cap = sta->sta.deflink.vht_cap;
1062             u32 vht_cap_info =
1063                 le32_to_cpu(elems->vht_cap_elem->vht_cap_info);
1064 
1065             ieee80211_chandef_vht_oper(&local->hw, vht_cap_info,
1066                            elems->vht_operation,
1067                            elems->ht_operation,
1068                            &chandef);
1069             memcpy(&cap_ie, elems->vht_cap_elem, sizeof(cap_ie));
1070             ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1071                                 &cap_ie,
1072                                 &sta->deflink);
1073             if (memcmp(&cap, &sta->sta.deflink.vht_cap, sizeof(cap)))
1074                 rates_updated |= true;
1075         }
1076 
1077         if (bw != sta->sta.deflink.bandwidth)
1078             rates_updated |= true;
1079 
1080         if (!cfg80211_chandef_compatible(&sdata->u.ibss.chandef,
1081                          &chandef))
1082             WARN_ON_ONCE(1);
1083     }
1084 
1085     if (sta && rates_updated) {
1086         u32 changed = IEEE80211_RC_SUPP_RATES_CHANGED;
1087         u8 rx_nss = sta->sta.deflink.rx_nss;
1088 
1089         /* Force rx_nss recalculation */
1090         sta->sta.deflink.rx_nss = 0;
1091         rate_control_rate_init(sta);
1092         if (sta->sta.deflink.rx_nss != rx_nss)
1093             changed |= IEEE80211_RC_NSS_CHANGED;
1094 
1095         drv_sta_rc_update(local, sdata, &sta->sta, changed);
1096     }
1097 
1098     rcu_read_unlock();
1099 }
1100 
1101 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1102                   struct ieee80211_mgmt *mgmt, size_t len,
1103                   struct ieee80211_rx_status *rx_status,
1104                   struct ieee802_11_elems *elems)
1105 {
1106     struct ieee80211_local *local = sdata->local;
1107     struct cfg80211_bss *cbss;
1108     struct ieee80211_bss *bss;
1109     struct ieee80211_channel *channel;
1110     u64 beacon_timestamp, rx_timestamp;
1111     u32 supp_rates = 0;
1112     enum nl80211_band band = rx_status->band;
1113 
1114     channel = ieee80211_get_channel(local->hw.wiphy, rx_status->freq);
1115     if (!channel)
1116         return;
1117 
1118     ieee80211_update_sta_info(sdata, mgmt, len, rx_status, elems, channel);
1119 
1120     bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, channel);
1121     if (!bss)
1122         return;
1123 
1124     cbss = container_of((void *)bss, struct cfg80211_bss, priv);
1125 
1126     /* same for beacon and probe response */
1127     beacon_timestamp = le64_to_cpu(mgmt->u.beacon.timestamp);
1128 
1129     /* check if we need to merge IBSS */
1130 
1131     /* not an IBSS */
1132     if (!(cbss->capability & WLAN_CAPABILITY_IBSS))
1133         goto put_bss;
1134 
1135     /* different channel */
1136     if (sdata->u.ibss.fixed_channel &&
1137         sdata->u.ibss.chandef.chan != cbss->channel)
1138         goto put_bss;
1139 
1140     /* different SSID */
1141     if (elems->ssid_len != sdata->u.ibss.ssid_len ||
1142         memcmp(elems->ssid, sdata->u.ibss.ssid,
1143                 sdata->u.ibss.ssid_len))
1144         goto put_bss;
1145 
1146     /* process channel switch */
1147     if (sdata->vif.bss_conf.csa_active ||
1148         ieee80211_ibss_process_chanswitch(sdata, elems, true))
1149         goto put_bss;
1150 
1151     /* same BSSID */
1152     if (ether_addr_equal(cbss->bssid, sdata->u.ibss.bssid))
1153         goto put_bss;
1154 
1155     /* we use a fixed BSSID */
1156     if (sdata->u.ibss.fixed_bssid)
1157         goto put_bss;
1158 
1159     if (ieee80211_have_rx_timestamp(rx_status)) {
1160         /* time when timestamp field was received */
1161         rx_timestamp =
1162             ieee80211_calculate_rx_timestamp(local, rx_status,
1163                              len + FCS_LEN, 24);
1164     } else {
1165         /*
1166          * second best option: get current TSF
1167          * (will return -1 if not supported)
1168          */
1169         rx_timestamp = drv_get_tsf(local, sdata);
1170     }
1171 
1172     ibss_dbg(sdata, "RX beacon SA=%pM BSSID=%pM TSF=0x%llx\n",
1173          mgmt->sa, mgmt->bssid,
1174          (unsigned long long)rx_timestamp);
1175     ibss_dbg(sdata, "\tBCN=0x%llx diff=%lld @%lu\n",
1176          (unsigned long long)beacon_timestamp,
1177          (unsigned long long)(rx_timestamp - beacon_timestamp),
1178          jiffies);
1179 
1180     if (beacon_timestamp > rx_timestamp) {
1181         ibss_dbg(sdata,
1182              "beacon TSF higher than local TSF - IBSS merge with BSSID %pM\n",
1183              mgmt->bssid);
1184         ieee80211_sta_join_ibss(sdata, bss);
1185         supp_rates = ieee80211_sta_get_rates(sdata, elems, band, NULL);
1186         ieee80211_ibss_add_sta(sdata, mgmt->bssid, mgmt->sa,
1187                        supp_rates);
1188         rcu_read_unlock();
1189     }
1190 
1191  put_bss:
1192     ieee80211_rx_bss_put(local, bss);
1193 }
1194 
1195 void ieee80211_ibss_rx_no_sta(struct ieee80211_sub_if_data *sdata,
1196                   const u8 *bssid, const u8 *addr,
1197                   u32 supp_rates)
1198 {
1199     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1200     struct ieee80211_local *local = sdata->local;
1201     struct sta_info *sta;
1202     struct ieee80211_chanctx_conf *chanctx_conf;
1203     struct ieee80211_supported_band *sband;
1204     enum nl80211_bss_scan_width scan_width;
1205     int band;
1206 
1207     /*
1208      * XXX: Consider removing the least recently used entry and
1209      *  allow new one to be added.
1210      */
1211     if (local->num_sta >= IEEE80211_IBSS_MAX_STA_ENTRIES) {
1212         net_info_ratelimited("%s: No room for a new IBSS STA entry %pM\n",
1213                     sdata->name, addr);
1214         return;
1215     }
1216 
1217     if (ifibss->state == IEEE80211_IBSS_MLME_SEARCH)
1218         return;
1219 
1220     if (!ether_addr_equal(bssid, sdata->u.ibss.bssid))
1221         return;
1222 
1223     rcu_read_lock();
1224     chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
1225     if (WARN_ON_ONCE(!chanctx_conf)) {
1226         rcu_read_unlock();
1227         return;
1228     }
1229     band = chanctx_conf->def.chan->band;
1230     scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
1231     rcu_read_unlock();
1232 
1233     sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
1234     if (!sta)
1235         return;
1236 
1237     /* make sure mandatory rates are always added */
1238     sband = local->hw.wiphy->bands[band];
1239     sta->sta.deflink.supp_rates[band] = supp_rates |
1240             ieee80211_mandatory_rates(sband, scan_width);
1241 
1242     spin_lock(&ifibss->incomplete_lock);
1243     list_add(&sta->list, &ifibss->incomplete_stations);
1244     spin_unlock(&ifibss->incomplete_lock);
1245     ieee80211_queue_work(&local->hw, &sdata->work);
1246 }
1247 
1248 static void ieee80211_ibss_sta_expire(struct ieee80211_sub_if_data *sdata)
1249 {
1250     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1251     struct ieee80211_local *local = sdata->local;
1252     struct sta_info *sta, *tmp;
1253     unsigned long exp_time = IEEE80211_IBSS_INACTIVITY_LIMIT;
1254     unsigned long exp_rsn = IEEE80211_IBSS_RSN_INACTIVITY_LIMIT;
1255 
1256     mutex_lock(&local->sta_mtx);
1257 
1258     list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
1259         unsigned long last_active = ieee80211_sta_last_active(sta);
1260 
1261         if (sdata != sta->sdata)
1262             continue;
1263 
1264         if (time_is_before_jiffies(last_active + exp_time) ||
1265             (time_is_before_jiffies(last_active + exp_rsn) &&
1266              sta->sta_state != IEEE80211_STA_AUTHORIZED)) {
1267             u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
1268 
1269             sta_dbg(sta->sdata, "expiring inactive %sSTA %pM\n",
1270                 sta->sta_state != IEEE80211_STA_AUTHORIZED ?
1271                 "not authorized " : "", sta->sta.addr);
1272 
1273             ieee80211_send_deauth_disassoc(sdata, sta->sta.addr,
1274                                ifibss->bssid,
1275                                IEEE80211_STYPE_DEAUTH,
1276                                WLAN_REASON_DEAUTH_LEAVING,
1277                                true, frame_buf);
1278             WARN_ON(__sta_info_destroy(sta));
1279         }
1280     }
1281 
1282     mutex_unlock(&local->sta_mtx);
1283 }
1284 
1285 /*
1286  * This function is called with state == IEEE80211_IBSS_MLME_JOINED
1287  */
1288 
1289 static void ieee80211_sta_merge_ibss(struct ieee80211_sub_if_data *sdata)
1290 {
1291     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1292     enum nl80211_bss_scan_width scan_width;
1293 
1294     sdata_assert_lock(sdata);
1295 
1296     mod_timer(&ifibss->timer,
1297           round_jiffies(jiffies + IEEE80211_IBSS_MERGE_INTERVAL));
1298 
1299     ieee80211_ibss_sta_expire(sdata);
1300 
1301     if (time_before(jiffies, ifibss->last_scan_completed +
1302                IEEE80211_IBSS_MERGE_INTERVAL))
1303         return;
1304 
1305     if (ieee80211_sta_active_ibss(sdata))
1306         return;
1307 
1308     if (ifibss->fixed_channel)
1309         return;
1310 
1311     sdata_info(sdata,
1312            "No active IBSS STAs - trying to scan for other IBSS networks with same SSID (merge)\n");
1313 
1314     scan_width = cfg80211_chandef_to_scan_width(&ifibss->chandef);
1315     ieee80211_request_ibss_scan(sdata, ifibss->ssid, ifibss->ssid_len,
1316                     NULL, 0, scan_width);
1317 }
1318 
1319 static void ieee80211_sta_create_ibss(struct ieee80211_sub_if_data *sdata)
1320 {
1321     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1322     u8 bssid[ETH_ALEN];
1323     u16 capability;
1324     int i;
1325 
1326     sdata_assert_lock(sdata);
1327 
1328     if (ifibss->fixed_bssid) {
1329         memcpy(bssid, ifibss->bssid, ETH_ALEN);
1330     } else {
1331         /* Generate random, not broadcast, locally administered BSSID. Mix in
1332          * own MAC address to make sure that devices that do not have proper
1333          * random number generator get different BSSID. */
1334         get_random_bytes(bssid, ETH_ALEN);
1335         for (i = 0; i < ETH_ALEN; i++)
1336             bssid[i] ^= sdata->vif.addr[i];
1337         bssid[0] &= ~0x01;
1338         bssid[0] |= 0x02;
1339     }
1340 
1341     sdata_info(sdata, "Creating new IBSS network, BSSID %pM\n", bssid);
1342 
1343     capability = WLAN_CAPABILITY_IBSS;
1344 
1345     if (ifibss->privacy)
1346         capability |= WLAN_CAPABILITY_PRIVACY;
1347 
1348     __ieee80211_sta_join_ibss(sdata, bssid, sdata->vif.bss_conf.beacon_int,
1349                   &ifibss->chandef, ifibss->basic_rates,
1350                   capability, 0, true);
1351 }
1352 
1353 static unsigned ibss_setup_channels(struct wiphy *wiphy,
1354                     struct ieee80211_channel **channels,
1355                     unsigned int channels_max,
1356                     u32 center_freq, u32 width)
1357 {
1358     struct ieee80211_channel *chan = NULL;
1359     unsigned int n_chan = 0;
1360     u32 start_freq, end_freq, freq;
1361 
1362     if (width <= 20) {
1363         start_freq = center_freq;
1364         end_freq = center_freq;
1365     } else {
1366         start_freq = center_freq - width / 2 + 10;
1367         end_freq = center_freq + width / 2 - 10;
1368     }
1369 
1370     for (freq = start_freq; freq <= end_freq; freq += 20) {
1371         chan = ieee80211_get_channel(wiphy, freq);
1372         if (!chan)
1373             continue;
1374         if (n_chan >= channels_max)
1375             return n_chan;
1376 
1377         channels[n_chan] = chan;
1378         n_chan++;
1379     }
1380 
1381     return n_chan;
1382 }
1383 
1384 static unsigned int
1385 ieee80211_ibss_setup_scan_channels(struct wiphy *wiphy,
1386                    const struct cfg80211_chan_def *chandef,
1387                    struct ieee80211_channel **channels,
1388                    unsigned int channels_max)
1389 {
1390     unsigned int n_chan = 0;
1391     u32 width, cf1, cf2 = 0;
1392 
1393     switch (chandef->width) {
1394     case NL80211_CHAN_WIDTH_40:
1395         width = 40;
1396         break;
1397     case NL80211_CHAN_WIDTH_80P80:
1398         cf2 = chandef->center_freq2;
1399         fallthrough;
1400     case NL80211_CHAN_WIDTH_80:
1401         width = 80;
1402         break;
1403     case NL80211_CHAN_WIDTH_160:
1404         width = 160;
1405         break;
1406     default:
1407         width = 20;
1408         break;
1409     }
1410 
1411     cf1 = chandef->center_freq1;
1412 
1413     n_chan = ibss_setup_channels(wiphy, channels, channels_max, cf1, width);
1414 
1415     if (cf2)
1416         n_chan += ibss_setup_channels(wiphy, &channels[n_chan],
1417                           channels_max - n_chan, cf2,
1418                           width);
1419 
1420     return n_chan;
1421 }
1422 
1423 /*
1424  * This function is called with state == IEEE80211_IBSS_MLME_SEARCH
1425  */
1426 
1427 static void ieee80211_sta_find_ibss(struct ieee80211_sub_if_data *sdata)
1428 {
1429     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1430     struct ieee80211_local *local = sdata->local;
1431     struct cfg80211_bss *cbss;
1432     struct ieee80211_channel *chan = NULL;
1433     const u8 *bssid = NULL;
1434     enum nl80211_bss_scan_width scan_width;
1435     int active_ibss;
1436 
1437     sdata_assert_lock(sdata);
1438 
1439     active_ibss = ieee80211_sta_active_ibss(sdata);
1440     ibss_dbg(sdata, "sta_find_ibss (active_ibss=%d)\n", active_ibss);
1441 
1442     if (active_ibss)
1443         return;
1444 
1445     if (ifibss->fixed_bssid)
1446         bssid = ifibss->bssid;
1447     if (ifibss->fixed_channel)
1448         chan = ifibss->chandef.chan;
1449     if (!is_zero_ether_addr(ifibss->bssid))
1450         bssid = ifibss->bssid;
1451     cbss = cfg80211_get_bss(local->hw.wiphy, chan, bssid,
1452                 ifibss->ssid, ifibss->ssid_len,
1453                 IEEE80211_BSS_TYPE_IBSS,
1454                 IEEE80211_PRIVACY(ifibss->privacy));
1455 
1456     if (cbss) {
1457         struct ieee80211_bss *bss;
1458 
1459         bss = (void *)cbss->priv;
1460         ibss_dbg(sdata,
1461              "sta_find_ibss: selected %pM current %pM\n",
1462              cbss->bssid, ifibss->bssid);
1463         sdata_info(sdata,
1464                "Selected IBSS BSSID %pM based on configured SSID\n",
1465                cbss->bssid);
1466 
1467         ieee80211_sta_join_ibss(sdata, bss);
1468         ieee80211_rx_bss_put(local, bss);
1469         return;
1470     }
1471 
1472     /* if a fixed bssid and a fixed freq have been provided create the IBSS
1473      * directly and do not waste time scanning
1474      */
1475     if (ifibss->fixed_bssid && ifibss->fixed_channel) {
1476         sdata_info(sdata, "Created IBSS using preconfigured BSSID %pM\n",
1477                bssid);
1478         ieee80211_sta_create_ibss(sdata);
1479         return;
1480     }
1481 
1482 
1483     ibss_dbg(sdata, "sta_find_ibss: did not try to join ibss\n");
1484 
1485     /* Selected IBSS not found in current scan results - try to scan */
1486     if (time_after(jiffies, ifibss->last_scan_completed +
1487                     IEEE80211_SCAN_INTERVAL)) {
1488         struct ieee80211_channel *channels[8];
1489         unsigned int num;
1490 
1491         sdata_info(sdata, "Trigger new scan to find an IBSS to join\n");
1492 
1493         scan_width = cfg80211_chandef_to_scan_width(&ifibss->chandef);
1494 
1495         if (ifibss->fixed_channel) {
1496             num = ieee80211_ibss_setup_scan_channels(local->hw.wiphy,
1497                                  &ifibss->chandef,
1498                                  channels,
1499                                  ARRAY_SIZE(channels));
1500             ieee80211_request_ibss_scan(sdata, ifibss->ssid,
1501                             ifibss->ssid_len, channels,
1502                             num, scan_width);
1503         } else {
1504             ieee80211_request_ibss_scan(sdata, ifibss->ssid,
1505                             ifibss->ssid_len, NULL,
1506                             0, scan_width);
1507         }
1508     } else {
1509         int interval = IEEE80211_SCAN_INTERVAL;
1510 
1511         if (time_after(jiffies, ifibss->ibss_join_req +
1512                    IEEE80211_IBSS_JOIN_TIMEOUT))
1513             ieee80211_sta_create_ibss(sdata);
1514 
1515         mod_timer(&ifibss->timer,
1516               round_jiffies(jiffies + interval));
1517     }
1518 }
1519 
1520 static void ieee80211_rx_mgmt_probe_req(struct ieee80211_sub_if_data *sdata,
1521                     struct sk_buff *req)
1522 {
1523     struct ieee80211_mgmt *mgmt = (void *)req->data;
1524     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1525     struct ieee80211_local *local = sdata->local;
1526     int tx_last_beacon, len = req->len;
1527     struct sk_buff *skb;
1528     struct beacon_data *presp;
1529     u8 *pos, *end;
1530 
1531     sdata_assert_lock(sdata);
1532 
1533     presp = sdata_dereference(ifibss->presp, sdata);
1534 
1535     if (ifibss->state != IEEE80211_IBSS_MLME_JOINED ||
1536         len < 24 + 2 || !presp)
1537         return;
1538 
1539     tx_last_beacon = drv_tx_last_beacon(local);
1540 
1541     ibss_dbg(sdata, "RX ProbeReq SA=%pM DA=%pM\n", mgmt->sa, mgmt->da);
1542     ibss_dbg(sdata, "\tBSSID=%pM (tx_last_beacon=%d)\n",
1543          mgmt->bssid, tx_last_beacon);
1544 
1545     if (!tx_last_beacon && is_multicast_ether_addr(mgmt->da))
1546         return;
1547 
1548     if (!ether_addr_equal(mgmt->bssid, ifibss->bssid) &&
1549         !is_broadcast_ether_addr(mgmt->bssid))
1550         return;
1551 
1552     end = ((u8 *) mgmt) + len;
1553     pos = mgmt->u.probe_req.variable;
1554     if (pos[0] != WLAN_EID_SSID ||
1555         pos + 2 + pos[1] > end) {
1556         ibss_dbg(sdata, "Invalid SSID IE in ProbeReq from %pM\n",
1557              mgmt->sa);
1558         return;
1559     }
1560     if (pos[1] != 0 &&
1561         (pos[1] != ifibss->ssid_len ||
1562          memcmp(pos + 2, ifibss->ssid, ifibss->ssid_len))) {
1563         /* Ignore ProbeReq for foreign SSID */
1564         return;
1565     }
1566 
1567     /* Reply with ProbeResp */
1568     skb = dev_alloc_skb(local->tx_headroom + presp->head_len);
1569     if (!skb)
1570         return;
1571 
1572     skb_reserve(skb, local->tx_headroom);
1573     skb_put_data(skb, presp->head, presp->head_len);
1574 
1575     memcpy(((struct ieee80211_mgmt *) skb->data)->da, mgmt->sa, ETH_ALEN);
1576     ibss_dbg(sdata, "Sending ProbeResp to %pM\n", mgmt->sa);
1577     IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1578 
1579     /* avoid excessive retries for probe request to wildcard SSIDs */
1580     if (pos[1] == 0)
1581         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_NO_ACK;
1582 
1583     ieee80211_tx_skb(sdata, skb);
1584 }
1585 
1586 static
1587 void ieee80211_rx_mgmt_probe_beacon(struct ieee80211_sub_if_data *sdata,
1588                     struct ieee80211_mgmt *mgmt, size_t len,
1589                     struct ieee80211_rx_status *rx_status)
1590 {
1591     size_t baselen;
1592     struct ieee802_11_elems *elems;
1593 
1594     BUILD_BUG_ON(offsetof(typeof(mgmt->u.probe_resp), variable) !=
1595              offsetof(typeof(mgmt->u.beacon), variable));
1596 
1597     /*
1598      * either beacon or probe_resp but the variable field is at the
1599      * same offset
1600      */
1601     baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1602     if (baselen > len)
1603         return;
1604 
1605     elems = ieee802_11_parse_elems(mgmt->u.probe_resp.variable,
1606                        len - baselen, false, NULL);
1607 
1608     if (elems) {
1609         ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, elems);
1610         kfree(elems);
1611     }
1612 }
1613 
1614 void ieee80211_ibss_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1615                    struct sk_buff *skb)
1616 {
1617     struct ieee80211_rx_status *rx_status;
1618     struct ieee80211_mgmt *mgmt;
1619     u16 fc;
1620     struct ieee802_11_elems *elems;
1621     int ies_len;
1622 
1623     rx_status = IEEE80211_SKB_RXCB(skb);
1624     mgmt = (struct ieee80211_mgmt *) skb->data;
1625     fc = le16_to_cpu(mgmt->frame_control);
1626 
1627     sdata_lock(sdata);
1628 
1629     if (!sdata->u.ibss.ssid_len)
1630         goto mgmt_out; /* not ready to merge yet */
1631 
1632     switch (fc & IEEE80211_FCTL_STYPE) {
1633     case IEEE80211_STYPE_PROBE_REQ:
1634         ieee80211_rx_mgmt_probe_req(sdata, skb);
1635         break;
1636     case IEEE80211_STYPE_PROBE_RESP:
1637     case IEEE80211_STYPE_BEACON:
1638         ieee80211_rx_mgmt_probe_beacon(sdata, mgmt, skb->len,
1639                            rx_status);
1640         break;
1641     case IEEE80211_STYPE_AUTH:
1642         ieee80211_rx_mgmt_auth_ibss(sdata, mgmt, skb->len);
1643         break;
1644     case IEEE80211_STYPE_DEAUTH:
1645         ieee80211_rx_mgmt_deauth_ibss(sdata, mgmt, skb->len);
1646         break;
1647     case IEEE80211_STYPE_ACTION:
1648         switch (mgmt->u.action.category) {
1649         case WLAN_CATEGORY_SPECTRUM_MGMT:
1650             ies_len = skb->len -
1651                   offsetof(struct ieee80211_mgmt,
1652                        u.action.u.chan_switch.variable);
1653 
1654             if (ies_len < 0)
1655                 break;
1656 
1657             elems = ieee802_11_parse_elems(
1658                 mgmt->u.action.u.chan_switch.variable,
1659                 ies_len, true, NULL);
1660 
1661             if (elems && !elems->parse_error)
1662                 ieee80211_rx_mgmt_spectrum_mgmt(sdata, mgmt,
1663                                 skb->len,
1664                                 rx_status,
1665                                 elems);
1666             kfree(elems);
1667             break;
1668         }
1669     }
1670 
1671  mgmt_out:
1672     sdata_unlock(sdata);
1673 }
1674 
1675 void ieee80211_ibss_work(struct ieee80211_sub_if_data *sdata)
1676 {
1677     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1678     struct sta_info *sta;
1679 
1680     sdata_lock(sdata);
1681 
1682     /*
1683      * Work could be scheduled after scan or similar
1684      * when we aren't even joined (or trying) with a
1685      * network.
1686      */
1687     if (!ifibss->ssid_len)
1688         goto out;
1689 
1690     spin_lock_bh(&ifibss->incomplete_lock);
1691     while (!list_empty(&ifibss->incomplete_stations)) {
1692         sta = list_first_entry(&ifibss->incomplete_stations,
1693                        struct sta_info, list);
1694         list_del(&sta->list);
1695         spin_unlock_bh(&ifibss->incomplete_lock);
1696 
1697         ieee80211_ibss_finish_sta(sta);
1698         rcu_read_unlock();
1699         spin_lock_bh(&ifibss->incomplete_lock);
1700     }
1701     spin_unlock_bh(&ifibss->incomplete_lock);
1702 
1703     switch (ifibss->state) {
1704     case IEEE80211_IBSS_MLME_SEARCH:
1705         ieee80211_sta_find_ibss(sdata);
1706         break;
1707     case IEEE80211_IBSS_MLME_JOINED:
1708         ieee80211_sta_merge_ibss(sdata);
1709         break;
1710     default:
1711         WARN_ON(1);
1712         break;
1713     }
1714 
1715  out:
1716     sdata_unlock(sdata);
1717 }
1718 
1719 static void ieee80211_ibss_timer(struct timer_list *t)
1720 {
1721     struct ieee80211_sub_if_data *sdata =
1722         from_timer(sdata, t, u.ibss.timer);
1723 
1724     ieee80211_queue_work(&sdata->local->hw, &sdata->work);
1725 }
1726 
1727 void ieee80211_ibss_setup_sdata(struct ieee80211_sub_if_data *sdata)
1728 {
1729     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1730 
1731     timer_setup(&ifibss->timer, ieee80211_ibss_timer, 0);
1732     INIT_LIST_HEAD(&ifibss->incomplete_stations);
1733     spin_lock_init(&ifibss->incomplete_lock);
1734     INIT_WORK(&ifibss->csa_connection_drop_work,
1735           ieee80211_csa_connection_drop_work);
1736 }
1737 
1738 /* scan finished notification */
1739 void ieee80211_ibss_notify_scan_completed(struct ieee80211_local *local)
1740 {
1741     struct ieee80211_sub_if_data *sdata;
1742 
1743     mutex_lock(&local->iflist_mtx);
1744     list_for_each_entry(sdata, &local->interfaces, list) {
1745         if (!ieee80211_sdata_running(sdata))
1746             continue;
1747         if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
1748             continue;
1749         sdata->u.ibss.last_scan_completed = jiffies;
1750     }
1751     mutex_unlock(&local->iflist_mtx);
1752 }
1753 
1754 int ieee80211_ibss_join(struct ieee80211_sub_if_data *sdata,
1755             struct cfg80211_ibss_params *params)
1756 {
1757     u32 changed = 0;
1758     u32 rate_flags;
1759     struct ieee80211_supported_band *sband;
1760     enum ieee80211_chanctx_mode chanmode;
1761     struct ieee80211_local *local = sdata->local;
1762     int radar_detect_width = 0;
1763     int i;
1764     int ret;
1765 
1766     if (params->chandef.chan->freq_offset) {
1767         /* this may work, but is untested */
1768         return -EOPNOTSUPP;
1769     }
1770 
1771     ret = cfg80211_chandef_dfs_required(local->hw.wiphy,
1772                         &params->chandef,
1773                         sdata->wdev.iftype);
1774     if (ret < 0)
1775         return ret;
1776 
1777     if (ret > 0) {
1778         if (!params->userspace_handles_dfs)
1779             return -EINVAL;
1780         radar_detect_width = BIT(params->chandef.width);
1781     }
1782 
1783     chanmode = (params->channel_fixed && !ret) ?
1784         IEEE80211_CHANCTX_SHARED : IEEE80211_CHANCTX_EXCLUSIVE;
1785 
1786     mutex_lock(&local->chanctx_mtx);
1787     ret = ieee80211_check_combinations(sdata, &params->chandef, chanmode,
1788                        radar_detect_width);
1789     mutex_unlock(&local->chanctx_mtx);
1790     if (ret < 0)
1791         return ret;
1792 
1793     if (params->bssid) {
1794         memcpy(sdata->u.ibss.bssid, params->bssid, ETH_ALEN);
1795         sdata->u.ibss.fixed_bssid = true;
1796     } else
1797         sdata->u.ibss.fixed_bssid = false;
1798 
1799     sdata->u.ibss.privacy = params->privacy;
1800     sdata->u.ibss.control_port = params->control_port;
1801     sdata->u.ibss.userspace_handles_dfs = params->userspace_handles_dfs;
1802     sdata->u.ibss.basic_rates = params->basic_rates;
1803     sdata->u.ibss.last_scan_completed = jiffies;
1804 
1805     /* fix basic_rates if channel does not support these rates */
1806     rate_flags = ieee80211_chandef_rate_flags(&params->chandef);
1807     sband = local->hw.wiphy->bands[params->chandef.chan->band];
1808     for (i = 0; i < sband->n_bitrates; i++) {
1809         if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
1810             sdata->u.ibss.basic_rates &= ~BIT(i);
1811     }
1812     memcpy(sdata->vif.bss_conf.mcast_rate, params->mcast_rate,
1813            sizeof(params->mcast_rate));
1814 
1815     sdata->vif.bss_conf.beacon_int = params->beacon_interval;
1816 
1817     sdata->u.ibss.chandef = params->chandef;
1818     sdata->u.ibss.fixed_channel = params->channel_fixed;
1819 
1820     if (params->ie) {
1821         sdata->u.ibss.ie = kmemdup(params->ie, params->ie_len,
1822                        GFP_KERNEL);
1823         if (sdata->u.ibss.ie)
1824             sdata->u.ibss.ie_len = params->ie_len;
1825     }
1826 
1827     sdata->u.ibss.state = IEEE80211_IBSS_MLME_SEARCH;
1828     sdata->u.ibss.ibss_join_req = jiffies;
1829 
1830     memcpy(sdata->u.ibss.ssid, params->ssid, params->ssid_len);
1831     sdata->u.ibss.ssid_len = params->ssid_len;
1832 
1833     memcpy(&sdata->u.ibss.ht_capa, &params->ht_capa,
1834            sizeof(sdata->u.ibss.ht_capa));
1835     memcpy(&sdata->u.ibss.ht_capa_mask, &params->ht_capa_mask,
1836            sizeof(sdata->u.ibss.ht_capa_mask));
1837 
1838     /*
1839      * 802.11n-2009 9.13.3.1: In an IBSS, the HT Protection field is
1840      * reserved, but an HT STA shall protect HT transmissions as though
1841      * the HT Protection field were set to non-HT mixed mode.
1842      *
1843      * In an IBSS, the RIFS Mode field of the HT Operation element is
1844      * also reserved, but an HT STA shall operate as though this field
1845      * were set to 1.
1846      */
1847 
1848     sdata->vif.bss_conf.ht_operation_mode |=
1849           IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
1850         | IEEE80211_HT_PARAM_RIFS_MODE;
1851 
1852     changed |= BSS_CHANGED_HT | BSS_CHANGED_MCAST_RATE;
1853     ieee80211_link_info_change_notify(sdata, &sdata->deflink, changed);
1854 
1855     sdata->deflink.smps_mode = IEEE80211_SMPS_OFF;
1856     sdata->deflink.needed_rx_chains = local->rx_chains;
1857     sdata->control_port_over_nl80211 = params->control_port_over_nl80211;
1858 
1859     ieee80211_queue_work(&local->hw, &sdata->work);
1860 
1861     return 0;
1862 }
1863 
1864 int ieee80211_ibss_leave(struct ieee80211_sub_if_data *sdata)
1865 {
1866     struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
1867 
1868     ieee80211_ibss_disconnect(sdata);
1869     ifibss->ssid_len = 0;
1870     eth_zero_addr(ifibss->bssid);
1871 
1872     /* remove beacon */
1873     kfree(sdata->u.ibss.ie);
1874     sdata->u.ibss.ie = NULL;
1875     sdata->u.ibss.ie_len = 0;
1876 
1877     /* on the next join, re-program HT parameters */
1878     memset(&ifibss->ht_capa, 0, sizeof(ifibss->ht_capa));
1879     memset(&ifibss->ht_capa_mask, 0, sizeof(ifibss->ht_capa_mask));
1880 
1881     synchronize_rcu();
1882 
1883     skb_queue_purge(&sdata->skb_queue);
1884 
1885     del_timer_sync(&sdata->u.ibss.timer);
1886 
1887     return 0;
1888 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!