SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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
  30         if (wdev->wext.keys) {
  31                 wdev->wext.keys->def = wdev->wext.default_key;
  32                 wdev->wext.keys->defmgmt = wdev->wext.default_mgmt_key;
  33                 wdev->wext.connect.privacy = true;
  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         }
 233         wdev_unlock(wdev);
 234
 235         return 0;
 236 }
 237
 238 int cfg80211_mgd_wext_siwap(struct net_device *dev,
 239                             struct iw_request_info *info,
 240                             struct sockaddr *ap_addr, char *extra)
 241 {
 242         struct wireless_dev *wdev = dev->ieee80211_ptr;
 243         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
 244         u8 *bssid = ap_addr->sa_data;
 245         int err;
 246
 247         /* call only for station! */
 248         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 249                 return -EINVAL;
 250
 251         if (ap_addr->sa_family != ARPHRD_ETHER)
 252                 return -EINVAL;
 253
 254         /* automatic mode */
 255         if (is_zero_ether_addr(bssid) || is_broadcast_ether_addr(bssid))
 256                 bssid = NULL;
 257
 258         cfg80211_lock_rdev(rdev);
 259         mutex_lock(&rdev->devlist_mtx);
 260         wdev_lock(wdev);
 261
 262         if (wdev->sme_state != CFG80211_SME_IDLE) {
 263                 err = 0;
 264                 /* both automatic */
 265                 if (!bssid && !wdev->wext.connect.bssid)
 266                         goto out;
 267
 268                 /* fixed already - and no change */
 269                 if (wdev->wext.connect.bssid && bssid &&
 270                     compare_ether_addr(bssid, wdev->wext.connect.bssid) == 0)
 271                         goto out;
 272
 273                 err = __cfg80211_disconnect(rdev, dev,
 274                                             WLAN_REASON_DEAUTH_LEAVING, false);
 275                 if (err)
 276                         goto out;
 277         }
 278
 279         if (bssid) {
 280                 memcpy(wdev->wext.bssid, bssid, ETH_ALEN);
 281                 wdev->wext.connect.bssid = wdev->wext.bssid;
 282         } else
 283                 wdev->wext.connect.bssid = NULL;
 284
 285         err = cfg80211_mgd_wext_connect(rdev, wdev);
 286  out:
 287         wdev_unlock(wdev);
 288         mutex_unlock(&rdev->devlist_mtx);
 289         cfg80211_unlock_rdev(rdev);
 290         return err;
 291 }
 292
 293 int cfg80211_mgd_wext_giwap(struct net_device *dev,
 294                             struct iw_request_info *info,
 295                             struct sockaddr *ap_addr, char *extra)
 296 {
 297         struct wireless_dev *wdev = dev->ieee80211_ptr;
 298
 299         /* call only for station! */
 300         if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))
 301                 return -EINVAL;
 302
 303         ap_addr->sa_family = ARPHRD_ETHER;
 304
 305         wdev_lock(wdev);
 306         if (wdev->current_bss)
 307                 memcpy(ap_addr->sa_data, wdev->current_bss->pub.bssid, ETH_ALEN);
 308         else
 309                 memset(ap_addr->sa_data, 0, ETH_ALEN);
 310         wdev_unlock(wdev);
 311
 312         return 0;
 313 }
 314
 315 int cfg80211_wext_siwgenie(struct net_device *dev,
 316                            struct iw_request_info *info,
 317                            struct iw_point *data, char *extra)
 318 {
 319         struct wireless_dev *wdev = dev->ieee80211_ptr;
 320         struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
 321         u8 *ie = extra;
 322         int ie_len = data->length, err;
 323
 324         if (wdev->iftype != NL80211_IFTYPE_STATION)
 325                 return -EOPNOTSUPP;
 326
 327         if (!ie_len)
 328                 ie = NULL;
 329
 330         wdev_lock(wdev);
 331
 332         /* no change */
 333         err = 0;
 334         if (wdev->wext.ie_len == ie_len &&
 335             memcmp(wdev->wext.ie, ie, ie_len) == 0)
 336                 goto out;
 337
 338         if (ie_len) {
 339                 ie = kmemdup(extra, ie_len, GFP_KERNEL);
 340                 if (!ie) {
 341                         err = -ENOMEM;
 342                         goto out;
 343                 }
 344         } else
 345                 ie = NULL;
 346
 347         kfree(wdev->wext.ie);
 348         wdev->wext.ie = ie;
 349         wdev->wext.ie_len = ie_len;
 350
 351         if (wdev->sme_state != CFG80211_SME_IDLE) {
 352                 err = __cfg80211_disconnect(rdev, dev,
 353                                             WLAN_REASON_DEAUTH_LEAVING, false);
 354                 if (err)
 355                         goto out;
 356         }
 357
 358         /* userspace better not think we'll reconnect */
 359         err = 0;
 360  out:
 361         wdev_unlock(wdev);
 362         return err;
 363 }
 364 EXPORT_SYMBOL_GPL(cfg80211_wext_siwgenie);
 365
 366 int cfg80211_wext_siwmlme(struct net_device *dev,
 367                           struct iw_request_info *info,
 368                           struct iw_point *data, char *extra)
 369 {
 370         struct wireless_dev *wdev = dev->ieee80211_ptr;
 371         struct iw_mlme *mlme = (struct iw_mlme *)extra;
 372         struct cfg80211_registered_device *rdev;
 373         int err;
 374
 375         if (!wdev)
 376                 return -EOPNOTSUPP;
 377
 378         rdev = wiphy_to_dev(wdev->wiphy);
 379
 380         if (wdev->iftype != NL80211_IFTYPE_STATION)
 381                 return -EINVAL;
 382
 383         if (mlme->addr.sa_family != ARPHRD_ETHER)
 384                 return -EINVAL;
 385
 386         wdev_lock(wdev);
 387         switch (mlme->cmd) {
 388         case IW_MLME_DEAUTH:
 389         case IW_MLME_DISASSOC:
 390                 err = __cfg80211_disconnect(rdev, dev, mlme->reason_code,
 391                                             true);
 392                 break;
 393         default:
 394                 err = -EOPNOTSUPP;
 395                 break;
 396         }
 397         wdev_unlock(wdev);
 398
 399         return err;
 400 }
 401 EXPORT_SYMBOL_GPL(cfg80211_wext_siwmlme);