SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/wireless/mlme.c

   1 /*
   2  * cfg80211 MLME SAP interface
   3  *
   4  * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
   5  */
   6
   7 #include <linux/kernel.h>
   8 #include <linux/module.h>
   9 #include <linux/netdevice.h>
  10 #include <linux/nl80211.h>
  11 #include <linux/wireless.h>
  12 #include <net/cfg80211.h>
  13 #include <net/iw_handler.h>
  14 #include "core.h"
  15 #include "nl80211.h"
  16
  17 void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len)
  18 {
  19         struct wireless_dev *wdev = dev->ieee80211_ptr;
  20         struct wiphy *wiphy = wdev->wiphy;
  21         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
  22         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
  23         u8 *bssid = mgmt->bssid;
  24         int i;
  25         u16 status = le16_to_cpu(mgmt->u.auth.status_code);
  26         bool done = false;
  27
  28         wdev_lock(wdev);
  29
  30         for (i = 0; i < MAX_AUTH_BSSES; i++) {
  31                 if (wdev->authtry_bsses[i] &&
  32                     memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid,
  33                                                         ETH_ALEN) == 0) {
  34                         if (status == WLAN_STATUS_SUCCESS) {
  35                                 wdev->auth_bsses[i] = wdev->authtry_bsses[i];
  36                         } else {
  37                                 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
  38                                 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
  39                         }
  40                         wdev->authtry_bsses[i] = NULL;
  41                         done = true;
  42                         break;
  43                 }
  44         }
  45
  46         WARN_ON(!done);
  47
  48         nl80211_send_rx_auth(rdev, dev, buf, len, GFP_KERNEL);
  49         cfg80211_sme_rx_auth(dev, buf, len);
  50
  51         wdev_unlock(wdev);
  52 }
  53 EXPORT_SYMBOL(cfg80211_send_rx_auth);
  54
  55 void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len)
  56 {
  57         u16 status_code;
  58         struct wireless_dev *wdev = dev->ieee80211_ptr;
  59         struct wiphy *wiphy = wdev->wiphy;
  60         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
  61         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
  62         u8 *ie = mgmt->u.assoc_resp.variable;
  63         int i, ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);
  64         struct cfg80211_internal_bss *bss = NULL;
  65
  66         wdev_lock(wdev);
  67
  68         status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
  69
  70         /*
  71          * This is a bit of a hack, we don't notify userspace of
  72          * a (re-)association reply if we tried to send a reassoc
  73          * and got a reject -- we only try again with an assoc
  74          * frame instead of reassoc.
  75          */
  76         if (status_code != WLAN_STATUS_SUCCESS && wdev->conn &&
  77             cfg80211_sme_failed_reassoc(wdev))
  78                 goto out;
  79
  80         nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL);
  81
  82         if (status_code == WLAN_STATUS_SUCCESS) {
  83                 for (i = 0; i < MAX_AUTH_BSSES; i++) {
  84                         if (!wdev->auth_bsses[i])
  85                                 continue;
  86                         if (memcmp(wdev->auth_bsses[i]->pub.bssid, mgmt->bssid,
  87                                    ETH_ALEN) == 0) {
  88                                 bss = wdev->auth_bsses[i];
  89                                 wdev->auth_bsses[i] = NULL;
  90                                 /* additional reference to drop hold */
  91                                 cfg80211_ref_bss(bss);
  92                                 break;
  93                         }
  94                 }
  95
  96                 WARN_ON(!bss);
  97         } else if (wdev->conn) {
  98                 cfg80211_sme_failed_assoc(wdev);
  99                 /*
 100                  * do not call connect_result() now because the
 101                  * sme will schedule work that does it later.
 102                  */
 103                 goto out;
 104         }
 105
 106         if (!wdev->conn && wdev->sme_state == CFG80211_SME_IDLE) {
 107                 /*
 108                  * This is for the userspace SME, the CONNECTING
 109                  * state will be changed to CONNECTED by
 110                  * __cfg80211_connect_result() below.
 111                  */
 112                 wdev->sme_state = CFG80211_SME_CONNECTING;
 113         }
 114
 115         /* this consumes one bss reference (unless bss is NULL) */
 116         __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,
 117                                   status_code,
 118                                   status_code == WLAN_STATUS_SUCCESS,
 119                                   bss ? &bss->pub : NULL);
 120         /* drop hold now, and also reference acquired above */
 121         if (bss) {
 122                 cfg80211_unhold_bss(bss);
 123                 cfg80211_put_bss(&bss->pub);
 124         }
 125
 126  out:
 127         wdev_unlock(wdev);
 128 }
 129 EXPORT_SYMBOL(cfg80211_send_rx_assoc);
 130
 131 void __cfg80211_send_deauth(struct net_device *dev,
 132                                    const u8 *buf, size_t len)
 133 {
 134         struct wireless_dev *wdev = dev->ieee80211_ptr;
 135         struct wiphy *wiphy = wdev->wiphy;
 136         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 137         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
 138         const u8 *bssid = mgmt->bssid;
 139         int i;
 140
 141         ASSERT_WDEV_LOCK(wdev);
 142
 143         nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);
 144
 145         if (wdev->current_bss &&
 146             memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
 147                 cfg80211_unhold_bss(wdev->current_bss);
 148                 cfg80211_put_bss(&wdev->current_bss->pub);
 149                 wdev->current_bss = NULL;
 150         } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
 151                 if (wdev->auth_bsses[i] &&
 152                     memcmp(wdev->auth_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
 153                         cfg80211_unhold_bss(wdev->auth_bsses[i]);
 154                         cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
 155                         wdev->auth_bsses[i] = NULL;
 156                         break;
 157                 }
 158                 if (wdev->authtry_bsses[i] &&
 159                     memcmp(wdev->authtry_bsses[i]->pub.bssid, bssid, ETH_ALEN) == 0) {
 160                         cfg80211_unhold_bss(wdev->authtry_bsses[i]);
 161                         cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
 162                         wdev->authtry_bsses[i] = NULL;
 163                         break;
 164                 }
 165         }
 166
 167         if (wdev->sme_state == CFG80211_SME_CONNECTED) {
 168                 u16 reason_code;
 169                 bool from_ap;
 170
 171                 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 172
 173                 from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
 174                 __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
 175         } else if (wdev->sme_state == CFG80211_SME_CONNECTING) {
 176                 __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,
 177                                           WLAN_STATUS_UNSPECIFIED_FAILURE,
 178                                           false, NULL);
 179         }
 180 }
 181 EXPORT_SYMBOL(__cfg80211_send_deauth);
 182
 183 void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len)
 184 {
 185         struct wireless_dev *wdev = dev->ieee80211_ptr;
 186
 187         wdev_lock(wdev);
 188         __cfg80211_send_deauth(dev, buf, len);
 189         wdev_unlock(wdev);
 190 }
 191 EXPORT_SYMBOL(cfg80211_send_deauth);
 192
 193 void __cfg80211_send_disassoc(struct net_device *dev,
 194                                      const u8 *buf, size_t len)
 195 {
 196         struct wireless_dev *wdev = dev->ieee80211_ptr;
 197         struct wiphy *wiphy = wdev->wiphy;
 198         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 199         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
 200         const u8 *bssid = mgmt->bssid;
 201         int i;
 202         u16 reason_code;
 203         bool from_ap;
 204         bool done = false;
 205
 206         ASSERT_WDEV_LOCK(wdev);
 207
 208         nl80211_send_disassoc(rdev, dev, buf, len, GFP_KERNEL);
 209
 210         if (wdev->sme_state != CFG80211_SME_CONNECTED)
 211                 return;
 212
 213         if (wdev->current_bss &&
 214             memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
 215                 for (i = 0; i < MAX_AUTH_BSSES; i++) {
 216                         if (wdev->authtry_bsses[i] || wdev->auth_bsses[i])
 217                                 continue;
 218                         wdev->auth_bsses[i] = wdev->current_bss;
 219                         wdev->current_bss = NULL;
 220                         done = true;
 221                         cfg80211_sme_disassoc(dev, i);
 222                         break;
 223                 }
 224                 WARN_ON(!done);
 225         } else
 226                 WARN_ON(1);
 227
 228
 229         reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
 230
 231         from_ap = memcmp(mgmt->sa, dev->dev_addr, ETH_ALEN) != 0;
 232         __cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);
 233 }
 234 EXPORT_SYMBOL(__cfg80211_send_disassoc);
 235
 236 void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len)
 237 {
 238         struct wireless_dev *wdev = dev->ieee80211_ptr;
 239
 240         wdev_lock(wdev);
 241         __cfg80211_send_disassoc(dev, buf, len);
 242         wdev_unlock(wdev);
 243 }
 244 EXPORT_SYMBOL(cfg80211_send_disassoc);
 245
 246 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
 247 {
 248         struct wireless_dev *wdev = dev->ieee80211_ptr;
 249         struct wiphy *wiphy = wdev->wiphy;
 250         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 251         int i;
 252         bool done = false;
 253
 254         wdev_lock(wdev);
 255
 256         nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
 257         if (wdev->sme_state == CFG80211_SME_CONNECTING)
 258                 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
 259                                           WLAN_STATUS_UNSPECIFIED_FAILURE,
 260                                           false, NULL);
 261
 262         for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
 263                 if (wdev->authtry_bsses[i] &&
 264                     memcmp(wdev->authtry_bsses[i]->pub.bssid,
 265                            addr, ETH_ALEN) == 0) {
 266                         cfg80211_unhold_bss(wdev->authtry_bsses[i]);
 267                         cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
 268                         wdev->authtry_bsses[i] = NULL;
 269                         done = true;
 270                         break;
 271                 }
 272         }
 273
 274         WARN_ON(!done);
 275
 276         wdev_unlock(wdev);
 277 }
 278 EXPORT_SYMBOL(cfg80211_send_auth_timeout);
 279
 280 void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
 281 {
 282         struct wireless_dev *wdev = dev->ieee80211_ptr;
 283         struct wiphy *wiphy = wdev->wiphy;
 284         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 285         int i;
 286         bool done = false;
 287
 288         wdev_lock(wdev);
 289
 290         nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
 291         if (wdev->sme_state == CFG80211_SME_CONNECTING)
 292                 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
 293                                           WLAN_STATUS_UNSPECIFIED_FAILURE,
 294                                           false, NULL);
 295
 296         for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
 297                 if (wdev->auth_bsses[i] &&
 298                     memcmp(wdev->auth_bsses[i]->pub.bssid,
 299                            addr, ETH_ALEN) == 0) {
 300                         cfg80211_unhold_bss(wdev->auth_bsses[i]);
 301                         cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
 302                         wdev->auth_bsses[i] = NULL;
 303                         done = true;
 304                         break;
 305                 }
 306         }
 307
 308         WARN_ON(!done);
 309
 310         wdev_unlock(wdev);
 311 }
 312 EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
 313
 314 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
 315                                   enum nl80211_key_type key_type, int key_id,
 316                                   const u8 *tsc, gfp_t gfp)
 317 {
 318         struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
 319         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
 320 #ifdef CONFIG_CFG80211_WEXT
 321         union iwreq_data wrqu;
 322         char *buf = kmalloc(128, gfp);
 323
 324         if (buf) {
 325                 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
 326                         "keyid=%d %scast addr=%pM)", key_id,
 327                         key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
 328                         addr);
 329                 memset(&wrqu, 0, sizeof(wrqu));
 330                 wrqu.data.length = strlen(buf);
 331                 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
 332                 kfree(buf);
 333         }
 334 #endif
 335
 336         nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
 337 }
 338 EXPORT_SYMBOL(cfg80211_michael_mic_failure);
 339
 340 /* some MLME handling for userspace SME */
 341 int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
 342                          struct net_device *dev,
 343                          struct ieee80211_channel *chan,
 344                          enum nl80211_auth_type auth_type,
 345                          const u8 *bssid,
 346                          const u8 *ssid, int ssid_len,
 347                          const u8 *ie, int ie_len,
 348                          const u8 *key, int key_len, int key_idx)
 349 {
 350         struct wireless_dev *wdev = dev->ieee80211_ptr;
 351         struct cfg80211_auth_request req;
 352         struct cfg80211_internal_bss *bss;
 353         int i, err, slot = -1, nfree = 0;
 354
 355         ASSERT_WDEV_LOCK(wdev);
 356
 357         if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
 358                 if (!key || !key_len || key_idx < 0 || key_idx > 4)
 359                         return -EINVAL;
 360
 361         if (wdev->current_bss &&
 362             memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
 363                 return -EALREADY;
 364
 365         for (i = 0; i < MAX_AUTH_BSSES; i++) {
 366                 if (wdev->authtry_bsses[i] &&
 367                     memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
 368                                                 ETH_ALEN) == 0)
 369                         return -EALREADY;
 370                 if (wdev->auth_bsses[i] &&
 371                     memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
 372                                                 ETH_ALEN) == 0)
 373                         return -EALREADY;
 374         }
 375
 376         memset(&req, 0, sizeof(req));
 377
 378         req.ie = ie;
 379         req.ie_len = ie_len;
 380         req.auth_type = auth_type;
 381         req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
 382                                    WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
 383         req.key = key;
 384         req.key_len = key_len;
 385         req.key_idx = key_idx;
 386         if (!req.bss)
 387                 return -ENOENT;
 388
 389         bss = bss_from_pub(req.bss);
 390
 391         for (i = 0; i < MAX_AUTH_BSSES; i++) {
 392                 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
 393                         slot = i;
 394                         nfree++;
 395                 }
 396         }
 397
 398         /* we need one free slot for disassoc and one for this auth */
 399         if (nfree < 2) {
 400                 err = -ENOSPC;
 401                 goto out;
 402         }
 403
 404         wdev->authtry_bsses[slot] = bss;
 405         cfg80211_hold_bss(bss);
 406
 407         err = rdev->ops->auth(&rdev->wiphy, dev, &req);
 408         if (err) {
 409                 wdev->authtry_bsses[slot] = NULL;
 410                 cfg80211_unhold_bss(bss);
 411         }
 412
 413  out:
 414         if (err)
 415                 cfg80211_put_bss(req.bss);
 416         return err;
 417 }
 418
 419 int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
 420                        struct net_device *dev, struct ieee80211_channel *chan,
 421                        enum nl80211_auth_type auth_type, const u8 *bssid,
 422                        const u8 *ssid, int ssid_len,
 423                        const u8 *ie, int ie_len,
 424                        const u8 *key, int key_len, int key_idx)
 425 {
 426         int err;
 427
 428         wdev_lock(dev->ieee80211_ptr);
 429         err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
 430                                    ssid, ssid_len, ie, ie_len,
 431                                    key, key_len, key_idx);
 432         wdev_unlock(dev->ieee80211_ptr);
 433
 434         return err;
 435 }
 436
 437 int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
 438                           struct net_device *dev,
 439                           struct ieee80211_channel *chan,
 440                           const u8 *bssid, const u8 *prev_bssid,
 441                           const u8 *ssid, int ssid_len,
 442                           const u8 *ie, int ie_len, bool use_mfp,
 443                           struct cfg80211_crypto_settings *crypt)
 444 {
 445         struct wireless_dev *wdev = dev->ieee80211_ptr;
 446         struct cfg80211_assoc_request req;
 447         struct cfg80211_internal_bss *bss;
 448         int i, err, slot = -1;
 449         bool was_connected = false;
 450
 451         ASSERT_WDEV_LOCK(wdev);
 452
 453         memset(&req, 0, sizeof(req));
 454
 455         if (wdev->current_bss && prev_bssid &&
 456             memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
 457                 /*
 458                  * Trying to reassociate: Allow this to proceed and let the old
 459                  * association to be dropped when the new one is completed.
 460                  */
 461                 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
 462                         was_connected = true;
 463                         wdev->sme_state = CFG80211_SME_CONNECTING;
 464                 }
 465         } else if (wdev->current_bss)
 466                 return -EALREADY;
 467
 468         req.ie = ie;
 469         req.ie_len = ie_len;
 470         memcpy(&req.crypto, crypt, sizeof(req.crypto));
 471         req.use_mfp = use_mfp;
 472         req.prev_bssid = prev_bssid;
 473         req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
 474                                    WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
 475         if (!req.bss) {
 476                 if (was_connected)
 477                         wdev->sme_state = CFG80211_SME_CONNECTED;
 478                 return -ENOENT;
 479         }
 480
 481         bss = bss_from_pub(req.bss);
 482
 483         for (i = 0; i < MAX_AUTH_BSSES; i++) {
 484                 if (bss == wdev->auth_bsses[i]) {
 485                         slot = i;
 486                         break;
 487                 }
 488         }
 489
 490         if (slot < 0) {
 491                 err = -ENOTCONN;
 492                 goto out;
 493         }
 494
 495         err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
 496  out:
 497         if (err && was_connected)
 498                 wdev->sme_state = CFG80211_SME_CONNECTED;
 499         /* still a reference in wdev->auth_bsses[slot] */
 500         cfg80211_put_bss(req.bss);
 501         return err;
 502 }
 503
 504 int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
 505                         struct net_device *dev,
 506                         struct ieee80211_channel *chan,
 507                         const u8 *bssid, const u8 *prev_bssid,
 508                         const u8 *ssid, int ssid_len,
 509                         const u8 *ie, int ie_len, bool use_mfp,
 510                         struct cfg80211_crypto_settings *crypt)
 511 {
 512         struct wireless_dev *wdev = dev->ieee80211_ptr;
 513         int err;
 514
 515         wdev_lock(wdev);
 516         err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
 517                                     ssid, ssid_len, ie, ie_len, use_mfp, crypt);
 518         wdev_unlock(wdev);
 519
 520         return err;
 521 }
 522
 523 int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
 524                            struct net_device *dev, const u8 *bssid,
 525                            const u8 *ie, int ie_len, u16 reason)
 526 {
 527         struct wireless_dev *wdev = dev->ieee80211_ptr;
 528         struct cfg80211_deauth_request req;
 529         int i;
 530
 531         ASSERT_WDEV_LOCK(wdev);
 532
 533         memset(&req, 0, sizeof(req));
 534         req.reason_code = reason;
 535         req.ie = ie;
 536         req.ie_len = ie_len;
 537         if (wdev->current_bss &&
 538             memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
 539                 req.bss = &wdev->current_bss->pub;
 540         } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
 541                 if (wdev->auth_bsses[i] &&
 542                     memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
 543                         req.bss = &wdev->auth_bsses[i]->pub;
 544                         break;
 545                 }
 546                 if (wdev->authtry_bsses[i] &&
 547                     memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
 548                         req.bss = &wdev->authtry_bsses[i]->pub;
 549                         break;
 550                 }
 551         }
 552
 553         if (!req.bss)
 554                 return -ENOTCONN;
 555
 556         return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
 557 }
 558
 559 int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
 560                          struct net_device *dev, const u8 *bssid,
 561                          const u8 *ie, int ie_len, u16 reason)
 562 {
 563         struct wireless_dev *wdev = dev->ieee80211_ptr;
 564         int err;
 565
 566         wdev_lock(wdev);
 567         err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason);
 568         wdev_unlock(wdev);
 569
 570         return err;
 571 }
 572
 573 static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
 574                                     struct net_device *dev, const u8 *bssid,
 575                                     const u8 *ie, int ie_len, u16 reason)
 576 {
 577         struct wireless_dev *wdev = dev->ieee80211_ptr;
 578         struct cfg80211_disassoc_request req;
 579
 580         ASSERT_WDEV_LOCK(wdev);
 581
 582         if (wdev->sme_state != CFG80211_SME_CONNECTED)
 583                 return -ENOTCONN;
 584
 585         if (WARN_ON(!wdev->current_bss))
 586                 return -ENOTCONN;
 587
 588         memset(&req, 0, sizeof(req));
 589         req.reason_code = reason;
 590         req.ie = ie;
 591         req.ie_len = ie_len;
 592         if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
 593                 req.bss = &wdev->current_bss->pub;
 594         else
 595                 return -ENOTCONN;
 596
 597         return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
 598 }
 599
 600 int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
 601                            struct net_device *dev, const u8 *bssid,
 602                            const u8 *ie, int ie_len, u16 reason)
 603 {
 604         struct wireless_dev *wdev = dev->ieee80211_ptr;
 605         int err;
 606
 607         wdev_lock(wdev);
 608         err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason);
 609         wdev_unlock(wdev);
 610
 611         return err;
 612 }
 613
 614 void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
 615                         struct net_device *dev)
 616 {
 617         struct wireless_dev *wdev = dev->ieee80211_ptr;
 618         struct cfg80211_deauth_request req;
 619         int i;
 620
 621         ASSERT_WDEV_LOCK(wdev);
 622
 623         if (!rdev->ops->deauth)
 624                 return;
 625
 626         memset(&req, 0, sizeof(req));
 627         req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
 628         req.ie = NULL;
 629         req.ie_len = 0;
 630
 631         if (wdev->current_bss) {
 632                 req.bss = &wdev->current_bss->pub;
 633                 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
 634                 if (wdev->current_bss) {
 635                         cfg80211_unhold_bss(wdev->current_bss);
 636                         cfg80211_put_bss(&wdev->current_bss->pub);
 637                         wdev->current_bss = NULL;
 638                 }
 639         }
 640
 641         for (i = 0; i < MAX_AUTH_BSSES; i++) {
 642                 if (wdev->auth_bsses[i]) {
 643                         req.bss = &wdev->auth_bsses[i]->pub;
 644                         rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
 645                         if (wdev->auth_bsses[i]) {
 646                                 cfg80211_unhold_bss(wdev->auth_bsses[i]);
 647                                 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
 648                                 wdev->auth_bsses[i] = NULL;
 649                         }
 650                 }
 651                 if (wdev->authtry_bsses[i]) {
 652                         req.bss = &wdev->authtry_bsses[i]->pub;
 653                         rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
 654                         if (wdev->authtry_bsses[i]) {
 655                                 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
 656                                 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
 657                                 wdev->authtry_bsses[i] = NULL;
 658                         }
 659                 }
 660         }
 661 }