mac80211: avoid spurious deauth frames/messages
[linux-2.6.git] / 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 static void __cfg80211_auth_remove(struct wireless_dev *wdev, const u8 *addr)
247 {
248         int i;
249         bool done = false;
250
251         ASSERT_WDEV_LOCK(wdev);
252
253         for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
254                 if (wdev->authtry_bsses[i] &&
255                     memcmp(wdev->authtry_bsses[i]->pub.bssid,
256                            addr, ETH_ALEN) == 0) {
257                         cfg80211_unhold_bss(wdev->authtry_bsses[i]);
258                         cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
259                         wdev->authtry_bsses[i] = NULL;
260                         done = true;
261                         break;
262                 }
263         }
264
265         WARN_ON(!done);
266 }
267
268 void __cfg80211_auth_canceled(struct net_device *dev, const u8 *addr)
269 {
270         __cfg80211_auth_remove(dev->ieee80211_ptr, addr);
271 }
272 EXPORT_SYMBOL(__cfg80211_auth_canceled);
273
274 void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr)
275 {
276         struct wireless_dev *wdev = dev->ieee80211_ptr;
277         struct wiphy *wiphy = wdev->wiphy;
278         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
279
280         wdev_lock(wdev);
281
282         nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
283         if (wdev->sme_state == CFG80211_SME_CONNECTING)
284                 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
285                                           WLAN_STATUS_UNSPECIFIED_FAILURE,
286                                           false, NULL);
287
288         __cfg80211_auth_remove(wdev, addr);
289
290         wdev_unlock(wdev);
291 }
292 EXPORT_SYMBOL(cfg80211_send_auth_timeout);
293
294 void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr)
295 {
296         struct wireless_dev *wdev = dev->ieee80211_ptr;
297         struct wiphy *wiphy = wdev->wiphy;
298         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
299         int i;
300         bool done = false;
301
302         wdev_lock(wdev);
303
304         nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);
305         if (wdev->sme_state == CFG80211_SME_CONNECTING)
306                 __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,
307                                           WLAN_STATUS_UNSPECIFIED_FAILURE,
308                                           false, NULL);
309
310         for (i = 0; addr && i < MAX_AUTH_BSSES; i++) {
311                 if (wdev->auth_bsses[i] &&
312                     memcmp(wdev->auth_bsses[i]->pub.bssid,
313                            addr, ETH_ALEN) == 0) {
314                         cfg80211_unhold_bss(wdev->auth_bsses[i]);
315                         cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
316                         wdev->auth_bsses[i] = NULL;
317                         done = true;
318                         break;
319                 }
320         }
321
322         WARN_ON(!done);
323
324         wdev_unlock(wdev);
325 }
326 EXPORT_SYMBOL(cfg80211_send_assoc_timeout);
327
328 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
329                                   enum nl80211_key_type key_type, int key_id,
330                                   const u8 *tsc, gfp_t gfp)
331 {
332         struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
333         struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
334 #ifdef CONFIG_CFG80211_WEXT
335         union iwreq_data wrqu;
336         char *buf = kmalloc(128, gfp);
337
338         if (buf) {
339                 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
340                         "keyid=%d %scast addr=%pM)", key_id,
341                         key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
342                         addr);
343                 memset(&wrqu, 0, sizeof(wrqu));
344                 wrqu.data.length = strlen(buf);
345                 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
346                 kfree(buf);
347         }
348 #endif
349
350         nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
351 }
352 EXPORT_SYMBOL(cfg80211_michael_mic_failure);
353
354 /* some MLME handling for userspace SME */
355 int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
356                          struct net_device *dev,
357                          struct ieee80211_channel *chan,
358                          enum nl80211_auth_type auth_type,
359                          const u8 *bssid,
360                          const u8 *ssid, int ssid_len,
361                          const u8 *ie, int ie_len,
362                          const u8 *key, int key_len, int key_idx)
363 {
364         struct wireless_dev *wdev = dev->ieee80211_ptr;
365         struct cfg80211_auth_request req;
366         struct cfg80211_internal_bss *bss;
367         int i, err, slot = -1, nfree = 0;
368
369         ASSERT_WDEV_LOCK(wdev);
370
371         if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
372                 if (!key || !key_len || key_idx < 0 || key_idx > 4)
373                         return -EINVAL;
374
375         if (wdev->current_bss &&
376             memcmp(bssid, wdev->current_bss->pub.bssid, ETH_ALEN) == 0)
377                 return -EALREADY;
378
379         for (i = 0; i < MAX_AUTH_BSSES; i++) {
380                 if (wdev->authtry_bsses[i] &&
381                     memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid,
382                                                 ETH_ALEN) == 0)
383                         return -EALREADY;
384                 if (wdev->auth_bsses[i] &&
385                     memcmp(bssid, wdev->auth_bsses[i]->pub.bssid,
386                                                 ETH_ALEN) == 0)
387                         return -EALREADY;
388         }
389
390         memset(&req, 0, sizeof(req));
391
392         req.ie = ie;
393         req.ie_len = ie_len;
394         req.auth_type = auth_type;
395         req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
396                                    WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
397         req.key = key;
398         req.key_len = key_len;
399         req.key_idx = key_idx;
400         if (!req.bss)
401                 return -ENOENT;
402
403         bss = bss_from_pub(req.bss);
404
405         for (i = 0; i < MAX_AUTH_BSSES; i++) {
406                 if (!wdev->auth_bsses[i] && !wdev->authtry_bsses[i]) {
407                         slot = i;
408                         nfree++;
409                 }
410         }
411
412         /* we need one free slot for disassoc and one for this auth */
413         if (nfree < 2) {
414                 err = -ENOSPC;
415                 goto out;
416         }
417
418         wdev->authtry_bsses[slot] = bss;
419         cfg80211_hold_bss(bss);
420
421         err = rdev->ops->auth(&rdev->wiphy, dev, &req);
422         if (err) {
423                 wdev->authtry_bsses[slot] = NULL;
424                 cfg80211_unhold_bss(bss);
425         }
426
427  out:
428         if (err)
429                 cfg80211_put_bss(req.bss);
430         return err;
431 }
432
433 int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
434                        struct net_device *dev, struct ieee80211_channel *chan,
435                        enum nl80211_auth_type auth_type, const u8 *bssid,
436                        const u8 *ssid, int ssid_len,
437                        const u8 *ie, int ie_len,
438                        const u8 *key, int key_len, int key_idx)
439 {
440         int err;
441
442         wdev_lock(dev->ieee80211_ptr);
443         err = __cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
444                                    ssid, ssid_len, ie, ie_len,
445                                    key, key_len, key_idx);
446         wdev_unlock(dev->ieee80211_ptr);
447
448         return err;
449 }
450
451 int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
452                           struct net_device *dev,
453                           struct ieee80211_channel *chan,
454                           const u8 *bssid, const u8 *prev_bssid,
455                           const u8 *ssid, int ssid_len,
456                           const u8 *ie, int ie_len, bool use_mfp,
457                           struct cfg80211_crypto_settings *crypt)
458 {
459         struct wireless_dev *wdev = dev->ieee80211_ptr;
460         struct cfg80211_assoc_request req;
461         struct cfg80211_internal_bss *bss;
462         int i, err, slot = -1;
463         bool was_connected = false;
464
465         ASSERT_WDEV_LOCK(wdev);
466
467         memset(&req, 0, sizeof(req));
468
469         if (wdev->current_bss && prev_bssid &&
470             memcmp(wdev->current_bss->pub.bssid, prev_bssid, ETH_ALEN) == 0) {
471                 /*
472                  * Trying to reassociate: Allow this to proceed and let the old
473                  * association to be dropped when the new one is completed.
474                  */
475                 if (wdev->sme_state == CFG80211_SME_CONNECTED) {
476                         was_connected = true;
477                         wdev->sme_state = CFG80211_SME_CONNECTING;
478                 }
479         } else if (wdev->current_bss)
480                 return -EALREADY;
481
482         req.ie = ie;
483         req.ie_len = ie_len;
484         memcpy(&req.crypto, crypt, sizeof(req.crypto));
485         req.use_mfp = use_mfp;
486         req.prev_bssid = prev_bssid;
487         req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
488                                    WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
489         if (!req.bss) {
490                 if (was_connected)
491                         wdev->sme_state = CFG80211_SME_CONNECTED;
492                 return -ENOENT;
493         }
494
495         bss = bss_from_pub(req.bss);
496
497         for (i = 0; i < MAX_AUTH_BSSES; i++) {
498                 if (bss == wdev->auth_bsses[i]) {
499                         slot = i;
500                         break;
501                 }
502         }
503
504         if (slot < 0) {
505                 err = -ENOTCONN;
506                 goto out;
507         }
508
509         err = rdev->ops->assoc(&rdev->wiphy, dev, &req);
510  out:
511         if (err && was_connected)
512                 wdev->sme_state = CFG80211_SME_CONNECTED;
513         /* still a reference in wdev->auth_bsses[slot] */
514         cfg80211_put_bss(req.bss);
515         return err;
516 }
517
518 int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
519                         struct net_device *dev,
520                         struct ieee80211_channel *chan,
521                         const u8 *bssid, const u8 *prev_bssid,
522                         const u8 *ssid, int ssid_len,
523                         const u8 *ie, int ie_len, bool use_mfp,
524                         struct cfg80211_crypto_settings *crypt)
525 {
526         struct wireless_dev *wdev = dev->ieee80211_ptr;
527         int err;
528
529         wdev_lock(wdev);
530         err = __cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
531                                     ssid, ssid_len, ie, ie_len, use_mfp, crypt);
532         wdev_unlock(wdev);
533
534         return err;
535 }
536
537 int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
538                            struct net_device *dev, const u8 *bssid,
539                            const u8 *ie, int ie_len, u16 reason)
540 {
541         struct wireless_dev *wdev = dev->ieee80211_ptr;
542         struct cfg80211_deauth_request req;
543         int i;
544
545         ASSERT_WDEV_LOCK(wdev);
546
547         memset(&req, 0, sizeof(req));
548         req.reason_code = reason;
549         req.ie = ie;
550         req.ie_len = ie_len;
551         if (wdev->current_bss &&
552             memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0) {
553                 req.bss = &wdev->current_bss->pub;
554         } else for (i = 0; i < MAX_AUTH_BSSES; i++) {
555                 if (wdev->auth_bsses[i] &&
556                     memcmp(bssid, wdev->auth_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
557                         req.bss = &wdev->auth_bsses[i]->pub;
558                         break;
559                 }
560                 if (wdev->authtry_bsses[i] &&
561                     memcmp(bssid, wdev->authtry_bsses[i]->pub.bssid, ETH_ALEN) == 0) {
562                         req.bss = &wdev->authtry_bsses[i]->pub;
563                         break;
564                 }
565         }
566
567         if (!req.bss)
568                 return -ENOTCONN;
569
570         return rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
571 }
572
573 int cfg80211_mlme_deauth(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         int err;
579
580         wdev_lock(wdev);
581         err = __cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason);
582         wdev_unlock(wdev);
583
584         return err;
585 }
586
587 static int __cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
588                                     struct net_device *dev, const u8 *bssid,
589                                     const u8 *ie, int ie_len, u16 reason)
590 {
591         struct wireless_dev *wdev = dev->ieee80211_ptr;
592         struct cfg80211_disassoc_request req;
593
594         ASSERT_WDEV_LOCK(wdev);
595
596         if (wdev->sme_state != CFG80211_SME_CONNECTED)
597                 return -ENOTCONN;
598
599         if (WARN_ON(!wdev->current_bss))
600                 return -ENOTCONN;
601
602         memset(&req, 0, sizeof(req));
603         req.reason_code = reason;
604         req.ie = ie;
605         req.ie_len = ie_len;
606         if (memcmp(wdev->current_bss->pub.bssid, bssid, ETH_ALEN) == 0)
607                 req.bss = &wdev->current_bss->pub;
608         else
609                 return -ENOTCONN;
610
611         return rdev->ops->disassoc(&rdev->wiphy, dev, &req, wdev);
612 }
613
614 int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
615                            struct net_device *dev, const u8 *bssid,
616                            const u8 *ie, int ie_len, u16 reason)
617 {
618         struct wireless_dev *wdev = dev->ieee80211_ptr;
619         int err;
620
621         wdev_lock(wdev);
622         err = __cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason);
623         wdev_unlock(wdev);
624
625         return err;
626 }
627
628 void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
629                         struct net_device *dev)
630 {
631         struct wireless_dev *wdev = dev->ieee80211_ptr;
632         struct cfg80211_deauth_request req;
633         int i;
634
635         ASSERT_WDEV_LOCK(wdev);
636
637         if (!rdev->ops->deauth)
638                 return;
639
640         memset(&req, 0, sizeof(req));
641         req.reason_code = WLAN_REASON_DEAUTH_LEAVING;
642         req.ie = NULL;
643         req.ie_len = 0;
644
645         if (wdev->current_bss) {
646                 req.bss = &wdev->current_bss->pub;
647                 rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
648                 if (wdev->current_bss) {
649                         cfg80211_unhold_bss(wdev->current_bss);
650                         cfg80211_put_bss(&wdev->current_bss->pub);
651                         wdev->current_bss = NULL;
652                 }
653         }
654
655         for (i = 0; i < MAX_AUTH_BSSES; i++) {
656                 if (wdev->auth_bsses[i]) {
657                         req.bss = &wdev->auth_bsses[i]->pub;
658                         rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
659                         if (wdev->auth_bsses[i]) {
660                                 cfg80211_unhold_bss(wdev->auth_bsses[i]);
661                                 cfg80211_put_bss(&wdev->auth_bsses[i]->pub);
662                                 wdev->auth_bsses[i] = NULL;
663                         }
664                 }
665                 if (wdev->authtry_bsses[i]) {
666                         req.bss = &wdev->authtry_bsses[i]->pub;
667                         rdev->ops->deauth(&rdev->wiphy, dev, &req, wdev);
668                         if (wdev->authtry_bsses[i]) {
669                                 cfg80211_unhold_bss(wdev->authtry_bsses[i]);
670                                 cfg80211_put_bss(&wdev->authtry_bsses[i]->pub);
671                                 wdev->authtry_bsses[i] = NULL;
672                         }
673                 }
674         }
675 }