net/wireless/wext-sme.c

   1 /*
   2  * cfg80211 wext compat for managed mode.
   3  *
   4  * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
   5  * Copyright (C) 2009   Intel Corporation. All rights reserved.
   6  */
   7
   8 #include <linux/etherdevice.h>
   9 #include <linux/if_arp.h>
  10 #include <net/cfg80211.h>
  11 #include "wext-compat.h"
  12 #include "nl80211.h"
  13
  14 int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
  15                               struct wireless_dev *wdev)
  16 {
  17         struct cfg80211_cached_keys *ck = NULL;
  18         const u8 *prev_bssid = NULL;
  19         int err, i;
  20
  21         ASSERT_RDEV_LOCK(rdev);
  22         ASSERT_WDEV_LOCK(wdev);
  23
  24         if (!netif_running(wdev->netdev))
  25                 return 0;
  26
  27         wdev->wext.connect.ie = wdev->wext.ie;
  28         wdev->wext.connect.ie_len = wdev->wext.ie_len;
  29         wdev->wext.connect.privacy = wdev->wext.default_key != -1;
  30
  31         if (wdev->wext.keys) {
  32                 wdev->wext.keys->def = wdev->wext.default_key;
  33                 wdev->wext.keys->defmgmt = wdev->wext.default_mgmt_key;
  34         }
  35
  36         if (!wdev->wext.connect.ssid_len)
  37                 return 0;
  38
  39         if (wdev->wext.keys) {
  40                 ck = kmemdup(wdev->wext.keys, sizeof(*ck), GFP_KERNEL);
  41                 if (!ck)
  42                         return -ENOMEM;
  43                 for (i = 0; i < 6; i++)
  44                         ck->params[i].key = ck->data[i];
  45         }
  46
  47         if (wdev->wext.prev_bssid_valid)
  48                 prev_bssid = wdev->wext.prev_bssid;
  49
  50         err = __cfg80211_connect(rdev, wdev->netdev,
  51                                  &wdev->wext.connect, ck, prev_bssid);
  52         if (err)
  53                 kfree(ck);
  54
  55         return err;
  56 }
  57
  58 int cfg80211_mgd_wext_siwfreq(struct net_device *dev,
  59                               struct iw_request_info *info,
  60                               struct iw_freq *wextfreq, char *extra)
  61 {
  62         struct wireless_dev *wdev = dev->ieee80211_ptr;
  63         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
  64         struct ieee80211_channel *chan = NULL;
  65         int err, freq;
  66
  67         /* call only for station! */
  68         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
  69                 return -EINVAL;
  70
  71         freq = cfg80211_wext_freq(wdev->wiphy, wextfreq);
  72         if (freq < 0)
  73                 return freq;
  74
  75         if (freq) {
  76                 chan = ieee80211_get_channel(wdev->wiphy, freq);
  77                 if (!chan)
  78                         return -EINVAL;
  79                 if (chan->flags & IEEE80211_CHAN_DISABLED)
  80                         return -EINVAL;
  81         }
  82
  83         cfg80211_lock_rdev(rdev);
  84         mutex_lock(&rdev->devlist_mtx);
  85         wdev_lock(wdev);
  86
  87         if (wdev->sme_state != CFG80211_SME_IDLE) {
  88                 bool event = true;
  89
  90                 if (wdev->wext.connect.channel == chan) {
  91                         err = 0;
  92                         goto out;
  93                 }
  94
  95                 /* if SSID set, we'll try right again, avoid event */
  96                 if (wdev->wext.connect.ssid_len)
  97                         event = false;
  98                 err = __cfg80211_disconnect(rdev, dev,
  99                                             WLAN_REASON_DEAUTH_LEAVING, event);
 100                 if (err)
 101                         goto out;
 102         }
 103
 104
 105         wdev->wext.connect.channel = chan;
 106
 107         /* SSID is not set, we just want to switch channel */
 108         if (chan && !wdev->wext.connect.ssid_len) {
 109                 err = rdev_set_freq(rdev, wdev, freq, NL80211_CHAN_NO_HT);
 110                 goto out;
 111         }
 112
 113         err = cfg80211_mgd_wext_connect(rdev, wdev);
 114  out:
 115         wdev_unlock(wdev);
 116         mutex_unlock(&rdev->devlist_mtx);
 117         cfg80211_unlock_rdev(rdev);
 118         return err;
 119 }
 120
 121 int cfg80211_mgd_wext_giwfreq(struct net_device *dev,
 122                               struct iw_request_info *info,
 123                               struct iw_freq *freq, char *extra)
 124 {
 125         struct wireless_dev *wdev = dev->ieee80211_ptr;
 126         struct ieee80211_channel *chan = NULL;
 127
 128         /* call only for station! */
 129         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 130                 return -EINVAL;
 131
 132         wdev_lock(wdev);
 133         if (wdev->current_bss)
 134                 chan = wdev->current_bss->pub.channel;
 135         else if (wdev->wext.connect.channel)
 136                 chan = wdev->wext.connect.channel;
 137         wdev_unlock(wdev);
 138
 139         if (chan) {
 140                 freq->m = chan->center_freq;
 141                 freq->e = 6;
 142                 return 0;
 143         }
 144
 145         /* no channel if not joining */
 146         return -EINVAL;
 147 }
 148
 149 int cfg80211_mgd_wext_siwessid(struct net_device *dev,
 150                                struct iw_request_info *info,
 151                                struct iw_point *data, char *ssid)
 152 {
 153         struct wireless_dev *wdev = dev->ieee80211_ptr;
 154         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
 155         size_t len = data->length;
 156         int err;
 157
 158         /* call only for station! */
 159         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 160                 return -EINVAL;
 161
 162         if (!data->flags)
 163                 len = 0;
 164
 165         /* iwconfig uses nul termination in SSID.. */
 166         if (len > 0 && ssid[len - 1] == '\0')
 167                 len--;
 168
 169         cfg80211_lock_rdev(rdev);
 170         mutex_lock(&rdev->devlist_mtx);
 171         wdev_lock(wdev);
 172
 173         err = 0;
 174
 175         if (wdev->sme_state != CFG80211_SME_IDLE) {
 176                 bool event = true;
 177
 178                 if (wdev->wext.connect.ssid && len &&
 179                     len == wdev->wext.connect.ssid_len &&
 180                     memcmp(wdev->wext.connect.ssid, ssid, len) == 0)
 181                         goto out;
 182
 183                 /* if SSID set now, we'll try to connect, avoid event */
 184                 if (len)
 185                         event = false;
 186                 err = __cfg80211_disconnect(rdev, dev,
 187                                             WLAN_REASON_DEAUTH_LEAVING, event);
 188                 if (err)
 189                         goto out;
 190         }
 191
 192         wdev->wext.prev_bssid_valid = false;
 193         wdev->wext.connect.ssid = wdev->wext.ssid;
 194         memcpy(wdev->wext.ssid, ssid, len);
 195         wdev->wext.connect.ssid_len = len;
 196
 197         wdev->wext.connect.crypto.control_port = false;
 198
 199         err = cfg80211_mgd_wext_connect(rdev, wdev);
 200  out:
 201         wdev_unlock(wdev);
 202         mutex_unlock(&rdev->devlist_mtx);
 203         cfg80211_unlock_rdev(rdev);
 204         return err;
 205 }
 206
 207 int cfg80211_mgd_wext_giwessid(struct net_device *dev,
 208                                struct iw_request_info *info,
 209                                struct iw_point *data, char *ssid)
 210 {
 211         struct wireless_dev *wdev = dev->ieee80211_ptr;
 212
 213         /* call only for station! */
 214         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 215                 return -EINVAL;
 216
 217         data->flags = 0;
 218
 219         wdev_lock(wdev);
 220         if (wdev->current_bss) {
 221                 const u8 *ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
 222                                                     WLAN_EID_SSID);
 223                 if (ie) {
 224                         data->flags = 1;
 225                         data->length = ie[1];
 226                         memcpy(ssid, ie + 2, data->length);
 227                 }
 228         } else if (wdev->wext.connect.ssid && wdev->wext.connect.ssid_len) {
 229                 data->flags = 1;
 230                 data->length = wdev->wext.connect.ssid_len;
 231                 memcpy(ssid, wdev->wext.connect.ssid, data->length);
 232         } else
 233                 data->flags = 0;
 234         wdev_unlock(wdev);
 235
 236         return 0;
 237 }
 238
 239 int cfg80211_mgd_wext_siwap(struct net_device *dev,
 240                             struct iw_request_info *info,
 241                             struct sockaddr *ap_addr, char *extra)
 242 {
 243         struct wireless_dev *wdev = dev->ieee80211_ptr;
 244         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
 245         u8 *bssid = ap_addr->sa_data;
 246         int err;
 247
 248         /* call only for station! */
 249         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 250                 return -EINVAL;
 251
 252         if (ap_addr->sa_family != ARPHRD_ETHER)
 253                 return -EINVAL;
 254
 255         /* automatic mode */
 256         if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
 257                 bssid = NULL;
 258
 259         cfg80211_lock_rdev(rdev);
 260         mutex_lock(&rdev->devlist_mtx);
 261         wdev_lock(wdev);
 262
 263         if (wdev->sme_state != CFG80211_SME_IDLE) {
 264                 err = 0;
 265                 /* both automatic */
 266                 if (!bssid && !wdev->wext.connect.bssid)
 267                         goto out;
 268
 269                 /* fixed already - and no change */
 270                 if (wdev->wext.connect.bssid && bssid &&
 271                     compare_ether_addr(bssid, wdev->wext.connect.bssid) == 0)
 272                         goto out;
 273
 274                 err = __cfg80211_disconnect(rdev, dev,
 275                                             WLAN_REASON_DEAUTH_LEAVING, false);
 276                 if (err)
 277                         goto out;
 278         }
 279
 280         if (bssid) {
 281                 memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
 282                 wdev->wext.connect.bssid = wdev->wext.bssid;
 283         } else
 284                 wdev->wext.connect.bssid = NULL;
 285
 286         err = cfg80211_mgd_wext_connect(rdev, wdev);
 287  out:
 288         wdev_unlock(wdev);
 289         mutex_unlock(&rdev->devlist_mtx);
 290         cfg80211_unlock_rdev(rdev);
 291         return err;
 292 }
 293
 294 int cfg80211_mgd_wext_giwap(struct net_device *dev,
 295                             struct iw_request_info *info,
 296                             struct sockaddr *ap_addr, char *extra)
 297 {
 298         struct wireless_dev *wdev = dev->ieee80211_ptr;
 299
 300         /* call only for station! */
 301         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 302                 return -EINVAL;
 303
 304         ap_addr->sa_family = ARPHRD_ETHER;
 305
 306         wdev_lock(wdev);
 307         if (wdev->current_bss)
 308                 memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN);
 309         else if (wdev->wext.connect.bssid)
 310                 memcpy(ap_addr->sa_data, wdev->wext.connect.bssid, ETH_ALEN);
 311         else
 312                 memset(ap_addr->sa_data, 0, ETH_ALEN);
 313         wdev_unlock(wdev);
 314
 315         return 0;
 316 }
 317
 318 int cfg80211_wext_siwgenie(struct net_device *dev,
 319                            struct iw_request_info *info,
 320                            struct iw_point *data, char *extra)
 321 {
 322         struct wireless_dev *wdev = dev->ieee80211_ptr;
 323         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
 324         u8 *ie = extra;
 325         int ie_len = data->length, err;
 326
 327         if (wdev->iftype != NL80211_IFTYPE_STATION)
 328                 return -EOPNOTSUPP;
 329
 330         if (!ie_len)
 331                 ie = NULL;
 332
 333         wdev_lock(wdev);
 334
 335         /* no change */
 336         err = 0;
 337         if (wdev->wext.ie_len == ie_len &&
 338             memcmp(wdev->wext.ie, ie, ie_len) == 0)
 339                 goto out;
 340
 341         if (ie_len) {
 342                 ie = kmemdup(extra, ie_len, GFP_KERNEL);
 343                 if (!ie) {
 344                         err = -ENOMEM;
 345                         goto out;
 346                 }
 347         } else
 348                 ie = NULL;
 349
 350         kfree(wdev->wext.ie);
 351         wdev->wext.ie = ie;
 352         wdev->wext.ie_len = ie_len;
 353
 354         if (wdev->sme_state != CFG80211_SME_IDLE) {
 355                 err = __cfg80211_disconnect(rdev, dev,
 356                                             WLAN_REASON_DEAUTH_LEAVING, false);
 357                 if (err)
 358                         goto out;
 359         }
 360
 361         /* userspace better not think we'll reconnect */
 362         err = 0;
 363  out:
 364         wdev_unlock(wdev);
 365         return err;
 366 }
 367 EXPORT_SYMBOL_GPL(cfg80211_wext_siwgenie);
 368
 369 int cfg80211_wext_siwmlme(struct net_device *dev,
 370                           struct iw_request_info *info,
 371                           struct iw_point *data, char *extra)
 372 {
 373         struct wireless_dev *wdev = dev->ieee80211_ptr;
 374         struct iw_mlme *mlme = (struct iw_mlme *)extra;
 375         struct cfg80211_registered_device *rdev;
 376         int err;
 377
 378         if (!wdev)
 379                 return -EOPNOTSUPP;
 380
 381         rdev = wiphy_to_dev(wdev->wiphy);
 382
 383         if (wdev->iftype != NL80211_IFTYPE_STATION)
 384                 return -EINVAL;
 385
 386         if (mlme->addr.sa_family != ARPHRD_ETHER)
 387                 return -EINVAL;
 388
 389         wdev_lock(wdev);
 390         switch (mlme->cmd) {
 391         case IW_MLME_DEAUTH:
 392         case IW_MLME_DISASSOC:
 393                 err = __cfg80211_disconnect(rdev, dev, mlme->reason_code,
 394                                             true);
 395                 break;
 396         default:
 397                 err = -EOPNOTSUPP;
 398                 break;
 399         }
 400         wdev_unlock(wdev);
 401
 402         return err;
 403 }
 404 EXPORT_SYMBOL_GPL(cfg80211_wext_siwmlme);