Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * cfg80211 MLME SAP interface
0004  *
0005  * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
0006  * Copyright (c) 2015       Intel Deutschland GmbH
0007  * Copyright (C) 2019-2020, 2022 Intel Corporation
0008  */
0009 
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/etherdevice.h>
0013 #include <linux/netdevice.h>
0014 #include <linux/nl80211.h>
0015 #include <linux/slab.h>
0016 #include <linux/wireless.h>
0017 #include <net/cfg80211.h>
0018 #include <net/iw_handler.h>
0019 #include "core.h"
0020 #include "nl80211.h"
0021 #include "rdev-ops.h"
0022 
0023 
0024 void cfg80211_rx_assoc_resp(struct net_device *dev,
0025                 struct cfg80211_rx_assoc_resp *data)
0026 {
0027     struct wireless_dev *wdev = dev->ieee80211_ptr;
0028     struct wiphy *wiphy = wdev->wiphy;
0029     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0030     struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)data->buf;
0031     struct cfg80211_connect_resp_params cr = {
0032         .timeout_reason = NL80211_TIMEOUT_UNSPECIFIED,
0033         .req_ie = data->req_ies,
0034         .req_ie_len = data->req_ies_len,
0035         .resp_ie = mgmt->u.assoc_resp.variable,
0036         .resp_ie_len = data->len -
0037                    offsetof(struct ieee80211_mgmt,
0038                     u.assoc_resp.variable),
0039         .status = le16_to_cpu(mgmt->u.assoc_resp.status_code),
0040         .ap_mld_addr = data->ap_mld_addr,
0041     };
0042     unsigned int link_id;
0043 
0044     for (link_id = 0; link_id < ARRAY_SIZE(data->links); link_id++) {
0045         cr.links[link_id].bss = data->links[link_id].bss;
0046         if (!cr.links[link_id].bss)
0047             continue;
0048         cr.links[link_id].bssid = data->links[link_id].bss->bssid;
0049         cr.links[link_id].addr = data->links[link_id].addr;
0050         /* need to have local link addresses for MLO connections */
0051         WARN_ON(cr.ap_mld_addr && !cr.links[link_id].addr);
0052 
0053         BUG_ON(!cr.links[link_id].bss->channel);
0054 
0055         if (cr.links[link_id].bss->channel->band == NL80211_BAND_S1GHZ) {
0056             WARN_ON(link_id);
0057             cr.resp_ie = (u8 *)&mgmt->u.s1g_assoc_resp.variable;
0058             cr.resp_ie_len = data->len -
0059                      offsetof(struct ieee80211_mgmt,
0060                           u.s1g_assoc_resp.variable);
0061         }
0062 
0063         if (cr.ap_mld_addr)
0064             cr.valid_links |= BIT(link_id);
0065     }
0066 
0067     trace_cfg80211_send_rx_assoc(dev, data);
0068 
0069     /*
0070      * This is a bit of a hack, we don't notify userspace of
0071      * a (re-)association reply if we tried to send a reassoc
0072      * and got a reject -- we only try again with an assoc
0073      * frame instead of reassoc.
0074      */
0075     if (cfg80211_sme_rx_assoc_resp(wdev, cr.status)) {
0076         for (link_id = 0; link_id < ARRAY_SIZE(data->links); link_id++) {
0077             struct cfg80211_bss *bss = data->links[link_id].bss;
0078 
0079             if (!bss)
0080                 continue;
0081 
0082             cfg80211_unhold_bss(bss_from_pub(bss));
0083             cfg80211_put_bss(wiphy, bss);
0084         }
0085         return;
0086     }
0087 
0088     nl80211_send_rx_assoc(rdev, dev, data);
0089     /* update current_bss etc., consumes the bss reference */
0090     __cfg80211_connect_result(dev, &cr, cr.status == WLAN_STATUS_SUCCESS);
0091 }
0092 EXPORT_SYMBOL(cfg80211_rx_assoc_resp);
0093 
0094 static void cfg80211_process_auth(struct wireless_dev *wdev,
0095                   const u8 *buf, size_t len)
0096 {
0097     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0098 
0099     nl80211_send_rx_auth(rdev, wdev->netdev, buf, len, GFP_KERNEL);
0100     cfg80211_sme_rx_auth(wdev, buf, len);
0101 }
0102 
0103 static void cfg80211_process_deauth(struct wireless_dev *wdev,
0104                     const u8 *buf, size_t len,
0105                     bool reconnect)
0106 {
0107     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0108     struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
0109     const u8 *bssid = mgmt->bssid;
0110     u16 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
0111     bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr);
0112 
0113     nl80211_send_deauth(rdev, wdev->netdev, buf, len, reconnect, GFP_KERNEL);
0114 
0115     if (!wdev->connected || !ether_addr_equal(wdev->u.client.connected_addr, bssid))
0116         return;
0117 
0118     __cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap);
0119     cfg80211_sme_deauth(wdev);
0120 }
0121 
0122 static void cfg80211_process_disassoc(struct wireless_dev *wdev,
0123                       const u8 *buf, size_t len,
0124                       bool reconnect)
0125 {
0126     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0127     struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
0128     const u8 *bssid = mgmt->bssid;
0129     u16 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
0130     bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr);
0131 
0132     nl80211_send_disassoc(rdev, wdev->netdev, buf, len, reconnect,
0133                   GFP_KERNEL);
0134 
0135     if (WARN_ON(!wdev->connected ||
0136             !ether_addr_equal(wdev->u.client.connected_addr, bssid)))
0137         return;
0138 
0139     __cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap);
0140     cfg80211_sme_disassoc(wdev);
0141 }
0142 
0143 void cfg80211_rx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len)
0144 {
0145     struct wireless_dev *wdev = dev->ieee80211_ptr;
0146     struct ieee80211_mgmt *mgmt = (void *)buf;
0147 
0148     ASSERT_WDEV_LOCK(wdev);
0149 
0150     trace_cfg80211_rx_mlme_mgmt(dev, buf, len);
0151 
0152     if (WARN_ON(len < 2))
0153         return;
0154 
0155     if (ieee80211_is_auth(mgmt->frame_control))
0156         cfg80211_process_auth(wdev, buf, len);
0157     else if (ieee80211_is_deauth(mgmt->frame_control))
0158         cfg80211_process_deauth(wdev, buf, len, false);
0159     else if (ieee80211_is_disassoc(mgmt->frame_control))
0160         cfg80211_process_disassoc(wdev, buf, len, false);
0161 }
0162 EXPORT_SYMBOL(cfg80211_rx_mlme_mgmt);
0163 
0164 void cfg80211_auth_timeout(struct net_device *dev, const u8 *addr)
0165 {
0166     struct wireless_dev *wdev = dev->ieee80211_ptr;
0167     struct wiphy *wiphy = wdev->wiphy;
0168     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0169 
0170     trace_cfg80211_send_auth_timeout(dev, addr);
0171 
0172     nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
0173     cfg80211_sme_auth_timeout(wdev);
0174 }
0175 EXPORT_SYMBOL(cfg80211_auth_timeout);
0176 
0177 void cfg80211_assoc_failure(struct net_device *dev,
0178                 struct cfg80211_assoc_failure *data)
0179 {
0180     struct wireless_dev *wdev = dev->ieee80211_ptr;
0181     struct wiphy *wiphy = wdev->wiphy;
0182     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0183     const u8 *addr = data->ap_mld_addr ?: data->bss[0]->bssid;
0184     int i;
0185 
0186     trace_cfg80211_send_assoc_failure(dev, data);
0187 
0188     if (data->timeout) {
0189         nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
0190         cfg80211_sme_assoc_timeout(wdev);
0191     } else {
0192         cfg80211_sme_abandon_assoc(wdev);
0193     }
0194 
0195     for (i = 0; i < ARRAY_SIZE(data->bss); i++) {
0196         struct cfg80211_bss *bss = data->bss[i];
0197 
0198         if (!bss)
0199             continue;
0200 
0201         cfg80211_unhold_bss(bss_from_pub(bss));
0202         cfg80211_put_bss(wiphy, bss);
0203     }
0204 }
0205 EXPORT_SYMBOL(cfg80211_assoc_failure);
0206 
0207 void cfg80211_tx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len,
0208                bool reconnect)
0209 {
0210     struct wireless_dev *wdev = dev->ieee80211_ptr;
0211     struct ieee80211_mgmt *mgmt = (void *)buf;
0212 
0213     ASSERT_WDEV_LOCK(wdev);
0214 
0215     trace_cfg80211_tx_mlme_mgmt(dev, buf, len, reconnect);
0216 
0217     if (WARN_ON(len < 2))
0218         return;
0219 
0220     if (ieee80211_is_deauth(mgmt->frame_control))
0221         cfg80211_process_deauth(wdev, buf, len, reconnect);
0222     else
0223         cfg80211_process_disassoc(wdev, buf, len, reconnect);
0224 }
0225 EXPORT_SYMBOL(cfg80211_tx_mlme_mgmt);
0226 
0227 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
0228                   enum nl80211_key_type key_type, int key_id,
0229                   const u8 *tsc, gfp_t gfp)
0230 {
0231     struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
0232     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0233 #ifdef CONFIG_CFG80211_WEXT
0234     union iwreq_data wrqu;
0235     char *buf = kmalloc(128, gfp);
0236 
0237     if (buf) {
0238         sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
0239             "keyid=%d %scast addr=%pM)", key_id,
0240             key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
0241             addr);
0242         memset(&wrqu, 0, sizeof(wrqu));
0243         wrqu.data.length = strlen(buf);
0244         wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
0245         kfree(buf);
0246     }
0247 #endif
0248 
0249     trace_cfg80211_michael_mic_failure(dev, addr, key_type, key_id, tsc);
0250     nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
0251 }
0252 EXPORT_SYMBOL(cfg80211_michael_mic_failure);
0253 
0254 /* some MLME handling for userspace SME */
0255 int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
0256                struct net_device *dev,
0257                struct cfg80211_auth_request *req)
0258 {
0259     struct wireless_dev *wdev = dev->ieee80211_ptr;
0260 
0261     ASSERT_WDEV_LOCK(wdev);
0262 
0263     if (!req->bss)
0264         return -ENOENT;
0265 
0266     if (req->link_id >= 0 &&
0267         !(wdev->wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO))
0268         return -EINVAL;
0269 
0270     if (req->auth_type == NL80211_AUTHTYPE_SHARED_KEY) {
0271         if (!req->key || !req->key_len ||
0272             req->key_idx < 0 || req->key_idx > 3)
0273             return -EINVAL;
0274     }
0275 
0276     if (wdev->connected &&
0277         ether_addr_equal(req->bss->bssid, wdev->u.client.connected_addr))
0278         return -EALREADY;
0279 
0280     return rdev_auth(rdev, dev, req);
0281 }
0282 
0283 /*  Do a logical ht_capa &= ht_capa_mask.  */
0284 void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa,
0285                    const struct ieee80211_ht_cap *ht_capa_mask)
0286 {
0287     int i;
0288     u8 *p1, *p2;
0289     if (!ht_capa_mask) {
0290         memset(ht_capa, 0, sizeof(*ht_capa));
0291         return;
0292     }
0293 
0294     p1 = (u8*)(ht_capa);
0295     p2 = (u8*)(ht_capa_mask);
0296     for (i = 0; i < sizeof(*ht_capa); i++)
0297         p1[i] &= p2[i];
0298 }
0299 
0300 /*  Do a logical vht_capa &= vht_capa_mask.  */
0301 void cfg80211_oper_and_vht_capa(struct ieee80211_vht_cap *vht_capa,
0302                 const struct ieee80211_vht_cap *vht_capa_mask)
0303 {
0304     int i;
0305     u8 *p1, *p2;
0306     if (!vht_capa_mask) {
0307         memset(vht_capa, 0, sizeof(*vht_capa));
0308         return;
0309     }
0310 
0311     p1 = (u8*)(vht_capa);
0312     p2 = (u8*)(vht_capa_mask);
0313     for (i = 0; i < sizeof(*vht_capa); i++)
0314         p1[i] &= p2[i];
0315 }
0316 
0317 /* Note: caller must cfg80211_put_bss() regardless of result */
0318 int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
0319             struct net_device *dev,
0320             struct cfg80211_assoc_request *req)
0321 {
0322     struct wireless_dev *wdev = dev->ieee80211_ptr;
0323     int err, i, j;
0324 
0325     ASSERT_WDEV_LOCK(wdev);
0326 
0327     for (i = 1; i < ARRAY_SIZE(req->links); i++) {
0328         if (!req->links[i].bss)
0329             continue;
0330         for (j = 0; j < i; j++) {
0331             if (req->links[i].bss == req->links[j].bss)
0332                 return -EINVAL;
0333         }
0334     }
0335 
0336     if (wdev->connected &&
0337         (!req->prev_bssid ||
0338          !ether_addr_equal(wdev->u.client.connected_addr, req->prev_bssid)))
0339         return -EALREADY;
0340 
0341     cfg80211_oper_and_ht_capa(&req->ht_capa_mask,
0342                   rdev->wiphy.ht_capa_mod_mask);
0343     cfg80211_oper_and_vht_capa(&req->vht_capa_mask,
0344                    rdev->wiphy.vht_capa_mod_mask);
0345 
0346     err = rdev_assoc(rdev, dev, req);
0347     if (!err) {
0348         int link_id;
0349 
0350         if (req->bss) {
0351             cfg80211_ref_bss(&rdev->wiphy, req->bss);
0352             cfg80211_hold_bss(bss_from_pub(req->bss));
0353         }
0354 
0355         for (link_id = 0; link_id < ARRAY_SIZE(req->links); link_id++) {
0356             if (!req->links[link_id].bss)
0357                 continue;
0358             cfg80211_ref_bss(&rdev->wiphy, req->links[link_id].bss);
0359             cfg80211_hold_bss(bss_from_pub(req->links[link_id].bss));
0360         }
0361     }
0362     return err;
0363 }
0364 
0365 int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
0366              struct net_device *dev, const u8 *bssid,
0367              const u8 *ie, int ie_len, u16 reason,
0368              bool local_state_change)
0369 {
0370     struct wireless_dev *wdev = dev->ieee80211_ptr;
0371     struct cfg80211_deauth_request req = {
0372         .bssid = bssid,
0373         .reason_code = reason,
0374         .ie = ie,
0375         .ie_len = ie_len,
0376         .local_state_change = local_state_change,
0377     };
0378 
0379     ASSERT_WDEV_LOCK(wdev);
0380 
0381     if (local_state_change &&
0382         (!wdev->connected ||
0383          !ether_addr_equal(wdev->u.client.connected_addr, bssid)))
0384         return 0;
0385 
0386     if (ether_addr_equal(wdev->disconnect_bssid, bssid) ||
0387         (wdev->connected &&
0388          ether_addr_equal(wdev->u.client.connected_addr, bssid)))
0389         wdev->conn_owner_nlportid = 0;
0390 
0391     return rdev_deauth(rdev, dev, &req);
0392 }
0393 
0394 int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
0395                struct net_device *dev, const u8 *ap_addr,
0396                const u8 *ie, int ie_len, u16 reason,
0397                bool local_state_change)
0398 {
0399     struct wireless_dev *wdev = dev->ieee80211_ptr;
0400     struct cfg80211_disassoc_request req = {
0401         .reason_code = reason,
0402         .local_state_change = local_state_change,
0403         .ie = ie,
0404         .ie_len = ie_len,
0405         .ap_addr = ap_addr,
0406     };
0407     int err;
0408 
0409     ASSERT_WDEV_LOCK(wdev);
0410 
0411     if (!wdev->connected)
0412         return -ENOTCONN;
0413 
0414     if (memcmp(wdev->u.client.connected_addr, ap_addr, ETH_ALEN))
0415         return -ENOTCONN;
0416 
0417     err = rdev_disassoc(rdev, dev, &req);
0418     if (err)
0419         return err;
0420 
0421     /* driver should have reported the disassoc */
0422     WARN_ON(wdev->connected);
0423     return 0;
0424 }
0425 
0426 void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
0427             struct net_device *dev)
0428 {
0429     struct wireless_dev *wdev = dev->ieee80211_ptr;
0430     u8 bssid[ETH_ALEN];
0431 
0432     ASSERT_WDEV_LOCK(wdev);
0433 
0434     if (!rdev->ops->deauth)
0435         return;
0436 
0437     if (!wdev->connected)
0438         return;
0439 
0440     memcpy(bssid, wdev->u.client.connected_addr, ETH_ALEN);
0441     cfg80211_mlme_deauth(rdev, dev, bssid, NULL, 0,
0442                  WLAN_REASON_DEAUTH_LEAVING, false);
0443 }
0444 
0445 struct cfg80211_mgmt_registration {
0446     struct list_head list;
0447     struct wireless_dev *wdev;
0448 
0449     u32 nlportid;
0450 
0451     int match_len;
0452 
0453     __le16 frame_type;
0454 
0455     bool multicast_rx;
0456 
0457     u8 match[];
0458 };
0459 
0460 static void cfg80211_mgmt_registrations_update(struct wireless_dev *wdev)
0461 {
0462     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0463     struct wireless_dev *tmp;
0464     struct cfg80211_mgmt_registration *reg;
0465     struct mgmt_frame_regs upd = {};
0466 
0467     lockdep_assert_held(&rdev->wiphy.mtx);
0468 
0469     spin_lock_bh(&rdev->mgmt_registrations_lock);
0470     if (!wdev->mgmt_registrations_need_update) {
0471         spin_unlock_bh(&rdev->mgmt_registrations_lock);
0472         return;
0473     }
0474 
0475     rcu_read_lock();
0476     list_for_each_entry_rcu(tmp, &rdev->wiphy.wdev_list, list) {
0477         list_for_each_entry(reg, &tmp->mgmt_registrations, list) {
0478             u32 mask = BIT(le16_to_cpu(reg->frame_type) >> 4);
0479             u32 mcast_mask = 0;
0480 
0481             if (reg->multicast_rx)
0482                 mcast_mask = mask;
0483 
0484             upd.global_stypes |= mask;
0485             upd.global_mcast_stypes |= mcast_mask;
0486 
0487             if (tmp == wdev) {
0488                 upd.interface_stypes |= mask;
0489                 upd.interface_mcast_stypes |= mcast_mask;
0490             }
0491         }
0492     }
0493     rcu_read_unlock();
0494 
0495     wdev->mgmt_registrations_need_update = 0;
0496     spin_unlock_bh(&rdev->mgmt_registrations_lock);
0497 
0498     rdev_update_mgmt_frame_registrations(rdev, wdev, &upd);
0499 }
0500 
0501 void cfg80211_mgmt_registrations_update_wk(struct work_struct *wk)
0502 {
0503     struct cfg80211_registered_device *rdev;
0504     struct wireless_dev *wdev;
0505 
0506     rdev = container_of(wk, struct cfg80211_registered_device,
0507                 mgmt_registrations_update_wk);
0508 
0509     wiphy_lock(&rdev->wiphy);
0510     list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list)
0511         cfg80211_mgmt_registrations_update(wdev);
0512     wiphy_unlock(&rdev->wiphy);
0513 }
0514 
0515 int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_portid,
0516                 u16 frame_type, const u8 *match_data,
0517                 int match_len, bool multicast_rx,
0518                 struct netlink_ext_ack *extack)
0519 {
0520     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0521     struct cfg80211_mgmt_registration *reg, *nreg;
0522     int err = 0;
0523     u16 mgmt_type;
0524     bool update_multicast = false;
0525 
0526     if (!wdev->wiphy->mgmt_stypes)
0527         return -EOPNOTSUPP;
0528 
0529     if ((frame_type & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT) {
0530         NL_SET_ERR_MSG(extack, "frame type not management");
0531         return -EINVAL;
0532     }
0533 
0534     if (frame_type & ~(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE)) {
0535         NL_SET_ERR_MSG(extack, "Invalid frame type");
0536         return -EINVAL;
0537     }
0538 
0539     mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
0540     if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].rx & BIT(mgmt_type))) {
0541         NL_SET_ERR_MSG(extack,
0542                    "Registration to specific type not supported");
0543         return -EINVAL;
0544     }
0545 
0546     /*
0547      * To support Pre Association Security Negotiation (PASN), registration
0548      * for authentication frames should be supported. However, as some
0549      * versions of the user space daemons wrongly register to all types of
0550      * authentication frames (which might result in unexpected behavior)
0551      * allow such registration if the request is for a specific
0552      * authentication algorithm number.
0553      */
0554     if (wdev->iftype == NL80211_IFTYPE_STATION &&
0555         (frame_type & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_AUTH &&
0556         !(match_data && match_len >= 2)) {
0557         NL_SET_ERR_MSG(extack,
0558                    "Authentication algorithm number required");
0559         return -EINVAL;
0560     }
0561 
0562     nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
0563     if (!nreg)
0564         return -ENOMEM;
0565 
0566     spin_lock_bh(&rdev->mgmt_registrations_lock);
0567 
0568     list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
0569         int mlen = min(match_len, reg->match_len);
0570 
0571         if (frame_type != le16_to_cpu(reg->frame_type))
0572             continue;
0573 
0574         if (memcmp(reg->match, match_data, mlen) == 0) {
0575             if (reg->multicast_rx != multicast_rx) {
0576                 update_multicast = true;
0577                 reg->multicast_rx = multicast_rx;
0578                 break;
0579             }
0580             NL_SET_ERR_MSG(extack, "Match already configured");
0581             err = -EALREADY;
0582             break;
0583         }
0584     }
0585 
0586     if (err)
0587         goto out;
0588 
0589     if (update_multicast) {
0590         kfree(nreg);
0591     } else {
0592         memcpy(nreg->match, match_data, match_len);
0593         nreg->match_len = match_len;
0594         nreg->nlportid = snd_portid;
0595         nreg->frame_type = cpu_to_le16(frame_type);
0596         nreg->wdev = wdev;
0597         nreg->multicast_rx = multicast_rx;
0598         list_add(&nreg->list, &wdev->mgmt_registrations);
0599     }
0600     wdev->mgmt_registrations_need_update = 1;
0601     spin_unlock_bh(&rdev->mgmt_registrations_lock);
0602 
0603     cfg80211_mgmt_registrations_update(wdev);
0604 
0605     return 0;
0606 
0607  out:
0608     kfree(nreg);
0609     spin_unlock_bh(&rdev->mgmt_registrations_lock);
0610 
0611     return err;
0612 }
0613 
0614 void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlportid)
0615 {
0616     struct wiphy *wiphy = wdev->wiphy;
0617     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0618     struct cfg80211_mgmt_registration *reg, *tmp;
0619 
0620     spin_lock_bh(&rdev->mgmt_registrations_lock);
0621 
0622     list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
0623         if (reg->nlportid != nlportid)
0624             continue;
0625 
0626         list_del(&reg->list);
0627         kfree(reg);
0628 
0629         wdev->mgmt_registrations_need_update = 1;
0630         schedule_work(&rdev->mgmt_registrations_update_wk);
0631     }
0632 
0633     spin_unlock_bh(&rdev->mgmt_registrations_lock);
0634 
0635     if (nlportid && rdev->crit_proto_nlportid == nlportid) {
0636         rdev->crit_proto_nlportid = 0;
0637         rdev_crit_proto_stop(rdev, wdev);
0638     }
0639 
0640     if (nlportid == wdev->ap_unexpected_nlportid)
0641         wdev->ap_unexpected_nlportid = 0;
0642 }
0643 
0644 void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev)
0645 {
0646     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0647     struct cfg80211_mgmt_registration *reg, *tmp;
0648 
0649     spin_lock_bh(&rdev->mgmt_registrations_lock);
0650     list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
0651         list_del(&reg->list);
0652         kfree(reg);
0653     }
0654     wdev->mgmt_registrations_need_update = 1;
0655     spin_unlock_bh(&rdev->mgmt_registrations_lock);
0656 
0657     cfg80211_mgmt_registrations_update(wdev);
0658 }
0659 
0660 static bool cfg80211_allowed_address(struct wireless_dev *wdev, const u8 *addr)
0661 {
0662     int i;
0663 
0664     for_each_valid_link(wdev, i) {
0665         if (ether_addr_equal(addr, wdev->links[i].addr))
0666             return true;
0667     }
0668 
0669     return ether_addr_equal(addr, wdev_address(wdev));
0670 }
0671 
0672 int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
0673               struct wireless_dev *wdev,
0674               struct cfg80211_mgmt_tx_params *params, u64 *cookie)
0675 {
0676     const struct ieee80211_mgmt *mgmt;
0677     u16 stype;
0678 
0679     if (!wdev->wiphy->mgmt_stypes)
0680         return -EOPNOTSUPP;
0681 
0682     if (!rdev->ops->mgmt_tx)
0683         return -EOPNOTSUPP;
0684 
0685     if (params->len < 24 + 1)
0686         return -EINVAL;
0687 
0688     mgmt = (const struct ieee80211_mgmt *)params->buf;
0689 
0690     if (!ieee80211_is_mgmt(mgmt->frame_control))
0691         return -EINVAL;
0692 
0693     stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
0694     if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].tx & BIT(stype >> 4)))
0695         return -EINVAL;
0696 
0697     if (ieee80211_is_action(mgmt->frame_control) &&
0698         mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
0699         int err = 0;
0700 
0701         wdev_lock(wdev);
0702 
0703         switch (wdev->iftype) {
0704         case NL80211_IFTYPE_ADHOC:
0705             /*
0706              * check for IBSS DA must be done by driver as
0707              * cfg80211 doesn't track the stations
0708              */
0709             if (!wdev->u.ibss.current_bss ||
0710                 !ether_addr_equal(wdev->u.ibss.current_bss->pub.bssid,
0711                           mgmt->bssid)) {
0712                 err = -ENOTCONN;
0713                 break;
0714             }
0715             break;
0716         case NL80211_IFTYPE_STATION:
0717         case NL80211_IFTYPE_P2P_CLIENT:
0718             if (!wdev->connected) {
0719                 err = -ENOTCONN;
0720                 break;
0721             }
0722 
0723             /* FIXME: MLD may address this differently */
0724 
0725             if (!ether_addr_equal(wdev->u.client.connected_addr,
0726                           mgmt->bssid)) {
0727                 err = -ENOTCONN;
0728                 break;
0729             }
0730 
0731             /* for station, check that DA is the AP */
0732             if (!ether_addr_equal(wdev->u.client.connected_addr,
0733                           mgmt->da)) {
0734                 err = -ENOTCONN;
0735                 break;
0736             }
0737             break;
0738         case NL80211_IFTYPE_AP:
0739         case NL80211_IFTYPE_P2P_GO:
0740         case NL80211_IFTYPE_AP_VLAN:
0741             if (!ether_addr_equal(mgmt->bssid, wdev_address(wdev)))
0742                 err = -EINVAL;
0743             break;
0744         case NL80211_IFTYPE_MESH_POINT:
0745             if (!ether_addr_equal(mgmt->sa, mgmt->bssid)) {
0746                 err = -EINVAL;
0747                 break;
0748             }
0749             /*
0750              * check for mesh DA must be done by driver as
0751              * cfg80211 doesn't track the stations
0752              */
0753             break;
0754         case NL80211_IFTYPE_P2P_DEVICE:
0755             /*
0756              * fall through, P2P device only supports
0757              * public action frames
0758              */
0759         case NL80211_IFTYPE_NAN:
0760         default:
0761             err = -EOPNOTSUPP;
0762             break;
0763         }
0764         wdev_unlock(wdev);
0765 
0766         if (err)
0767             return err;
0768     }
0769 
0770     if (!cfg80211_allowed_address(wdev, mgmt->sa)) {
0771         /* Allow random TA to be used with Public Action frames if the
0772          * driver has indicated support for this. Otherwise, only allow
0773          * the local address to be used.
0774          */
0775         if (!ieee80211_is_action(mgmt->frame_control) ||
0776             mgmt->u.action.category != WLAN_CATEGORY_PUBLIC)
0777             return -EINVAL;
0778         if (!wdev->connected &&
0779             !wiphy_ext_feature_isset(
0780                 &rdev->wiphy,
0781                 NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA))
0782             return -EINVAL;
0783         if (wdev->connected &&
0784             !wiphy_ext_feature_isset(
0785                 &rdev->wiphy,
0786                 NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTED))
0787             return -EINVAL;
0788     }
0789 
0790     /* Transmit the management frame as requested by user space */
0791     return rdev_mgmt_tx(rdev, wdev, params, cookie);
0792 }
0793 
0794 bool cfg80211_rx_mgmt_ext(struct wireless_dev *wdev,
0795               struct cfg80211_rx_info *info)
0796 {
0797     struct wiphy *wiphy = wdev->wiphy;
0798     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0799     struct cfg80211_mgmt_registration *reg;
0800     const struct ieee80211_txrx_stypes *stypes =
0801         &wiphy->mgmt_stypes[wdev->iftype];
0802     struct ieee80211_mgmt *mgmt = (void *)info->buf;
0803     const u8 *data;
0804     int data_len;
0805     bool result = false;
0806     __le16 ftype = mgmt->frame_control &
0807         cpu_to_le16(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE);
0808     u16 stype;
0809 
0810     trace_cfg80211_rx_mgmt(wdev, info);
0811     stype = (le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
0812 
0813     if (!(stypes->rx & BIT(stype))) {
0814         trace_cfg80211_return_bool(false);
0815         return false;
0816     }
0817 
0818     data = info->buf + ieee80211_hdrlen(mgmt->frame_control);
0819     data_len = info->len - ieee80211_hdrlen(mgmt->frame_control);
0820 
0821     spin_lock_bh(&rdev->mgmt_registrations_lock);
0822 
0823     list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
0824         if (reg->frame_type != ftype)
0825             continue;
0826 
0827         if (reg->match_len > data_len)
0828             continue;
0829 
0830         if (memcmp(reg->match, data, reg->match_len))
0831             continue;
0832 
0833         /* found match! */
0834 
0835         /* Indicate the received Action frame to user space */
0836         if (nl80211_send_mgmt(rdev, wdev, reg->nlportid, info,
0837                       GFP_ATOMIC))
0838             continue;
0839 
0840         result = true;
0841         break;
0842     }
0843 
0844     spin_unlock_bh(&rdev->mgmt_registrations_lock);
0845 
0846     trace_cfg80211_return_bool(result);
0847     return result;
0848 }
0849 EXPORT_SYMBOL(cfg80211_rx_mgmt_ext);
0850 
0851 void cfg80211_sched_dfs_chan_update(struct cfg80211_registered_device *rdev)
0852 {
0853     cancel_delayed_work(&rdev->dfs_update_channels_wk);
0854     queue_delayed_work(cfg80211_wq, &rdev->dfs_update_channels_wk, 0);
0855 }
0856 
0857 void cfg80211_dfs_channels_update_work(struct work_struct *work)
0858 {
0859     struct delayed_work *delayed_work = to_delayed_work(work);
0860     struct cfg80211_registered_device *rdev;
0861     struct cfg80211_chan_def chandef;
0862     struct ieee80211_supported_band *sband;
0863     struct ieee80211_channel *c;
0864     struct wiphy *wiphy;
0865     bool check_again = false;
0866     unsigned long timeout, next_time = 0;
0867     unsigned long time_dfs_update;
0868     enum nl80211_radar_event radar_event;
0869     int bandid, i;
0870 
0871     rdev = container_of(delayed_work, struct cfg80211_registered_device,
0872                 dfs_update_channels_wk);
0873     wiphy = &rdev->wiphy;
0874 
0875     rtnl_lock();
0876     for (bandid = 0; bandid < NUM_NL80211_BANDS; bandid++) {
0877         sband = wiphy->bands[bandid];
0878         if (!sband)
0879             continue;
0880 
0881         for (i = 0; i < sband->n_channels; i++) {
0882             c = &sband->channels[i];
0883 
0884             if (!(c->flags & IEEE80211_CHAN_RADAR))
0885                 continue;
0886 
0887             if (c->dfs_state != NL80211_DFS_UNAVAILABLE &&
0888                 c->dfs_state != NL80211_DFS_AVAILABLE)
0889                 continue;
0890 
0891             if (c->dfs_state == NL80211_DFS_UNAVAILABLE) {
0892                 time_dfs_update = IEEE80211_DFS_MIN_NOP_TIME_MS;
0893                 radar_event = NL80211_RADAR_NOP_FINISHED;
0894             } else {
0895                 if (regulatory_pre_cac_allowed(wiphy) ||
0896                     cfg80211_any_wiphy_oper_chan(wiphy, c))
0897                     continue;
0898 
0899                 time_dfs_update = REG_PRE_CAC_EXPIRY_GRACE_MS;
0900                 radar_event = NL80211_RADAR_PRE_CAC_EXPIRED;
0901             }
0902 
0903             timeout = c->dfs_state_entered +
0904                   msecs_to_jiffies(time_dfs_update);
0905 
0906             if (time_after_eq(jiffies, timeout)) {
0907                 c->dfs_state = NL80211_DFS_USABLE;
0908                 c->dfs_state_entered = jiffies;
0909 
0910                 cfg80211_chandef_create(&chandef, c,
0911                             NL80211_CHAN_NO_HT);
0912 
0913                 nl80211_radar_notify(rdev, &chandef,
0914                              radar_event, NULL,
0915                              GFP_ATOMIC);
0916 
0917                 regulatory_propagate_dfs_state(wiphy, &chandef,
0918                                    c->dfs_state,
0919                                    radar_event);
0920                 continue;
0921             }
0922 
0923             if (!check_again)
0924                 next_time = timeout - jiffies;
0925             else
0926                 next_time = min(next_time, timeout - jiffies);
0927             check_again = true;
0928         }
0929     }
0930     rtnl_unlock();
0931 
0932     /* reschedule if there are other channels waiting to be cleared again */
0933     if (check_again)
0934         queue_delayed_work(cfg80211_wq, &rdev->dfs_update_channels_wk,
0935                    next_time);
0936 }
0937 
0938 
0939 void __cfg80211_radar_event(struct wiphy *wiphy,
0940                 struct cfg80211_chan_def *chandef,
0941                 bool offchan, gfp_t gfp)
0942 {
0943     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0944 
0945     trace_cfg80211_radar_event(wiphy, chandef, offchan);
0946 
0947     /* only set the chandef supplied channel to unavailable, in
0948      * case the radar is detected on only one of multiple channels
0949      * spanned by the chandef.
0950      */
0951     cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_UNAVAILABLE);
0952 
0953     if (offchan)
0954         queue_work(cfg80211_wq, &rdev->background_cac_abort_wk);
0955 
0956     cfg80211_sched_dfs_chan_update(rdev);
0957 
0958     nl80211_radar_notify(rdev, chandef, NL80211_RADAR_DETECTED, NULL, gfp);
0959 
0960     memcpy(&rdev->radar_chandef, chandef, sizeof(struct cfg80211_chan_def));
0961     queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
0962 }
0963 EXPORT_SYMBOL(__cfg80211_radar_event);
0964 
0965 void cfg80211_cac_event(struct net_device *netdev,
0966             const struct cfg80211_chan_def *chandef,
0967             enum nl80211_radar_event event, gfp_t gfp)
0968 {
0969     struct wireless_dev *wdev = netdev->ieee80211_ptr;
0970     struct wiphy *wiphy = wdev->wiphy;
0971     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
0972     unsigned long timeout;
0973 
0974     /* not yet supported */
0975     if (wdev->valid_links)
0976         return;
0977 
0978     trace_cfg80211_cac_event(netdev, event);
0979 
0980     if (WARN_ON(!wdev->cac_started && event != NL80211_RADAR_CAC_STARTED))
0981         return;
0982 
0983     switch (event) {
0984     case NL80211_RADAR_CAC_FINISHED:
0985         timeout = wdev->cac_start_time +
0986               msecs_to_jiffies(wdev->cac_time_ms);
0987         WARN_ON(!time_after_eq(jiffies, timeout));
0988         cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_AVAILABLE);
0989         memcpy(&rdev->cac_done_chandef, chandef,
0990                sizeof(struct cfg80211_chan_def));
0991         queue_work(cfg80211_wq, &rdev->propagate_cac_done_wk);
0992         cfg80211_sched_dfs_chan_update(rdev);
0993         fallthrough;
0994     case NL80211_RADAR_CAC_ABORTED:
0995         wdev->cac_started = false;
0996         break;
0997     case NL80211_RADAR_CAC_STARTED:
0998         wdev->cac_started = true;
0999         break;
1000     default:
1001         WARN_ON(1);
1002         return;
1003     }
1004 
1005     nl80211_radar_notify(rdev, chandef, event, netdev, gfp);
1006 }
1007 EXPORT_SYMBOL(cfg80211_cac_event);
1008 
1009 static void
1010 __cfg80211_background_cac_event(struct cfg80211_registered_device *rdev,
1011                 struct wireless_dev *wdev,
1012                 const struct cfg80211_chan_def *chandef,
1013                 enum nl80211_radar_event event)
1014 {
1015     struct wiphy *wiphy = &rdev->wiphy;
1016     struct net_device *netdev;
1017 
1018     lockdep_assert_wiphy(&rdev->wiphy);
1019 
1020     if (!cfg80211_chandef_valid(chandef))
1021         return;
1022 
1023     if (!rdev->background_radar_wdev)
1024         return;
1025 
1026     switch (event) {
1027     case NL80211_RADAR_CAC_FINISHED:
1028         cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_AVAILABLE);
1029         memcpy(&rdev->cac_done_chandef, chandef, sizeof(*chandef));
1030         queue_work(cfg80211_wq, &rdev->propagate_cac_done_wk);
1031         cfg80211_sched_dfs_chan_update(rdev);
1032         wdev = rdev->background_radar_wdev;
1033         break;
1034     case NL80211_RADAR_CAC_ABORTED:
1035         if (!cancel_delayed_work(&rdev->background_cac_done_wk))
1036             return;
1037         wdev = rdev->background_radar_wdev;
1038         break;
1039     case NL80211_RADAR_CAC_STARTED:
1040         break;
1041     default:
1042         return;
1043     }
1044 
1045     netdev = wdev ? wdev->netdev : NULL;
1046     nl80211_radar_notify(rdev, chandef, event, netdev, GFP_KERNEL);
1047 }
1048 
1049 static void
1050 cfg80211_background_cac_event(struct cfg80211_registered_device *rdev,
1051                   const struct cfg80211_chan_def *chandef,
1052                   enum nl80211_radar_event event)
1053 {
1054     wiphy_lock(&rdev->wiphy);
1055     __cfg80211_background_cac_event(rdev, rdev->background_radar_wdev,
1056                     chandef, event);
1057     wiphy_unlock(&rdev->wiphy);
1058 }
1059 
1060 void cfg80211_background_cac_done_wk(struct work_struct *work)
1061 {
1062     struct delayed_work *delayed_work = to_delayed_work(work);
1063     struct cfg80211_registered_device *rdev;
1064 
1065     rdev = container_of(delayed_work, struct cfg80211_registered_device,
1066                 background_cac_done_wk);
1067     cfg80211_background_cac_event(rdev, &rdev->background_radar_chandef,
1068                       NL80211_RADAR_CAC_FINISHED);
1069 }
1070 
1071 void cfg80211_background_cac_abort_wk(struct work_struct *work)
1072 {
1073     struct cfg80211_registered_device *rdev;
1074 
1075     rdev = container_of(work, struct cfg80211_registered_device,
1076                 background_cac_abort_wk);
1077     cfg80211_background_cac_event(rdev, &rdev->background_radar_chandef,
1078                       NL80211_RADAR_CAC_ABORTED);
1079 }
1080 
1081 void cfg80211_background_cac_abort(struct wiphy *wiphy)
1082 {
1083     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1084 
1085     queue_work(cfg80211_wq, &rdev->background_cac_abort_wk);
1086 }
1087 EXPORT_SYMBOL(cfg80211_background_cac_abort);
1088 
1089 int
1090 cfg80211_start_background_radar_detection(struct cfg80211_registered_device *rdev,
1091                       struct wireless_dev *wdev,
1092                       struct cfg80211_chan_def *chandef)
1093 {
1094     unsigned int cac_time_ms;
1095     int err;
1096 
1097     lockdep_assert_wiphy(&rdev->wiphy);
1098 
1099     if (!wiphy_ext_feature_isset(&rdev->wiphy,
1100                      NL80211_EXT_FEATURE_RADAR_BACKGROUND))
1101         return -EOPNOTSUPP;
1102 
1103     /* Offchannel chain already locked by another wdev */
1104     if (rdev->background_radar_wdev && rdev->background_radar_wdev != wdev)
1105         return -EBUSY;
1106 
1107     /* CAC already in progress on the offchannel chain */
1108     if (rdev->background_radar_wdev == wdev &&
1109         delayed_work_pending(&rdev->background_cac_done_wk))
1110         return -EBUSY;
1111 
1112     err = rdev_set_radar_background(rdev, chandef);
1113     if (err)
1114         return err;
1115 
1116     cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, chandef);
1117     if (!cac_time_ms)
1118         cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1119 
1120     rdev->background_radar_chandef = *chandef;
1121     rdev->background_radar_wdev = wdev; /* Get offchain ownership */
1122 
1123     __cfg80211_background_cac_event(rdev, wdev, chandef,
1124                     NL80211_RADAR_CAC_STARTED);
1125     queue_delayed_work(cfg80211_wq, &rdev->background_cac_done_wk,
1126                msecs_to_jiffies(cac_time_ms));
1127 
1128     return 0;
1129 }
1130 
1131 void cfg80211_stop_background_radar_detection(struct wireless_dev *wdev)
1132 {
1133     struct wiphy *wiphy = wdev->wiphy;
1134     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1135 
1136     lockdep_assert_wiphy(wiphy);
1137 
1138     if (wdev != rdev->background_radar_wdev)
1139         return;
1140 
1141     rdev_set_radar_background(rdev, NULL);
1142     rdev->background_radar_wdev = NULL; /* Release offchain ownership */
1143 
1144     __cfg80211_background_cac_event(rdev, wdev,
1145                     &rdev->background_radar_chandef,
1146                     NL80211_RADAR_CAC_ABORTED);
1147 }
[ 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!