Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * cfg80211 wext compat for managed mode.
0004  *
0005  * Copyright 2009   Johannes Berg <johannes@sipsolutions.net>
0006  * Copyright (C) 2009, 2020-2022 Intel Corporation
0007  */
0008 
0009 #include <linux/export.h>
0010 #include <linux/etherdevice.h>
0011 #include <linux/if_arp.h>
0012 #include <linux/slab.h>
0013 #include <net/cfg80211.h>
0014 #include <net/cfg80211-wext.h>
0015 #include "wext-compat.h"
0016 #include "nl80211.h"
0017 
0018 int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
0019                   struct wireless_dev *wdev)
0020 {
0021     struct cfg80211_cached_keys *ck = NULL;
0022     const u8 *prev_bssid = NULL;
0023     int err, i;
0024 
0025     ASSERT_RTNL();
0026     ASSERT_WDEV_LOCK(wdev);
0027 
0028     if (!netif_running(wdev->netdev))
0029         return 0;
0030 
0031     wdev->wext.connect.ie = wdev->wext.ie;
0032     wdev->wext.connect.ie_len = wdev->wext.ie_len;
0033 
0034     /* Use default background scan period */
0035     wdev->wext.connect.bg_scan_period = -1;
0036 
0037     if (wdev->wext.keys) {
0038         wdev->wext.keys->def = wdev->wext.default_key;
0039         if (wdev->wext.default_key != -1)
0040             wdev->wext.connect.privacy = true;
0041     }
0042 
0043     if (!wdev->wext.connect.ssid_len)
0044         return 0;
0045 
0046     if (wdev->wext.keys && wdev->wext.keys->def != -1) {
0047         ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);
0048         if (!ck)
0049             return -ENOMEM;
0050         for (i = 0; i < CFG80211_MAX_WEP_KEYS; i++)
0051             ck->params[i].key = ck->data[i];
0052     }
0053 
0054     if (wdev->wext.prev_bssid_valid)
0055         prev_bssid = wdev->wext.prev_bssid;
0056 
0057     err = cfg80211_connect(rdev, wdev->netdev,
0058                    &wdev->wext.connect, ck, prev_bssid);
0059     if (err)
0060         kfree_sensitive(ck);
0061 
0062     return err;
0063 }
0064 
0065 int cfg80211_mgd_wext_siwfreq(struct net_device *dev,
0066                   struct iw_request_info *info,
0067                   struct iw_freq *wextfreq, char *extra)
0068 {
0069     struct wireless_dev *wdev = dev->ieee80211_ptr;
0070     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0071     struct ieee80211_channel *chan = NULL;
0072     int err, freq;
0073 
0074     /* call only for station! */
0075     if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
0076         return -EINVAL;
0077 
0078     freq = cfg80211_wext_freq(wextfreq);
0079     if (freq < 0)
0080         return freq;
0081 
0082     if (freq) {
0083         chan = ieee80211_get_channel(wdev->wiphy, freq);
0084         if (!chan)
0085             return -EINVAL;
0086         if (chan->flags & IEEE80211_CHAN_DISABLED)
0087             return -EINVAL;
0088     }
0089 
0090     wdev_lock(wdev);
0091 
0092     if (wdev->conn) {
0093         bool event = true;
0094 
0095         if (wdev->wext.connect.channel == chan) {
0096             err = 0;
0097             goto out;
0098         }
0099 
0100         /* if SSID set, we'll try right again, avoid event */
0101         if (wdev->wext.connect.ssid_len)
0102             event = false;
0103         err = cfg80211_disconnect(rdev, dev,
0104                       WLAN_REASON_DEAUTH_LEAVING, event);
0105         if (err)
0106             goto out;
0107     }
0108 
0109     wdev->wext.connect.channel = chan;
0110     err = cfg80211_mgd_wext_connect(rdev, wdev);
0111  out:
0112     wdev_unlock(wdev);
0113     return err;
0114 }
0115 
0116 int cfg80211_mgd_wext_giwfreq(struct net_device *dev,
0117                   struct iw_request_info *info,
0118                   struct iw_freq *freq, char *extra)
0119 {
0120     struct wireless_dev *wdev = dev->ieee80211_ptr;
0121     struct ieee80211_channel *chan = NULL;
0122 
0123     /* call only for station! */
0124     if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
0125         return -EINVAL;
0126 
0127     if (wdev->valid_links)
0128         return -EOPNOTSUPP;
0129 
0130     wdev_lock(wdev);
0131     if (wdev->links[0].client.current_bss)
0132         chan = wdev->links[0].client.current_bss->pub.channel;
0133     else if (wdev->wext.connect.channel)
0134         chan = wdev->wext.connect.channel;
0135     wdev_unlock(wdev);
0136 
0137     if (chan) {
0138         freq->m = chan->center_freq;
0139         freq->e = 6;
0140         return 0;
0141     }
0142 
0143     /* no channel if not joining */
0144     return -EINVAL;
0145 }
0146 
0147 int cfg80211_mgd_wext_siwessid(struct net_device *dev,
0148                    struct iw_request_info *info,
0149                    struct iw_point *data, char *ssid)
0150 {
0151     struct wireless_dev *wdev = dev->ieee80211_ptr;
0152     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0153     size_t len = data->length;
0154     int err;
0155 
0156     /* call only for station! */
0157     if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
0158         return -EINVAL;
0159 
0160     if (!data->flags)
0161         len = 0;
0162 
0163     /* iwconfig uses nul termination in SSID.. */
0164     if (len > 0 && ssid[len - 1] == '\0')
0165         len--;
0166 
0167     wdev_lock(wdev);
0168 
0169     err = 0;
0170 
0171     if (wdev->conn) {
0172         bool event = true;
0173 
0174         if (wdev->wext.connect.ssid && len &&
0175             len == wdev->wext.connect.ssid_len &&
0176             memcmp(wdev->wext.connect.ssid, ssid, len) == 0)
0177             goto out;
0178 
0179         /* if SSID set now, we'll try to connect, avoid event */
0180         if (len)
0181             event = false;
0182         err = cfg80211_disconnect(rdev, dev,
0183                       WLAN_REASON_DEAUTH_LEAVING, event);
0184         if (err)
0185             goto out;
0186     }
0187 
0188     wdev->wext.prev_bssid_valid = false;
0189     wdev->wext.connect.ssid = wdev->wext.ssid;
0190     memcpy(wdev->wext.ssid, ssid, len);
0191     wdev->wext.connect.ssid_len = len;
0192 
0193     wdev->wext.connect.crypto.control_port = false;
0194     wdev->wext.connect.crypto.control_port_ethertype =
0195                     cpu_to_be16(ETH_P_PAE);
0196 
0197     err = cfg80211_mgd_wext_connect(rdev, wdev);
0198  out:
0199     wdev_unlock(wdev);
0200     return err;
0201 }
0202 
0203 int cfg80211_mgd_wext_giwessid(struct net_device *dev,
0204                    struct iw_request_info *info,
0205                    struct iw_point *data, char *ssid)
0206 {
0207     struct wireless_dev *wdev = dev->ieee80211_ptr;
0208     int ret = 0;
0209 
0210     /* call only for station! */
0211     if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
0212         return -EINVAL;
0213 
0214     if (wdev->valid_links)
0215         return -EINVAL;
0216 
0217     data->flags = 0;
0218 
0219     wdev_lock(wdev);
0220     if (wdev->links[0].client.current_bss) {
0221         const struct element *ssid_elem;
0222 
0223         rcu_read_lock();
0224         ssid_elem = ieee80211_bss_get_elem(
0225                 &wdev->links[0].client.current_bss->pub,
0226                 WLAN_EID_SSID);
0227         if (ssid_elem) {
0228             data->flags = 1;
0229             data->length = ssid_elem->datalen;
0230             if (data->length > IW_ESSID_MAX_SIZE)
0231                 ret = -EINVAL;
0232             else
0233                 memcpy(ssid, ssid_elem->data, data->length);
0234         }
0235         rcu_read_unlock();
0236     } else if (wdev->wext.connect.ssid && wdev->wext.connect.ssid_len) {
0237         data->flags = 1;
0238         data->length = wdev->wext.connect.ssid_len;
0239         memcpy(ssid, wdev->wext.connect.ssid, data->length);
0240     }
0241     wdev_unlock(wdev);
0242 
0243     return ret;
0244 }
0245 
0246 int cfg80211_mgd_wext_siwap(struct net_device *dev,
0247                 struct iw_request_info *info,
0248                 struct sockaddr *ap_addr, char *extra)
0249 {
0250     struct wireless_dev *wdev = dev->ieee80211_ptr;
0251     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0252     u8 *bssid = ap_addr->sa_data;
0253     int err;
0254 
0255     /* call only for station! */
0256     if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
0257         return -EINVAL;
0258 
0259     if (ap_addr->sa_family != ARPHRD_ETHER)
0260         return -EINVAL;
0261 
0262     /* automatic mode */
0263     if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
0264         bssid = NULL;
0265 
0266     wdev_lock(wdev);
0267 
0268     if (wdev->conn) {
0269         err = 0;
0270         /* both automatic */
0271         if (!bssid && !wdev->wext.connect.bssid)
0272             goto out;
0273 
0274         /* fixed already - and no change */
0275         if (wdev->wext.connect.bssid && bssid &&
0276             ether_addr_equal(bssid, wdev->wext.connect.bssid))
0277             goto out;
0278 
0279         err = cfg80211_disconnect(rdev, dev,
0280                       WLAN_REASON_DEAUTH_LEAVING, false);
0281         if (err)
0282             goto out;
0283     }
0284 
0285     if (bssid) {
0286         memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
0287         wdev->wext.connect.bssid = wdev->wext.bssid;
0288     } else
0289         wdev->wext.connect.bssid = NULL;
0290 
0291     err = cfg80211_mgd_wext_connect(rdev, wdev);
0292  out:
0293     wdev_unlock(wdev);
0294     return err;
0295 }
0296 
0297 int cfg80211_mgd_wext_giwap(struct net_device *dev,
0298                 struct iw_request_info *info,
0299                 struct sockaddr *ap_addr, char *extra)
0300 {
0301     struct wireless_dev *wdev = dev->ieee80211_ptr;
0302 
0303     /* call only for station! */
0304     if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
0305         return -EINVAL;
0306 
0307     ap_addr->sa_family = ARPHRD_ETHER;
0308 
0309     wdev_lock(wdev);
0310     if (wdev->valid_links) {
0311         wdev_unlock(wdev);
0312         return -EOPNOTSUPP;
0313     }
0314     if (wdev->links[0].client.current_bss)
0315         memcpy(ap_addr->sa_data,
0316                wdev->links[0].client.current_bss->pub.bssid,
0317                ETH_ALEN);
0318     else
0319         eth_zero_addr(ap_addr->sa_data);
0320     wdev_unlock(wdev);
0321 
0322     return 0;
0323 }
0324 
0325 int cfg80211_wext_siwgenie(struct net_device *dev,
0326                struct iw_request_info *info,
0327                struct iw_point *data, char *extra)
0328 {
0329     struct wireless_dev *wdev = dev->ieee80211_ptr;
0330     struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
0331     u8 *ie = extra;
0332     int ie_len = data->length, err;
0333 
0334     if (wdev->iftype != NL80211_IFTYPE_STATION)
0335         return -EOPNOTSUPP;
0336 
0337     if (!ie_len)
0338         ie = NULL;
0339 
0340     wdev_lock(wdev);
0341 
0342     /* no change */
0343     err = 0;
0344     if (wdev->wext.ie_len == ie_len &&
0345         memcmp(wdev->wext.ie, ie, ie_len) == 0)
0346         goto out;
0347 
0348     if (ie_len) {
0349         ie = kmemdup(extra, ie_len, GFP_KERNEL);
0350         if (!ie) {
0351             err = -ENOMEM;
0352             goto out;
0353         }
0354     } else
0355         ie = NULL;
0356 
0357     kfree(wdev->wext.ie);
0358     wdev->wext.ie = ie;
0359     wdev->wext.ie_len = ie_len;
0360 
0361     if (wdev->conn) {
0362         err = cfg80211_disconnect(rdev, dev,
0363                       WLAN_REASON_DEAUTH_LEAVING, false);
0364         if (err)
0365             goto out;
0366     }
0367 
0368     /* userspace better not think we'll reconnect */
0369     err = 0;
0370  out:
0371     wdev_unlock(wdev);
0372     return err;
0373 }
0374 
0375 int cfg80211_wext_siwmlme(struct net_device *dev,
0376               struct iw_request_info *info,
0377               struct iw_point *data, char *extra)
0378 {
0379     struct wireless_dev *wdev = dev->ieee80211_ptr;
0380     struct iw_mlme *mlme = (struct iw_mlme *)extra;
0381     struct cfg80211_registered_device *rdev;
0382     int err;
0383 
0384     if (!wdev)
0385         return -EOPNOTSUPP;
0386 
0387     rdev = wiphy_to_rdev(wdev->wiphy);
0388 
0389     if (wdev->iftype != NL80211_IFTYPE_STATION)
0390         return -EINVAL;
0391 
0392     if (mlme->addr.sa_family != ARPHRD_ETHER)
0393         return -EINVAL;
0394 
0395     wiphy_lock(&rdev->wiphy);
0396     wdev_lock(wdev);
0397     switch (mlme->cmd) {
0398     case IW_MLME_DEAUTH:
0399     case IW_MLME_DISASSOC:
0400         err = cfg80211_disconnect(rdev, dev, mlme->reason_code, true);
0401         break;
0402     default:
0403         err = -EOPNOTSUPP;
0404         break;
0405     }
0406     wdev_unlock(wdev);
0407     wiphy_unlock(&rdev->wiphy);
0408 
0409     return err;
0410 }
[ 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!